frostfs-node/pkg/services/object_manager/placement/traverser_test.go
Alex Vanin f354b8a270
All checks were successful
Build / Build Components (1.20) (pull_request) Successful in 3m52s
Build / Build Components (1.19) (pull_request) Successful in 4m8s
ci/woodpecker/pr/pre-commit Pipeline was successful
Tests and linters / Lint (pull_request) Successful in 9m3s
Tests and linters / Tests with -race (pull_request) Successful in 5m27s
Tests and linters / Tests (1.20) (pull_request) Successful in 6m18s
Tests and linters / Tests (1.19) (pull_request) Successful in 13m54s
ci/woodpecker/push/pre-commit Pipeline was successful
[#473] Add tests for rem values of traverser
Signed-off-by: Alex Vanin <a.vanin@yadro.com>
2023-07-05 20:13:23 +03:00

262 lines
5.8 KiB
Go

package placement
import (
"strconv"
"testing"
netmapcore "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/core/netmap"
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/network"
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container"
cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
"github.com/stretchr/testify/require"
)
type testBuilder struct {
vectors [][]netmap.NodeInfo
}
func (b testBuilder) BuildPlacement(cid.ID, *oid.ID, netmap.PlacementPolicy) ([][]netmap.NodeInfo, error) {
return b.vectors, nil
}
func testNode(v uint32) (n netmap.NodeInfo) {
n.SetNetworkEndpoints("/ip4/0.0.0.0/tcp/" + strconv.Itoa(int(v)))
return n
}
func copyVectors(v [][]netmap.NodeInfo) [][]netmap.NodeInfo {
vc := make([][]netmap.NodeInfo, 0, len(v))
for i := range v {
ns := make([]netmap.NodeInfo, len(v[i]))
copy(ns, v[i])
vc = append(vc, ns)
}
return vc
}
func testPlacement(t *testing.T, ss, rs []int) ([][]netmap.NodeInfo, container.Container) {
nodes := make([][]netmap.NodeInfo, 0, len(rs))
replicas := make([]netmap.ReplicaDescriptor, 0, len(rs))
num := uint32(0)
for i := range ss {
ns := make([]netmap.NodeInfo, 0, ss[i])
for j := 0; j < ss[i]; j++ {
ns = append(ns, testNode(num))
num++
}
nodes = append(nodes, ns)
var rd netmap.ReplicaDescriptor
rd.SetNumberOfObjects(uint32(rs[i]))
replicas = append(replicas, rd)
}
var policy netmap.PlacementPolicy
policy.AddReplicas(replicas...)
var cnr container.Container
cnr.SetPlacementPolicy(policy)
return nodes, cnr
}
func assertSameAddress(t *testing.T, ni netmap.NodeInfo, addr network.AddressGroup) {
var netAddr network.AddressGroup
err := netAddr.FromIterator(netmapcore.Node(ni))
require.NoError(t, err)
require.True(t, netAddr.Intersects(addr))
}
func TestTraverserObjectScenarios(t *testing.T) {
t.Run("search scenario", func(t *testing.T) {
selectors := []int{2, 3}
replicas := []int{1, 2}
nodes, cnr := testPlacement(t, selectors, replicas)
nodesCopy := copyVectors(nodes)
tr, err := NewTraverser(
ForContainer(cnr),
UseBuilder(&testBuilder{vectors: nodesCopy}),
WithoutSuccessTracking(),
)
require.NoError(t, err)
for i := range selectors {
addrs := tr.Next()
require.Len(t, addrs, len(nodes[i]))
for j, n := range nodes[i] {
assertSameAddress(t, n, addrs[j].Addresses())
}
}
require.Empty(t, tr.Next())
require.True(t, tr.Success())
})
t.Run("read scenario", func(t *testing.T) {
selectors := []int{5, 3}
replicas := []int{2, 2}
nodes, cnr := testPlacement(t, selectors, replicas)
nodesCopy := copyVectors(nodes)
tr, err := NewTraverser(
ForContainer(cnr),
UseBuilder(&testBuilder{
vectors: nodesCopy,
}),
SuccessAfter(1),
)
require.NoError(t, err)
for i := 0; i < len(nodes[0]); i++ {
require.NotNil(t, tr.Next())
}
var n network.AddressGroup
err = n.FromIterator(netmapcore.Node(nodes[1][0]))
require.NoError(t, err)
require.Equal(t, []Node{{addresses: n}}, tr.Next())
})
t.Run("put scenario", func(t *testing.T) {
selectors := []int{5, 3}
replicas := []int{2, 2}
nodes, cnr := testPlacement(t, selectors, replicas)
nodesCopy := copyVectors(nodes)
tr, err := NewTraverser(
ForContainer(cnr),
UseBuilder(&testBuilder{vectors: nodesCopy}),
)
require.NoError(t, err)
fn := func(curVector int) {
for i := 0; i+replicas[curVector] < selectors[curVector]; i += replicas[curVector] {
addrs := tr.Next()
require.Len(t, addrs, replicas[curVector])
for j := range addrs {
assertSameAddress(t, nodes[curVector][i+j], addrs[j].Addresses())
}
}
require.Empty(t, tr.Next())
require.False(t, tr.Success())
for i := 0; i < replicas[curVector]; i++ {
tr.SubmitSuccess()
}
}
for i := range selectors {
fn(i)
if i < len(selectors)-1 {
require.False(t, tr.Success())
} else {
require.True(t, tr.Success())
}
}
})
t.Run("local operation scenario", func(t *testing.T) {
selectors := []int{2, 3}
replicas := []int{1, 2}
nodes, cnr := testPlacement(t, selectors, replicas)
tr, err := NewTraverser(
ForContainer(cnr),
UseBuilder(&testBuilder{
vectors: [][]netmap.NodeInfo{{nodes[1][1]}}, // single node (local)
}),
SuccessAfter(1),
)
require.NoError(t, err)
require.NotEmpty(t, tr.Next())
require.False(t, tr.Success())
// add 1 OK
tr.SubmitSuccess()
// nothing more to do
require.Empty(t, tr.Next())
// common success
require.True(t, tr.Success())
})
}
func TestTraverserRemValues(t *testing.T) {
selectors := []int{3, 4, 5}
replicas := []int{2, 3, 4}
nodes, cnr := testPlacement(t, selectors, replicas)
nodesCopy := copyVectors(nodes)
testCases := [...]struct {
name string
copyNumbers []uint32
expectedRem []int
}{
{
name: "zero copy numbers",
copyNumbers: []uint32{},
expectedRem: replicas,
},
{
name: "compatible zero copy numbers",
copyNumbers: []uint32{0},
expectedRem: replicas,
},
{
name: "copy numbers for all replicas",
copyNumbers: []uint32{1, 1, 1},
expectedRem: []int{1, 1, 1},
},
{
name: "single copy numbers for multiple replicas",
copyNumbers: []uint32{1},
expectedRem: []int{1}, // may be a bit unexpected
},
{
name: "multiple copy numbers for multiple replicas",
copyNumbers: []uint32{1, 1},
expectedRem: []int{1, 1, 4},
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
tr, err := NewTraverser(
ForContainer(cnr),
UseBuilder(&testBuilder{vectors: nodesCopy}),
WithCopyNumbers(testCase.copyNumbers),
)
require.NoError(t, err)
require.Equal(t, testCase.expectedRem, tr.rem)
})
}
}