def get_pod_storage_pools(self, with_available=False):
"""Get the storage pools information."""
pools = []
for pool in self.list_pools():
output = self.run(['pool-dumpxml', pool]).strip()
if output is None:
# Skip if cannot get more information.
continue
doc = etree.XML(output)
evaluator = etree.XPathEvaluator(doc)
pool_capacity = int(evaluator(XPATH_POOL_CAPACITY)[0].text)
pool_path = evaluator(XPATH_POOL_PATH)[0].text
pool_type = evaluator(XPATH_POOL_TYPE)[0]
pool_uuid = evaluator(XPATH_POOL_UUID)[0].text
pool = DiscoveredPodStoragePool(id=pool_uuid,
name=pool,
path=pool_path,
type=pool_type,
storage=pool_capacity)
if with_available:
# Use `setattr` because `DiscoveredPodStoragePool` doesn't have
# an available attribute and its only needed for the driver
# to perform calculations. This prevents this information from
# being sent to the region, which isn't needed.
pool_available = int(evaluator(XPATH_POOL_AVAILABLE)[0].text)
setattr(pool, 'available', pool_available)
pools.append(pool)
return pools
def fake_pod_discovery(self):
discovered_pod = DiscoveredPod(
architectures=['amd64/generic'],
cores=random.randint(2, 4), memory=random.randint(1024, 4096),
local_storage=random.randint(1024, 1024 * 1024),
cpu_speed=random.randint(2048, 4048),
hints=DiscoveredPodHints(
cores=random.randint(2, 4), memory=random.randint(1024, 4096),
local_storage=random.randint(1024, 1024 * 1024),
cpu_speed=random.randint(2048, 4048)),
storage_pools=[
DiscoveredPodStoragePool(
id=factory.make_name('pool_id'),
name=factory.make_name('name'),
type=factory.make_name('type'),
path='/var/lib/path/%s' % factory.make_name('path'),
storage=random.randint(1024, 1024 * 1024),
)
for _ in range(3)
])
discovered_rack_1 = factory.make_RackController()
discovered_rack_2 = factory.make_RackController()
failed_rack = factory.make_RackController()
self.patch(pods_module, "discover_pod").return_value = ({
discovered_rack_1.system_id: discovered_pod,
discovered_rack_2.system_id: discovered_pod,
}, {
failed_rack.system_id: factory.make_exception(),
})
return (
discovered_pod,
[discovered_rack_1, discovered_rack_2],
[failed_rack])
def _get_discovered_pod_storage_pool(self, storage_pool):
"""Get the Pod storage pool."""
storage_pool_config = storage_pool.config
# Sometimes the config is empty, use get() method on the dictionary in case.
storage_pool_path = storage_pool_config.get("source")
storage_pool_resources = storage_pool.resources.get()
total_storage = storage_pool_resources.space["total"]
return DiscoveredPodStoragePool(
# No ID's with LXD so we are just using the name as the ID.
id=storage_pool.name,
name=storage_pool.name,
path=storage_pool_path,
type=storage_pool.driver,
storage=total_storage,
)
def test_pod_asdict(self):
hostname = factory.make_name("hostname")
cores = random.randint(1, 8)
cpu_speed = random.randint(1000, 2000)
memory = random.randint(4096, 8192)
local_storage = random.randint(4096, 8192)
local_disks = random.randint(1, 8)
iscsi_storage = random.randint(4096, 8192)
hints = DiscoveredPodHints(
cores=random.randint(1, 8),
cpu_speed=random.randint(1000, 2000),
memory=random.randint(4096, 8192),
local_storage=random.randint(4096, 8192),
local_disks=random.randint(1, 8),
iscsi_storage=random.randint(4096, 8192),
)
machines = []
tags = [factory.make_name("tag") for _ in range(3)]
storage_pools = [
DiscoveredPodStoragePool(
id=factory.make_name("id"),
name=factory.make_name("name"),
storage=random.randint(4096, 8192),
type="dir",
path="/var/%s" % factory.make_name("dir"),
) for _ in range(3)
]
for _ in range(3):
cores = random.randint(1, 8)
cpu_speed = random.randint(1000, 2000)
memory = random.randint(4096, 8192)
power_state = factory.make_name("unknown")
power_parameters = {"power_id": factory.make_name("power_id")}
interfaces = [
DiscoveredMachineInterface(
mac_address=factory.make_mac_address()) for _ in range(3)
]
block_devices = [
DiscoveredMachineBlockDevice(
model=factory.make_name("model"),
serial=factory.make_name("serial"),
size=random.randint(512, 1024),
id_path=factory.make_name("/dev/vda"),
) for _ in range(3)
]
for _ in range(3):
block_devices.append(
DiscoveredMachineBlockDevice(
model=None,
serial=None,
size=random.randint(512, 1024),
type=BlockDeviceType.ISCSI,
iscsi_target=self.make_iscsi_target(),
storage_pool=factory.make_name("pool"),
))
tags = [factory.make_name("tag") for _ in range(3)]
machines.append(
DiscoveredMachine(
hostname=hostname,
architecture="amd64/generic",
cores=cores,
cpu_speed=cpu_speed,
memory=memory,
power_state=power_state,
power_parameters=power_parameters,
interfaces=interfaces,
block_devices=block_devices,
tags=tags,
))
pod = DiscoveredPod(
architectures=["amd64/generic"],
cores=cores,
cpu_speed=cpu_speed,
memory=memory,
local_storage=local_storage,
local_disks=local_disks,
iscsi_storage=iscsi_storage,
hints=hints,
machines=machines,
tags=tags,
storage_pools=storage_pools,
)
self.assertThat(
pod.asdict(),
MatchesDict({
"architectures":
Equals(["amd64/generic"]),
"name":
Equals(None),
"cores":
Equals(cores),
"cpu_speed":
Equals(cpu_speed),
"memory":
Equals(memory),
"local_storage":
Equals(local_storage),
"local_disks":
Equals(local_disks),
"iscsi_storage":
Equals(iscsi_storage),
"mac_addresses":
Equals([]),
"capabilities":
Equals(pod.capabilities),
"hints":
MatchesDict({
"cores": Equals(hints.cores),
"cpu_speed": Equals(hints.cpu_speed),
"memory": Equals(hints.memory),
"local_storage": Equals(hints.local_storage),
"local_disks": Equals(hints.local_disks),
"iscsi_storage": Equals(hints.iscsi_storage),
}),
"machines":
MatchesListwise([
MatchesDict({
"hostname":
Equals(machine.hostname),
"architecture":
Equals("amd64/generic"),
"cores":
Equals(machine.cores),
"cpu_speed":
Equals(machine.cpu_speed),
"memory":
Equals(machine.memory),
"power_state":
Equals(machine.power_state),
"power_parameters":
Equals(machine.power_parameters),
"interfaces":
MatchesListwise([
MatchesDict({
"mac_address":
Equals(interface.mac_address),
"vid":
Equals(interface.vid),
"tags":
Equals(interface.tags),
"boot":
Equals(False),
"attach_type":
Is(None),
"attach_name":
Is(None),
}) for interface in machine.interfaces
]),
"block_devices":
MatchesListwise([
MatchesDict({
"model":
Equals(block_device.model),
"serial":
Equals(block_device.serial),
"size":
Equals(block_device.size),
"block_size":
Equals(block_device.block_size),
"tags":
Equals(block_device.tags),
"id_path":
Equals(block_device.id_path),
"type":
Equals(block_device.type),
"iscsi_target":
Equals(block_device.iscsi_target),
"storage_pool":
Equals(block_device.storage_pool),
}) for block_device in machine.block_devices
]),
"tags":
Equals(machine.tags),
}) for machine in machines
]),
"tags":
Equals(tags),
"storage_pools":
MatchesListwise([
MatchesDict({
"id": Equals(pool.id),
"name": Equals(pool.name),
"storage": Equals(pool.storage),
"type": Equals(pool.type),
"path": Equals(pool.path),
}) for pool in storage_pools
]),
}),
)