370 lines
No EOL
10 KiB
Go
370 lines
No EOL
10 KiB
Go
package backend
|
|
|
|
import (
|
|
"apiserver/models"
|
|
"apiserver/store"
|
|
"testing"
|
|
)
|
|
|
|
// resetStores reinitializes all global stores for test isolation.
|
|
func resetStores() {
|
|
store.InitStores()
|
|
}
|
|
|
|
func TestOnHostConfigUpdated_UnregisteredHostIgnored(t *testing.T) {
|
|
// Config-only entries (e.g. "default", hosts whose daemons haven't started)
|
|
// must not be inserted into the Hosts store. Only OnHostUpdated (worker push) creates entries.
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
h.OnHostConfigUpdated(&models.HostInfo{
|
|
HostName: "node01",
|
|
HostModel: "x86_64",
|
|
HostType: "LINUX64",
|
|
MaxSlot: 8,
|
|
})
|
|
|
|
_, ok := store.Hosts.Get("node01")
|
|
if ok {
|
|
t.Error("OnHostConfigUpdated must not create a new host entry; only workers can register hosts")
|
|
}
|
|
}
|
|
|
|
func TestOnHostConfigUpdated_DefaultPseudoHostIgnored(t *testing.T) {
|
|
// The "default" host is a cluster-wide config sentinel, never a real worker.
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
h.OnHostConfigUpdated(&models.HostInfo{
|
|
HostName: "default",
|
|
HostType: "x86_64-linux-gnu",
|
|
MaxSlot: -1,
|
|
})
|
|
|
|
_, ok := store.Hosts.Get("default")
|
|
if ok {
|
|
t.Error("OnHostConfigUpdated must not create an entry for the 'default' pseudo-host")
|
|
}
|
|
}
|
|
|
|
func TestOnHostConfigUpdated_PartialMerge(t *testing.T) {
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
// Simulate a prior worker push that set worker-sourced fields.
|
|
store.Hosts.Put("node01", models.HostInfo{
|
|
HostName: "node01",
|
|
HostStatus: 0x00010000, // UNAVAIL
|
|
CPUFactor: 2.5,
|
|
NumCPUs: 32,
|
|
MaxMem: 131072,
|
|
NumRun: 5,
|
|
})
|
|
|
|
// Config push arrives — should merge config fields, preserve worker fields.
|
|
h.OnHostConfigUpdated(&models.HostInfo{
|
|
HostName: "node01",
|
|
HostModel: "modelA",
|
|
HostType: "CENTOS7",
|
|
MaxSlot: 16,
|
|
})
|
|
|
|
got, ok := store.Hosts.Get("node01")
|
|
if !ok {
|
|
t.Fatal("host node01 should exist after merge")
|
|
}
|
|
// Config-sourced fields taken from the push.
|
|
if got.HostModel != "modelA" {
|
|
t.Errorf("HostModel: got %q, want %q", got.HostModel, "modelA")
|
|
}
|
|
if got.HostType != "CENTOS7" {
|
|
t.Errorf("HostType: got %q, want %q", got.HostType, "CENTOS7")
|
|
}
|
|
if got.MaxSlot != 16 {
|
|
t.Errorf("MaxSlot: got %d, want 16", got.MaxSlot)
|
|
}
|
|
// Worker-sourced fields preserved from the prior entry.
|
|
if got.HostStatus != 0x00010000 {
|
|
t.Errorf("HostStatus: got 0x%08X, want 0x00010000 (should be preserved)", got.HostStatus)
|
|
}
|
|
if got.CPUFactor != 2.5 {
|
|
t.Errorf("CPUFactor: got %f, want 2.5 (should be preserved)", got.CPUFactor)
|
|
}
|
|
if got.NumCPUs != 32 {
|
|
t.Errorf("NumCPUs: got %d, want 32 (should be preserved)", got.NumCPUs)
|
|
}
|
|
if got.MaxMem != 131072 {
|
|
t.Errorf("MaxMem: got %d, want 131072 (should be preserved)", got.MaxMem)
|
|
}
|
|
if got.NumRun != 5 {
|
|
t.Errorf("NumRun: got %d, want 5 (should be preserved)", got.NumRun)
|
|
}
|
|
}
|
|
|
|
func TestOnClusterUpdated_NewCluster(t *testing.T) {
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
cluster := &models.ClusterInfo{
|
|
ClusterName: "mycluster",
|
|
HeartbeatInterval: 30,
|
|
Vcpus: 16,
|
|
InactiveHeartbeatCount: 3,
|
|
}
|
|
|
|
h.OnClusterUpdated(cluster)
|
|
|
|
got, ok := store.Clusters.Get("mycluster")
|
|
if !ok {
|
|
t.Fatal("cluster mycluster should exist in store after OnClusterUpdated")
|
|
}
|
|
if got.HeartbeatInterval != 30 {
|
|
t.Errorf("HeartbeatInterval: got %d, want 30", got.HeartbeatInterval)
|
|
}
|
|
if got.Vcpus != 16 {
|
|
t.Errorf("Vcpus: got %d, want 16", got.Vcpus)
|
|
}
|
|
if got.InactiveHeartbeatCount != 3 {
|
|
t.Errorf("InactiveHeartbeatCount: got %d, want 3", got.InactiveHeartbeatCount)
|
|
}
|
|
}
|
|
|
|
func TestOnClusterUpdated_PartialMerge(t *testing.T) {
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
// Simulate built-in data loaded at startup.
|
|
store.Clusters.Put("mycluster", models.ClusterInfo{
|
|
ClusterName: "mycluster",
|
|
Version: "10.1.0",
|
|
Status: 0x01, // CONNECTED
|
|
ControllerName: "ctrl01",
|
|
NumServers: 3,
|
|
})
|
|
|
|
// Config push arrives — should merge config fields, preserve built-in fields.
|
|
h.OnClusterUpdated(&models.ClusterInfo{
|
|
ClusterName: "mycluster",
|
|
HeartbeatInterval: 45,
|
|
Vcpus: 64,
|
|
InactiveHeartbeatCount: 5,
|
|
})
|
|
|
|
got, ok := store.Clusters.Get("mycluster")
|
|
if !ok {
|
|
t.Fatal("cluster mycluster should exist after merge")
|
|
}
|
|
// Config-sourced fields from the push.
|
|
if got.HeartbeatInterval != 45 {
|
|
t.Errorf("HeartbeatInterval: got %d, want 45", got.HeartbeatInterval)
|
|
}
|
|
if got.Vcpus != 64 {
|
|
t.Errorf("Vcpus: got %d, want 64", got.Vcpus)
|
|
}
|
|
if got.InactiveHeartbeatCount != 5 {
|
|
t.Errorf("InactiveHeartbeatCount: got %d, want 5", got.InactiveHeartbeatCount)
|
|
}
|
|
// Built-in fields preserved.
|
|
if got.Version != "10.1.0" {
|
|
t.Errorf("Version: got %q, want %q (should be preserved)", got.Version, "10.1.0")
|
|
}
|
|
if got.Status != 0x01 {
|
|
t.Errorf("Status: got 0x%02X, want 0x01 (should be preserved)", got.Status)
|
|
}
|
|
if got.ControllerName != "ctrl01" {
|
|
t.Errorf("ControllerName: got %q, want %q (should be preserved)", got.ControllerName, "ctrl01")
|
|
}
|
|
if got.NumServers != 3 {
|
|
t.Errorf("NumServers: got %d, want 3 (should be preserved)", got.NumServers)
|
|
}
|
|
}
|
|
|
|
func TestOnHostUpdated_PartialMerge(t *testing.T) {
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
// Simulate a prior config push that set config-sourced fields.
|
|
store.Hosts.Put("node01", models.HostInfo{
|
|
HostName: "node01",
|
|
HostModel: "x86_64",
|
|
HostType: "LINUX64",
|
|
MaxSlot: 8,
|
|
DisptWindow: "always",
|
|
})
|
|
|
|
// Worker push arrives — should merge worker fields, preserve config fields.
|
|
h.OnHostUpdated(&models.HostInfo{
|
|
HostName: "node01",
|
|
HostStatus: 3,
|
|
CPUFactor: 1.8,
|
|
NumCPUs: 16,
|
|
MaxMem: 65536,
|
|
NumRun: 2,
|
|
})
|
|
|
|
got, ok := store.Hosts.Get("node01")
|
|
if !ok {
|
|
t.Fatal("host node01 should exist after merge")
|
|
}
|
|
// Worker-sourced fields from the push.
|
|
if got.HostStatus != 3 {
|
|
t.Errorf("HostStatus: got %d, want 3", got.HostStatus)
|
|
}
|
|
if got.CPUFactor != 1.8 {
|
|
t.Errorf("CPUFactor: got %f, want 1.8", got.CPUFactor)
|
|
}
|
|
if got.NumCPUs != 16 {
|
|
t.Errorf("NumCPUs: got %d, want 16", got.NumCPUs)
|
|
}
|
|
if got.MaxMem != 65536 {
|
|
t.Errorf("MaxMem: got %d, want 65536", got.MaxMem)
|
|
}
|
|
if got.NumRun != 2 {
|
|
t.Errorf("NumRun: got %d, want 2", got.NumRun)
|
|
}
|
|
// Config-sourced fields preserved.
|
|
if got.HostModel != "x86_64" {
|
|
t.Errorf("HostModel: got %q, want %q (should be preserved)", got.HostModel, "x86_64")
|
|
}
|
|
if got.HostType != "LINUX64" {
|
|
t.Errorf("HostType: got %q, want %q (should be preserved)", got.HostType, "LINUX64")
|
|
}
|
|
if got.MaxSlot != 8 {
|
|
t.Errorf("MaxSlot: got %d, want 8 (should be preserved)", got.MaxSlot)
|
|
}
|
|
if got.DisptWindow != "always" {
|
|
t.Errorf("DisptWindow: got %q, want %q (should be preserved)", got.DisptWindow, "always")
|
|
}
|
|
}
|
|
|
|
func TestOnHostUpdated_NewHost(t *testing.T) {
|
|
resetStores()
|
|
h := DefaultHandler{}
|
|
|
|
// No prior entry in store — first push is from worker.
|
|
h.OnHostUpdated(&models.HostInfo{
|
|
HostName: "node05",
|
|
HostStatus: 1,
|
|
CPUFactor: 3.0,
|
|
})
|
|
|
|
got, ok := store.Hosts.Get("node05")
|
|
if !ok {
|
|
t.Fatal("host node05 should exist after first push")
|
|
}
|
|
if got.HostStatus != 1 {
|
|
t.Errorf("HostStatus: got %d, want 1", got.HostStatus)
|
|
}
|
|
}
|
|
|
|
func TestDispatchConfigPush_MergesConfigOntoRegisteredHosts(t *testing.T) {
|
|
// Config push should merge onto hosts already registered by workers, and
|
|
// silently skip any host not yet in the store (e.g. "default", offline workers).
|
|
resetStores()
|
|
h := &DefaultHandler{}
|
|
|
|
// Simulate worker registration arriving before config push.
|
|
store.Hosts.Put("node01", models.HostInfo{HostName: "node01", NumCPUs: 32})
|
|
store.Hosts.Put("node02", models.HostInfo{HostName: "node02", NumCPUs: 64})
|
|
|
|
hosts := []models.HostInfo{
|
|
{HostName: "node01", HostModel: "x86_64", HostType: "LINUX64", MaxSlot: 4},
|
|
{HostName: "node02", HostModel: "arm64", HostType: "LINUX64", MaxSlot: 8},
|
|
{HostName: "default", HostModel: "x86_64", HostType: "LINUX64", MaxSlot: -1},
|
|
}
|
|
|
|
dispatchConfigPush(h, nil, nil, hosts, nil)
|
|
|
|
got1, ok1 := store.Hosts.Get("node01")
|
|
if !ok1 {
|
|
t.Fatal("node01 should remain in store after dispatchConfigPush")
|
|
}
|
|
if got1.HostModel != "x86_64" {
|
|
t.Errorf("node01 HostModel: got %q, want x86_64", got1.HostModel)
|
|
}
|
|
if got1.MaxSlot != 4 {
|
|
t.Errorf("node01 MaxSlot: got %d, want 4", got1.MaxSlot)
|
|
}
|
|
if got1.NumCPUs != 32 {
|
|
t.Errorf("node01 NumCPUs: got %d, want 32 (worker field must be preserved)", got1.NumCPUs)
|
|
}
|
|
|
|
got2, ok2 := store.Hosts.Get("node02")
|
|
if !ok2 {
|
|
t.Fatal("node02 should remain in store after dispatchConfigPush")
|
|
}
|
|
if got2.HostModel != "arm64" {
|
|
t.Errorf("node02 HostModel: got %q, want arm64", got2.HostModel)
|
|
}
|
|
if got2.MaxSlot != 8 {
|
|
t.Errorf("node02 MaxSlot: got %d, want 8", got2.MaxSlot)
|
|
}
|
|
|
|
if _, ok := store.Hosts.Get("default"); ok {
|
|
t.Error("'default' pseudo-host must not be inserted by config push")
|
|
}
|
|
if n := store.Hosts.Count(); n != 2 {
|
|
t.Errorf("Hosts store should have exactly 2 entries, got %d", n)
|
|
}
|
|
}
|
|
|
|
func TestDispatchConfigPush_CallsOnClusterUpdated(t *testing.T) {
|
|
resetStores()
|
|
h := &DefaultHandler{}
|
|
|
|
cluster := &models.ClusterInfo{
|
|
ClusterName: "mycluster",
|
|
HeartbeatInterval: 30,
|
|
Vcpus: 64,
|
|
InactiveHeartbeatCount: 5,
|
|
}
|
|
|
|
dispatchConfigPush(h, nil, nil, nil, cluster)
|
|
|
|
got, ok := store.Clusters.Get("mycluster")
|
|
if !ok {
|
|
t.Fatal("mycluster should be in store after dispatchConfigPush")
|
|
}
|
|
if got.HeartbeatInterval != 30 {
|
|
t.Errorf("HeartbeatInterval: got %d, want 30", got.HeartbeatInterval)
|
|
}
|
|
if got.Vcpus != 64 {
|
|
t.Errorf("Vcpus: got %d, want 64", got.Vcpus)
|
|
}
|
|
if got.InactiveHeartbeatCount != 5 {
|
|
t.Errorf("InactiveHeartbeatCount: got %d, want 5", got.InactiveHeartbeatCount)
|
|
}
|
|
}
|
|
|
|
func TestDispatchConfigPush_NilClusterIsSkipped(t *testing.T) {
|
|
resetStores()
|
|
h := &DefaultHandler{}
|
|
|
|
dispatchConfigPush(h, nil, nil, nil, nil)
|
|
|
|
if n := store.Clusters.Count(); n != 0 {
|
|
t.Errorf("Clusters store should be empty when cluster is nil, got %d entries", n)
|
|
}
|
|
}
|
|
|
|
func TestDispatchConfigPush_EmptySlicesNoOp(t *testing.T) {
|
|
resetStores()
|
|
h := &DefaultHandler{}
|
|
|
|
dispatchConfigPush(h,
|
|
[]models.QueueInfo{},
|
|
[]models.ResourceDefinitionInfo{},
|
|
[]models.HostInfo{},
|
|
nil,
|
|
)
|
|
|
|
if n := store.Hosts.Count(); n != 0 {
|
|
t.Errorf("Hosts store should be empty, got %d entries", n)
|
|
}
|
|
if n := store.Queues.Count(); n != 0 {
|
|
t.Errorf("Queues store should be empty, got %d entries", n)
|
|
}
|
|
if n := store.Clusters.Count(); n != 0 {
|
|
t.Errorf("Clusters store should be empty, got %d entries", n)
|
|
}
|
|
} |