Anton Nikiforov
78e4d71cc0
All checks were successful
Tests and linters / Run gofumpt (pull_request) Successful in 1m30s
DCO action / DCO (pull_request) Successful in 1m42s
Vulncheck / Vulncheck (pull_request) Successful in 2m1s
Pre-commit hooks / Pre-commit (pull_request) Successful in 2m13s
Build / Build Components (pull_request) Successful in 2m25s
Tests and linters / gopls check (pull_request) Successful in 2m42s
Tests and linters / Staticcheck (pull_request) Successful in 2m48s
Tests and linters / Lint (pull_request) Successful in 3m38s
Tests and linters / Tests (pull_request) Successful in 4m18s
Tests and linters / Tests with -race (pull_request) Successful in 5m18s
Signed-off-by: Anton Nikiforov <an.nikiforov@yadro.com>
474 lines
12 KiB
Go
474 lines
12 KiB
Go
package placement
|
|
|
|
import (
|
|
"strconv"
|
|
"testing"
|
|
|
|
netmapAPI "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/netmap"
|
|
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) {
|
|
ip := "/ip4/0.0.0.0/tcp/" + strconv.Itoa(int(v))
|
|
n.SetNetworkEndpoints(ip)
|
|
n.SetPublicKey([]byte(ip))
|
|
|
|
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(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 range ss[i] {
|
|
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(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(selectors, replicas)
|
|
|
|
nodesCopy := copyVectors(nodes)
|
|
|
|
tr, err := NewTraverser(
|
|
ForContainer(cnr),
|
|
UseBuilder(&testBuilder{
|
|
vectors: nodesCopy,
|
|
}),
|
|
SuccessAfter(1),
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
for range len(nodes[0]) {
|
|
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, key: []byte("/ip4/0.0.0.0/tcp/5")}}, tr.Next())
|
|
})
|
|
|
|
t.Run("put scenario", func(t *testing.T) {
|
|
selectors := []int{5, 3}
|
|
replicas := []int{2, 2}
|
|
|
|
nodes, cnr := testPlacement(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 range replicas[curVector] {
|
|
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(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(selectors, replicas)
|
|
nodesCopy := copyVectors(nodes)
|
|
|
|
testCases := [...]struct {
|
|
name string
|
|
copyNumbers []uint32
|
|
expectedRem []int
|
|
expectedErr error
|
|
}{
|
|
{
|
|
name: "zero copy numbers",
|
|
copyNumbers: []uint32{},
|
|
expectedRem: replicas,
|
|
},
|
|
{
|
|
name: "compatible zero copy numbers, len 1",
|
|
copyNumbers: []uint32{0},
|
|
expectedRem: replicas,
|
|
},
|
|
{
|
|
name: "compatible zero copy numbers, len 3",
|
|
copyNumbers: []uint32{0, 0, 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, 4},
|
|
expectedRem: []int{1, 1, 4},
|
|
},
|
|
{
|
|
name: "incompatible copies number vector",
|
|
copyNumbers: []uint32{1, 1},
|
|
expectedErr: errCopiesNumberLen,
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
tr, err := NewTraverser(
|
|
ForContainer(cnr),
|
|
UseBuilder(&testBuilder{vectors: nodesCopy}),
|
|
WithCopyNumbers(testCase.copyNumbers),
|
|
)
|
|
if testCase.expectedErr == nil {
|
|
require.NoError(t, err, testCase.name)
|
|
require.Equal(t, testCase.expectedRem, tr.rem, testCase.name)
|
|
} else {
|
|
require.Error(t, err, testCase.expectedErr, testCase.name)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type nodeState struct {
|
|
node *netmapAPI.NodeInfo
|
|
}
|
|
|
|
func (n *nodeState) LocalNodeInfo() (*netmapAPI.NodeInfo, error) {
|
|
return n.node, nil
|
|
}
|
|
|
|
func TestTraverserPriorityMetrics(t *testing.T) {
|
|
t.Run("one rep one metric", func(t *testing.T) {
|
|
selectors := []int{4}
|
|
replicas := []int{3}
|
|
|
|
nodes, cnr := testPlacement(selectors, replicas)
|
|
|
|
nodes[0][0].SetAttribute("ClusterName", "A")
|
|
nodes[0][1].SetAttribute("ClusterName", "A")
|
|
nodes[0][2].SetAttribute("ClusterName", "B")
|
|
nodes[0][3].SetAttribute("ClusterName", "B")
|
|
|
|
sdkNode := testNode(5)
|
|
sdkNode.SetAttribute("ClusterName", "B")
|
|
nodeAPI := &netmapAPI.NodeInfo{}
|
|
sdkNode.WriteToV2(nodeAPI)
|
|
|
|
nodesCopy := copyVectors(nodes)
|
|
|
|
m := []Metric{NewAttributeMetric("$attribute:ClusterName")}
|
|
|
|
tr, err := NewTraverser(
|
|
ForContainer(cnr),
|
|
UseBuilder(&testBuilder{
|
|
vectors: nodesCopy,
|
|
}),
|
|
WithoutSuccessTracking(),
|
|
WithPriorityMetrics(m),
|
|
WithNodeState(&nodeState{
|
|
node: nodeAPI,
|
|
}),
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
next := tr.Next()
|
|
require.NotNil(t, next)
|
|
require.Equal(t, 3, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/2", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/0", string(next[1].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/1", string(next[2].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Equal(t, 1, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/3", string(next[0].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Nil(t, next)
|
|
})
|
|
|
|
t.Run("two reps two metrics", func(t *testing.T) {
|
|
selectors := []int{3, 3}
|
|
replicas := []int{2, 2}
|
|
|
|
nodes, cnr := testPlacement(selectors, replicas)
|
|
|
|
nodes[0][0].SetAttribute("ClusterName", "A")
|
|
nodes[0][0].SetAttribute("UN-LOCODE", "RU LED")
|
|
|
|
nodes[0][1].SetAttribute("ClusterName", "A")
|
|
nodes[0][1].SetAttribute("UN-LOCODE", "FI HEL")
|
|
|
|
nodes[0][2].SetAttribute("ClusterName", "A")
|
|
nodes[0][2].SetAttribute("UN-LOCODE", "RU LED")
|
|
|
|
nodes[1][0].SetAttribute("ClusterName", "B")
|
|
nodes[1][0].SetAttribute("UN-LOCODE", "RU MOW")
|
|
|
|
nodes[1][1].SetAttribute("ClusterName", "B")
|
|
nodes[1][1].SetAttribute("UN-LOCODE", "RU DME")
|
|
|
|
nodes[1][2].SetAttribute("ClusterName", "B")
|
|
nodes[1][2].SetAttribute("UN-LOCODE", "RU MOW")
|
|
|
|
sdkNode := testNode(9)
|
|
sdkNode.SetAttribute("ClusterName", "B")
|
|
sdkNode.SetAttribute("UN-LOCODE", "RU DME")
|
|
nodeAPI := &netmapAPI.NodeInfo{}
|
|
sdkNode.WriteToV2(nodeAPI)
|
|
|
|
nodesCopy := copyVectors(nodes)
|
|
|
|
m := []Metric{
|
|
NewAttributeMetric("$attribute:ClusterName"),
|
|
NewAttributeMetric("$attribute:UN-LOCODE"),
|
|
}
|
|
|
|
tr, err := NewTraverser(
|
|
ForContainer(cnr),
|
|
UseBuilder(&testBuilder{
|
|
vectors: nodesCopy,
|
|
}),
|
|
WithoutSuccessTracking(),
|
|
WithPriorityMetrics(m),
|
|
WithNodeState(&nodeState{
|
|
node: nodeAPI,
|
|
}),
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
next := tr.Next()
|
|
require.Equal(t, 4, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/4", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/3", string(next[1].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/0", string(next[2].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/1", string(next[3].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Equal(t, 2, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/2", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/5", string(next[1].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Nil(t, next)
|
|
|
|
sdkNode.SetAttribute("ClusterName", "B")
|
|
sdkNode.SetAttribute("UN-LOCODE", "RU MOW")
|
|
nodeAPI = &netmapAPI.NodeInfo{}
|
|
sdkNode.WriteToV2(nodeAPI)
|
|
|
|
nodesCopy = copyVectors(nodes)
|
|
|
|
tr, err = NewTraverser(
|
|
ForContainer(cnr),
|
|
UseBuilder(&testBuilder{
|
|
vectors: nodesCopy,
|
|
}),
|
|
WithoutSuccessTracking(),
|
|
WithPriorityMetrics(m),
|
|
WithNodeState(&nodeState{
|
|
node: nodeAPI,
|
|
}),
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
next = tr.Next()
|
|
require.Equal(t, 4, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/3", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/4", string(next[1].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/0", string(next[2].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/1", string(next[3].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Equal(t, 2, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/2", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/5", string(next[1].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Nil(t, next)
|
|
|
|
sdkNode.SetAttribute("ClusterName", "A")
|
|
sdkNode.SetAttribute("UN-LOCODE", "RU LED")
|
|
nodeAPI = &netmapAPI.NodeInfo{}
|
|
sdkNode.WriteToV2(nodeAPI)
|
|
|
|
nodesCopy = copyVectors(nodes)
|
|
|
|
tr, err = NewTraverser(
|
|
ForContainer(cnr),
|
|
UseBuilder(&testBuilder{
|
|
vectors: nodesCopy,
|
|
}),
|
|
WithoutSuccessTracking(),
|
|
WithPriorityMetrics(m),
|
|
WithNodeState(&nodeState{
|
|
node: nodeAPI,
|
|
}),
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
next = tr.Next()
|
|
require.Equal(t, 4, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/0", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/1", string(next[1].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/3", string(next[2].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/4", string(next[3].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Equal(t, 2, len(next))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/2", string(next[0].PublicKey()))
|
|
require.Equal(t, "/ip4/0.0.0.0/tcp/5", string(next[1].PublicKey()))
|
|
|
|
next = tr.Next()
|
|
require.Nil(t, next)
|
|
})
|
|
}
|