forked from rook/rook
129 lines
4.8 KiB
Go
129 lines
4.8 KiB
Go
/*
|
|
Copyright 2016 The Rook Authors. All rights reserved.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
package inventory
|
|
|
|
import (
|
|
"path"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/rook/rook/pkg/util"
|
|
"github.com/rook/rook/pkg/util/sys"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestLoadDiscoveredNodes(t *testing.T) {
|
|
etcdClient := &util.MockEtcdClient{}
|
|
|
|
// Create some test config
|
|
etcdClient.SetValue(path.Join(NodesConfigKey, "23", "publicIp"), "1.2.3.4")
|
|
etcdClient.SetValue(path.Join(NodesConfigKey, "23", "privateIp"), "10.2.3.4")
|
|
etcdClient.SetValue(path.Join(NodesConfigKey, "46", "publicIp"), "4.5.6.7")
|
|
etcdClient.SetValue(path.Join(NodesConfigKey, "46", "privateIp"), "10.5.6.7")
|
|
|
|
config, err := LoadDiscoveredNodes(etcdClient)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 2, len(config.Nodes))
|
|
assert.Equal(t, "1.2.3.4", config.Nodes["23"].PublicIP)
|
|
assert.Equal(t, "10.2.3.4", config.Nodes["23"].PrivateIP)
|
|
assert.Equal(t, "4.5.6.7", config.Nodes["46"].PublicIP)
|
|
assert.Equal(t, "10.5.6.7", config.Nodes["46"].PrivateIP)
|
|
assert.Equal(t, time.Hour*24*365, config.Nodes["23"].HeartbeatAge) // no heartbeat has an age of a year
|
|
|
|
desiredPublicIP := "9.8.7.6"
|
|
desiredPrivateIP := "10.7.6.7"
|
|
err = SetIPAddress(etcdClient, "23", desiredPublicIP, desiredPrivateIP)
|
|
assert.Nil(t, err)
|
|
|
|
config, err = LoadDiscoveredNodes(etcdClient)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 2, len(config.Nodes))
|
|
assert.Equal(t, "9.8.7.6", config.Nodes["23"].PublicIP)
|
|
assert.Equal(t, "10.7.6.7", config.Nodes["23"].PrivateIP)
|
|
assert.Equal(t, "4.5.6.7", config.Nodes["46"].PublicIP)
|
|
assert.Equal(t, "10.5.6.7", config.Nodes["46"].PrivateIP)
|
|
}
|
|
|
|
func TestLoadHardwareConfig(t *testing.T) {
|
|
nodeID := "12345"
|
|
etcdClient := util.NewMockEtcdClient()
|
|
|
|
// setup disk info in etcd
|
|
d1 := &LocalDisk{Name: "sda", UUID: "uuid1", Size: 10737418240, Rotational: true, Readonly: false, Type: sys.DiskType, HasChildren: true}
|
|
d1.Empty = getDeviceEmpty(d1)
|
|
d2 := &LocalDisk{Name: "sda2", UUID: "uuid2", Size: 2097152, Rotational: false, Readonly: true, Type: sys.PartType, HasChildren: false}
|
|
err := storeDevices(etcdClient, nodeID, []*LocalDisk{d1, d2})
|
|
assert.Nil(t, err)
|
|
|
|
// setup processor info in etcd
|
|
p1 := &ProcessorConfig{ID: 0, PhysicalID: 3, Siblings: 1, CoreID: 6, NumCores: 1, Speed: 1234.56, Bits: 64}
|
|
p2 := &ProcessorConfig{ID: 1, PhysicalID: 4, Siblings: 2, CoreID: 7, NumCores: 2, Speed: 8000.00, Bits: 32}
|
|
p3 := &ProcessorConfig{ID: 2, PhysicalID: 5, Siblings: 0, CoreID: 8, NumCores: 4, Speed: 4000.01, Bits: 32}
|
|
err = storeProcessorConfig(etcdClient, nodeID, []*ProcessorConfig{p1, p2, p3})
|
|
assert.Nil(t, err)
|
|
|
|
// setup memory info in etcd
|
|
mem := getSystemMemory()
|
|
err = storeMemory(etcdClient, nodeID, mem)
|
|
assert.Nil(t, err)
|
|
|
|
// set up network info in etcd
|
|
n1 := &NetworkConfig{Name: "eth0", IPv4Address: "172.17.42.1/16", IPv6Address: "fe80::42:4aff:fefe:13d7/64", Speed: 0}
|
|
n2 := &NetworkConfig{Name: "veth2b6453a", IPv6Address: "fe80::7c0f:acff:feff:478d/64", Speed: 10000}
|
|
err = storeNetworkConfig(etcdClient, nodeID, []*NetworkConfig{n1, n2})
|
|
assert.Nil(t, err)
|
|
|
|
// set IP address in etcd
|
|
publicIP := "10.0.0.43"
|
|
privateIP := "10.2.3.4"
|
|
SetIPAddress(etcdClient, nodeID, publicIP, privateIP)
|
|
|
|
// set location in etcd
|
|
SetLocation(etcdClient, nodeID, "root=default,dc=datacenter1")
|
|
|
|
// load the discovered node config
|
|
nodeConfig, err := loadNodeConfig(etcdClient)
|
|
assert.Nil(t, err, "loaded node config error should be nil")
|
|
assert.NotNil(t, nodeConfig, "loaded node config should not be nil")
|
|
assert.Equal(t, 1, len(nodeConfig))
|
|
|
|
cfg := nodeConfig[nodeID]
|
|
|
|
// verify the single disk (the partition is not saved)
|
|
assert.Equal(t, 1, len(cfg.Disks))
|
|
assert.True(t, cfg.Disks[0].Empty)
|
|
assert.Equal(t, d1.Rotational, cfg.Disks[0].Rotational)
|
|
assert.Equal(t, d1.Size, cfg.Disks[0].Size)
|
|
assert.Equal(t, d1.Type, cfg.Disks[0].Type)
|
|
|
|
// verify the processors
|
|
assert.Equal(t, 3, len(cfg.Processors))
|
|
|
|
// verify the network adapters
|
|
assert.Equal(t, 2, len(cfg.NetworkAdapters))
|
|
|
|
// verify the simple values
|
|
assert.Equal(t, mem, cfg.Memory)
|
|
assert.Equal(t, "10.0.0.43", cfg.PublicIP)
|
|
assert.Equal(t, "root=default,dc=datacenter1", cfg.Location)
|
|
|
|
// verify that some values are in etcd
|
|
key := path.Join(NodesConfigKey, nodeID)
|
|
assert.Equal(t, publicIP, etcdClient.GetValue(path.Join(key, publicIpAddressKey)))
|
|
assert.Equal(t, privateIP, etcdClient.GetValue(path.Join(key, privateIpAddressKey)))
|
|
|
|
}
|