Merge ~newell-jensen/maas:lxd-pod-driver-discovery into maas:master

[Newell Jensen]

Discover Pod storage pools and machines during the Pod adding/refresh process so that machines not known to MAAS are commissioned.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b lxd-pod-driver-discovery lp:~newell-jensen/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/7356/console
COMMIT: 4d2cd8ddd424eaa39f60eed59be92e81b35f570d

review: Needs Fixing

[Lee Trager (ltrager)]

I think this branch also needs to configure an LXD profile for MAAS use if one isn't already created. Otherwise compose won't know which storage pool or parent interface to use when composing a machine.

Also a couple of questions below.

[Newell Jensen (newell-jensen)]

The LXD profile is going to be included with the branch that does compose and decompose, which this branch does not do. This branch is for adding discovered resources.

See inline for my responses on items that I don't agree or an explanation is needed (will change the others).

[MAAS Lander (maas-lander)]

UNIT TESTS
-b lxd-pod-driver-discovery lp:~newell-jensen/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 208674ac978485f90b72e35b351ab9ba432e18bb

review: Approve

[Lee Trager (ltrager)]

Looks good, just a couple of things inline. I think we should ask stgraber about the vid but we can get that in a later branch.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b lxd-pod-driver-discovery lp:~newell-jensen/maas/+git/maas into -b master lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 93c1d03c6041a1119ae1b3d8045f760696d9309b

review: Approve

[Lee Trager (ltrager)]

Thanks for the fixes! LGTM!

review: Approve

diff --git a/src/provisioningserver/drivers/pod/lxd.py b/src/provisioningserver/drivers/pod/lxd.py
index 28c441f..70a1cbb 100644
--- a/src/provisioningserver/drivers/pod/lxd.py
+++ b/src/provisioningserver/drivers/pod/lxd.py
@@ -20,20 +20,32 @@ from provisioningserver.drivers import (
 )
 from provisioningserver.drivers.pod import (
     Capabilities,
+    DiscoveredMachine,
+    DiscoveredMachineBlockDevice,
+    DiscoveredMachineInterface,
     DiscoveredPod,
+    DiscoveredPodStoragePool,
     PodDriver,
 )
+from provisioningserver.logger import get_maas_logger
 from provisioningserver.maas_certificates import (
     MAAS_CERTIFICATE,
     MAAS_PRIVATE_KEY,
 )
 from provisioningserver.utils import kernel_to_debian_architecture, typed
+from provisioningserver.utils.ipaddr import get_vid_from_ifname
+from provisioningserver.utils.twisted import asynchronous
 
-# LXD Status Codes
+maaslog = get_maas_logger("drivers.pod.lxd")
+
+# LXD status codes
 LXD_VM_POWER_STATE = {101: "on", 102: "off", 103: "on", 110: "off"}
 
+# LXD vm disk path
+LXD_VM_ID_PATH = "/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_lxd_"
+
 
-class LXDError(Exception):
+class LXDPodError(Exception):
     """Failure communicating to LXD. """
 
 
@@ -86,8 +98,8 @@ class LXDPodDriver(PodDriver):
 
     @typed
     @inlineCallbacks
-    def get_client(self, system_id: str, context: dict):
-        """Connect and return PyLXD client."""
+    def get_client(self, pod_id: str, context: dict):
+        """Connect pylxd client."""
         endpoint = self.get_url(context)
         password = context.get("password")
         try:
@@ -101,62 +113,165 @@ class LXDPodDriver(PodDriver):
                 if password:
                     yield deferToThread(client.authenticate, password)
                 else:
-                    raise LXDError(
-                        f"{system_id}: Certificate is not trusted and no password was given."
+                    raise LXDPodError(
+                        f"Pod {pod_id}: Certificate is not trusted and no password was given."
                     )
-            return client
         except ClientConnectionFailed:
-            raise LXDError(
-                f"{system_id}: Failed to connect to the LXD REST API."
+            raise LXDPodError(
+                f"Pod {pod_id}: Failed to connect to the LXD REST API."
             )
+        return client
 
     @typed
     @inlineCallbacks
-    def get_machine(self, system_id: str, context: dict):
+    def get_machine(self, pod_id: str, context: dict):
         """Retrieve LXD VM."""
-        client = yield self.get_client(system_id, context)
+        client = yield self.get_client(pod_id, context)
         instance_name = context.get("instance_name")
         try:
             machine = yield deferToThread(
                 client.virtual_machines.get, instance_name
             )
         except NotFound:
-            raise LXDError(f"{system_id}: LXD VM {instance_name} not found.")
+            raise LXDPodError(
+                f"Pod {pod_id}: LXD VM {instance_name} not found."
+            )
         return machine
 
+    def get_discovered_machine(
+        self, machine, storage_pools, request=None, cpu_speed=0
+    ):
+        """Get the discovered machine."""
+        # Check the power state first.
+        state = machine.status_code
+        try:
+            power_state = LXD_VM_POWER_STATE[state]
+        except KeyError:
+            maaslog.error(
+                f"{machine.name}: Unknown power status code: {state}"
+            )
+            power_state = "unknown"
+
+        expanded_config = machine.expanded_config
+        expanded_devices = machine.expanded_devices
+
+        # Discover block devices.
+        block_devices = []
+        for idx, device in enumerate(expanded_devices):
+            # Block device.
+            # When request is provided map the tags from the request block
+            # devices to the discovered block devices. This ensures that
+            # composed machine has the requested tags on the block device.
+            tags = []
+            if request is not None:
+                tags = request.block_devices[idx].tags
+
+            device_info = expanded_devices[device]
+            if device_info["type"] == "disk":
+                # Default disk size is 10GB.
+                size = device_info.get("size", 10 * 1000 ** 3)
+                pool = device_info.get("pool")
+                block_devices.append(
+                    DiscoveredMachineBlockDevice(
+                        model=None,
+                        serial=None,
+                        id_path=LXD_VM_ID_PATH + device,
+                        size=size,
+                        tags=tags,
+                        storage_pool=pool,
+                    )
+                )
+
+        # Discover interfaces.
+        interfaces = []
+        boot = True
+        for configuration in expanded_config:
+            if configuration.endswith("hwaddr"):
+                mac = expanded_config[configuration]
+                name = configuration.split(".")[1]
+                nictype = expanded_devices[name]["nictype"]
+                interfaces.append(
+                    DiscoveredMachineInterface(
+                        mac_address=mac,
+                        vid=get_vid_from_ifname(name),
+                        boot=boot,
+                        attach_type=nictype,
+                        attach_name=name,
+                    )
+                )
+                boot = False
+
+        return DiscoveredMachine(
+            hostname=machine.name,
+            architecture=kernel_to_debian_architecture(machine.architecture),
+            # 1 core and 1GiB of memory (we need it in MiB) is default for
+            # LXD if not specified.
+            cores=int(expanded_config.get("limits.cpu", 1)),
+            memory=int(expanded_config.get("limits.memory", 1024)),
+            cpu_speed=cpu_speed,
+            interfaces=interfaces,
+            block_devices=block_devices,
+            power_state=power_state,
+            power_parameters={"instance_name": machine.name},
+            tags=[],
+        )
+
+    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,
+        )
+
     @typed
+    @asynchronous
     @inlineCallbacks
-    def power_on(self, system_id: str, context: dict):
+    def power_on(self, pod_id: str, context: dict):
         """Power on LXD VM."""
-        machine = yield deferToThread(self.get_machine, system_id, context)
+        machine = yield self.get_machine(pod_id, context)
         if LXD_VM_POWER_STATE[machine.status_code] == "off":
             yield deferToThread(machine.start)
 
     @typed
+    @asynchronous
     @inlineCallbacks
-    def power_off(self, system_id: str, context: dict):
+    def power_off(self, pod_id: str, context: dict):
         """Power off LXD VM."""
-        machine = yield deferToThread(self.get_machine, system_id, context)
+        machine = yield self.get_machine(pod_id, context)
         if LXD_VM_POWER_STATE[machine.status_code] == "on":
             yield deferToThread(machine.stop)
 
     @typed
+    @asynchronous
     @inlineCallbacks
-    def power_query(self, system_id: str, context: dict):
+    def power_query(self, pod_id: str, context: dict):
         """Power query LXD VM."""
-        machine = yield deferToThread(self.get_machine, system_id, context)
+        machine = yield self.get_machine(pod_id, context)
         state = machine.status_code
         try:
             return LXD_VM_POWER_STATE[state]
         except KeyError:
-            raise LXDError(f"{system_id}: Unknown power status code: {state}")
+            raise LXDPodError(
+                f"Pod {pod_id}: Unknown power status code: {state}"
+            )
 
     @inlineCallbacks
     def discover(self, pod_id, context):
         """Discover all Pod host resources."""
+        # Connect to the Pod and make sure it is valid.
         client = yield self.get_client(pod_id, context)
         if not client.has_api_extension("virtual-machines"):
-            raise LXDError(
+            raise LXDPodError(
                 "Please upgrade your LXD host to 3.19+ for virtual machine support."
             )
         resources = yield deferToThread(lambda: client.resources)
@@ -168,7 +283,7 @@ class LXDPodDriver(PodDriver):
 
         # After the region creates the Pod object it will sync LXD commissioning
         # data for all hardware information.
-        return DiscoveredPod(
+        discovered_pod = DiscoveredPod(
             architectures=[
                 kernel_to_debian_architecture(arch)
                 for arch in client.host_info["environment"]["architectures"]
@@ -183,14 +298,46 @@ class LXDPodDriver(PodDriver):
             ],
         )
 
+        # Check that we have at least one storage pool.  If not, create it.
+        pools = yield deferToThread(client.storage_pools.all)
+        if not len(pools):
+            yield deferToThread(
+                client.storage_pools.create, {"name": "maas", "driver": "dir"}
+            )
+
+        # Discover Storage Pools.
+        pools = []
+        storage_pools = yield deferToThread(client.storage_pools.all)
+        for storage_pool in storage_pools:
+            discovered_storage_pool = self.get_discovered_pod_storage_pool(
+                storage_pool
+            )
+            pools.append(discovered_storage_pool)
+        discovered_pod.storage_pools = pools
+
+        # Discover VMs.
+        machines = []
+        virtual_machines = yield deferToThread(client.virtual_machines.all)
+        for virtual_machine in virtual_machines:
+            discovered_machine = self.get_discovered_machine(
+                virtual_machine,
+                storage_pools=discovered_pod.storage_pools,
+                cpu_speed=discovered_pod.cpu_speed,
+            )
+            machines.append(discovered_machine)
+        discovered_pod.machines = machines
+
+        # Return the DiscoveredPod.
+        return discovered_pod
+
     @inlineCallbacks
-    def compose(self, system_id, context, request):
+    def compose(self, pod_id, context, request):
         """Compose a virtual machine."""
         # abstract method, will update in subsequent branch.
         pass
 
     @inlineCallbacks
-    def decompose(self, system_id, context):
+    def decompose(self, pod_id, context):
         """Decompose a virtual machine machine."""
         # abstract method, will update in subsequent branch.
         pass
diff --git a/src/provisioningserver/drivers/pod/tests/test_lxd.py b/src/provisioningserver/drivers/pod/tests/test_lxd.py
index 904c7af..7c81873 100644
--- a/src/provisioningserver/drivers/pod/tests/test_lxd.py
+++ b/src/provisioningserver/drivers/pod/tests/test_lxd.py
@@ -8,23 +8,20 @@ __all__ = []
 from os.path import join
 from unittest.mock import Mock
 
-from testtools.matchers import Equals
+from testtools.matchers import Equals, MatchesStructure
 from testtools.testcase import ExpectedException
 from twisted.internet.defer import inlineCallbacks
 
-# XXX - Remove provisioningserver.drivers.power from testing in this file
-# and rename lxd_pod_module.
 from maastesting.factory import factory
 from maastesting.matchers import MockCalledOnceWith
 from maastesting.testcase import MAASTestCase, MAASTwistedRunTest
 from provisioningserver.drivers.pod import Capabilities
 from provisioningserver.drivers.pod import lxd as lxd_pod_module
-from provisioningserver.drivers.pod.lxd import LXDPodDriver
-from provisioningserver.drivers.power import lxd as lxd_module
 from provisioningserver.maas_certificates import (
     MAAS_CERTIFICATE,
     MAAS_PRIVATE_KEY,
 )
+from provisioningserver.utils import kernel_to_debian_architecture
 
 
 class TestLXDPodDriver(MAASTestCase):
@@ -32,7 +29,7 @@ class TestLXDPodDriver(MAASTestCase):
     run_tests_with = MAASTwistedRunTest.make_factory(timeout=5)
 
     def test_missing_packages(self):
-        driver = LXDPodDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         missing = driver.detect_missing_packages()
         self.assertItemsEqual([], missing)
 
@@ -56,7 +53,7 @@ class TestLXDPodDriver(MAASTestCase):
         )
 
     def test_get_url(self):
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         context = {"power_address": factory.make_hostname()}
 
         # Test ip adds protocol and port
@@ -86,15 +83,13 @@ class TestLXDPodDriver(MAASTestCase):
     @inlineCallbacks
     def test__get_client(self):
         context = self.make_parameters_context()
-        Client = self.patch(lxd_module, "Client")
+        Client = self.patch(lxd_pod_module, "Client")
         client = Client.return_value
         client.has_api_extension.return_value = True
         client.trusted = False
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         endpoint = driver.get_url(context)
-        returned_client = yield driver.get_client(
-            factory.make_name("system_id"), context
-        )
+        returned_client = yield driver.get_client(None, context)
         self.assertThat(
             Client,
             MockCalledOnceWith(
@@ -112,111 +107,109 @@ class TestLXDPodDriver(MAASTestCase):
     def test_get_client_raises_error_when_not_trusted_and_no_password(self):
         context = self.make_parameters_context()
         context["password"] = None
-        system_id = factory.make_name("system_id")
-        Client = self.patch(lxd_module, "Client")
+        pod_id = factory.make_name("pod_id")
+        Client = self.patch(lxd_pod_module, "Client")
         client = Client.return_value
-        client.has_api_extension.return_value = True
         client.trusted = False
-        driver = lxd_module.LXDPowerDriver()
-        error_msg = f"{system_id}: Certificate is not trusted and no password was given."
-        with ExpectedException(lxd_module.LXDError, error_msg):
-            yield driver.get_machine(system_id, context)
-        self.assertThat(
-            client.has_api_extension, MockCalledOnceWith("virtual-machines")
-        )
+        driver = lxd_pod_module.LXDPodDriver()
+        error_msg = f"Pod {pod_id}: Certificate is not trusted and no password was given."
+        with ExpectedException(lxd_pod_module.LXDPodError, error_msg):
+            yield driver.get_client(pod_id, context)
 
     @inlineCallbacks
     def test_get_client_raises_error_when_cannot_connect(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
-        Client = self.patch(lxd_module, "Client")
-        Client.side_effect = lxd_module.ClientConnectionFailed()
-        driver = lxd_module.LXDPowerDriver()
-        error_msg = f"{system_id}: Failed to connect to the LXD REST API."
-        with ExpectedException(lxd_module.LXDError, error_msg):
-            yield driver.get_client(system_id, context)
+        pod_id = factory.make_name("pod_id")
+        Client = self.patch(lxd_pod_module, "Client")
+        Client.side_effect = lxd_pod_module.ClientConnectionFailed()
+        driver = lxd_pod_module.LXDPodDriver()
+        error_msg = f"Pod {pod_id}: Failed to connect to the LXD REST API."
+        with ExpectedException(lxd_pod_module.LXDPodError, error_msg):
+            yield driver.get_client(pod_id, context)
 
     @inlineCallbacks
     def test__get_machine(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         Client = self.patch(driver, "get_client")
         client = Client.return_value
         mock_machine = Mock()
         client.virtual_machines.get.return_value = mock_machine
-        returned_machine = yield driver.get_machine(system_id, context)
-        self.assertThat(Client, MockCalledOnceWith(system_id, context))
+        returned_machine = yield driver.get_machine(None, context)
+        self.assertThat(Client, MockCalledOnceWith(None, context))
         self.assertEquals(mock_machine, returned_machine)
 
     @inlineCallbacks
     def test_get_machine_raises_error_when_machine_not_found(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
+        pod_id = factory.make_name("pod_id")
         instance_name = context.get("instance_name")
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         Client = self.patch(driver, "get_client")
         client = Client.return_value
-        client.virtual_machines.get.side_effect = lxd_module.NotFound("Error")
-        error_msg = f"{system_id}: LXD VM {instance_name} not found."
-        with ExpectedException(lxd_module.LXDError, error_msg):
-            yield driver.get_machine(system_id, context)
+        client.virtual_machines.get.side_effect = lxd_pod_module.NotFound(
+            "Error"
+        )
+        error_msg = f"Pod {pod_id}: LXD VM {instance_name} not found."
+        with ExpectedException(lxd_pod_module.LXDPodError, error_msg):
+            yield driver.get_machine(pod_id, context)
 
     @inlineCallbacks
     def test__power_on(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         mock_machine = self.patch(driver, "get_machine").return_value
         mock_machine.status_code = 110
-        yield driver.power_on(system_id, context)
+        yield driver.power_on(None, context)
         self.assertThat(mock_machine.start, MockCalledOnceWith())
 
     @inlineCallbacks
     def test__power_off(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         mock_machine = self.patch(driver, "get_machine").return_value
         mock_machine.status_code = 103
-        yield driver.power_off(system_id, context)
+        yield driver.power_off(None, context)
         self.assertThat(mock_machine.stop, MockCalledOnceWith())
 
     @inlineCallbacks
     def test__power_query(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
-        driver = lxd_module.LXDPowerDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         mock_machine = self.patch(driver, "get_machine").return_value
         mock_machine.status_code = 103
-        state = yield driver.power_query(system_id, context)
+        state = yield driver.power_query(None, context)
         self.assertThat(state, Equals("on"))
 
     @inlineCallbacks
-    def test__power_query_raises_error_on_unknown_state(self):
+    def test_power_query_raises_error_on_unknown_state(self):
         context = self.make_parameters_context()
-        system_id = factory.make_name("system_id")
-        driver = lxd_module.LXDPowerDriver()
+        pod_id = factory.make_name("pod_id")
+        driver = lxd_pod_module.LXDPodDriver()
         mock_machine = self.patch(driver, "get_machine").return_value
         mock_machine.status_code = 106
-        error_msg = f"{system_id}: Unknown power status code: {mock_machine.status_code}"
-        with ExpectedException(lxd_module.LXDError, error_msg):
-            yield driver.power_query(system_id, context)
+        error_msg = f"Pod {pod_id}: Unknown power status code: {mock_machine.status_code}"
+        with ExpectedException(lxd_pod_module.LXDPodError, error_msg):
+            yield driver.power_query(pod_id, context)
 
     @inlineCallbacks
-    def test__discover_requires_client_to_have_vm_support(self):
+    def test_discover_requires_client_to_have_vm_support(self):
         context = self.make_parameters_context()
-        driver = LXDPodDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         Client = self.patch(lxd_pod_module, "Client")
         client = Client.return_value
         client.has_api_extension.return_value = False
-        with ExpectedException(lxd_pod_module.LXDError):
+        error_msg = "Please upgrade your LXD host to *."
+        with ExpectedException(lxd_pod_module.LXDPodError, error_msg):
             yield driver.discover(None, context)
+        self.assertThat(
+            client.has_api_extension, MockCalledOnceWith("virtual-machines")
+        )
 
     @inlineCallbacks
     def test__discover(self):
         context = self.make_parameters_context()
-        driver = LXDPodDriver()
+        driver = lxd_pod_module.LXDPodDriver()
         Client = self.patch(lxd_pod_module, "Client")
         client = Client.return_value
         client.has_api_extension.return_value = True
@@ -260,3 +253,188 @@ class TestLXDPodDriver(MAASTestCase):
         self.assertItemsEqual([], discovered_pod.machines)
         self.assertItemsEqual([], discovered_pod.tags)
         self.assertItemsEqual([], discovered_pod.storage_pools)
+
+    @inlineCallbacks
+    def test__get_discovered_pod_storage_pool(self):
+        driver = lxd_pod_module.LXDPodDriver()
+        mock_storage_pool = Mock()
+        mock_storage_pool.name = factory.make_name("pool")
+        mock_storage_pool.driver = "dir"
+        mock_storage_pool.config = {
+            "size": "61203283968",
+            "source": "/home/chb/mnt/l2/disks/default.img",
+            "volume.size": "0",
+            "zfs.pool_name": "default",
+        }
+        mock_resources = Mock()
+        mock_resources.space = {"used": 207111192576, "total": 306027577344}
+        mock_storage_pool.resources.get.return_value = mock_resources
+        discovered_pod_storage_pool = yield driver.get_discovered_pod_storage_pool(
+            mock_storage_pool
+        )
+
+        self.assertEquals(
+            mock_storage_pool.name, discovered_pod_storage_pool.id
+        )
+        self.assertEquals(
+            mock_storage_pool.name, discovered_pod_storage_pool.name
+        )
+        self.assertEquals(
+            mock_storage_pool.config["source"],
+            discovered_pod_storage_pool.path,
+        )
+        self.assertEquals(
+            mock_storage_pool.driver, discovered_pod_storage_pool.type
+        )
+        self.assertEquals(
+            mock_resources.space["total"], discovered_pod_storage_pool.storage
+        )
+
+    @inlineCallbacks
+    def test__get_discovered_machine(self):
+        driver = lxd_pod_module.LXDPodDriver()
+        mock_machine = Mock()
+        mock_machine.name = factory.make_name("machine")
+        mock_machine.architecture = "x86_64"
+        expanded_config = {
+            "limits.cpu": "2",
+            "limits.memory": "1024",
+            "volatile.eth0.hwaddr": "00:16:3e:78:be:04",
+            "volatile.eth1.hwaddr": "00:16:3e:f9:fc:cb",
+        }
+        expanded_devices = {
+            "eth0": {
+                "name": "eth0",
+                "nictype": "bridged",
+                "parent": "lxdbr0",
+                "type": "nic",
+            },
+            "eth1": {
+                "name": "eth1",
+                "nictype": "bridged",
+                "parent": "virbr1",
+                "type": "nic",
+            },
+            "root": {"path": "/", "pool": "default", "type": "disk"},
+        }
+        mock_machine.expanded_config = expanded_config
+        mock_machine.expanded_devices = expanded_devices
+        mock_machine.status_code = 102
+        mock_storage_pool = Mock()
+        mock_storage_pool.name = "default"
+        mock_storage_pool_resources = Mock()
+        mock_storage_pool_resources.space = {
+            "used": 207111192576,
+            "total": 306027577344,
+        }
+        mock_storage_pool.resources.get.return_value = (
+            mock_storage_pool_resources
+        )
+        mock_machine.storage_pools.get.return_value = mock_storage_pool
+        discovered_machine = yield driver.get_discovered_machine(
+            mock_machine, [mock_storage_pool], cpu_speed=2500
+        )
+
+        self.assertEquals(mock_machine.name, discovered_machine.hostname)
+
+        self.assertEquals(
+            kernel_to_debian_architecture(mock_machine.architecture),
+            discovered_machine.architecture,
+        )
+        self.assertEquals(
+            lxd_pod_module.LXD_VM_POWER_STATE[mock_machine.status_code],
+            discovered_machine.power_state,
+        )
+        self.assertEquals(2, discovered_machine.cores)
+        self.assertEquals(2500, discovered_machine.cpu_speed)
+        self.assertEquals(1024, discovered_machine.memory)
+        self.assertEquals(
+            mock_machine.name,
+            discovered_machine.power_parameters["instance_name"],
+        )
+        self.assertThat(
+            discovered_machine.block_devices[0],
+            MatchesStructure.byEquality(
+                model=None,
+                serial=None,
+                id_path=lxd_pod_module.LXD_VM_ID_PATH + "root",
+                size=10 * 1000 ** 3,
+                block_size=512,
+                tags=[],
+                type="physical",
+                storage_pool=expanded_devices["root"]["pool"],
+                iscsi_target=None,
+            ),
+        )
+        self.assertThat(
+            discovered_machine.interfaces[0],
+            MatchesStructure.byEquality(
+                mac_address=expanded_config["volatile.eth0.hwaddr"],
+                vid=0,
+                tags=[],
+                boot=True,
+                attach_type=expanded_devices["eth0"]["nictype"],
+                attach_name="eth0",
+            ),
+        )
+        self.assertThat(
+            discovered_machine.interfaces[1],
+            MatchesStructure.byEquality(
+                mac_address=expanded_config["volatile.eth1.hwaddr"],
+                vid=0,
+                tags=[],
+                boot=False,
+                attach_type=expanded_devices["eth1"]["nictype"],
+                attach_name="eth1",
+            ),
+        )
+        self.assertItemsEqual([], discovered_machine.tags)
+
+    @inlineCallbacks
+    def test_get_discovered_machine_sets_power_state_to_unknown_for_unknown(
+        self
+    ):
+        driver = lxd_pod_module.LXDPodDriver()
+        mock_machine = Mock()
+        mock_machine.name = factory.make_name("machine")
+        mock_machine.architecture = "x86_64"
+        expanded_config = {
+            "limits.cpu": "2",
+            "limits.memory": "1024",
+            "volatile.eth0.hwaddr": "00:16:3e:78:be:04",
+            "volatile.eth1.hwaddr": "00:16:3e:f9:fc:cb",
+        }
+        expanded_devices = {
+            "eth0": {
+                "name": "eth0",
+                "nictype": "bridged",
+                "parent": "lxdbr0",
+                "type": "nic",
+            },
+            "eth1": {
+                "name": "eth1",
+                "nictype": "bridged",
+                "parent": "virbr1",
+                "type": "nic",
+            },
+            "root": {"path": "/", "pool": "default", "type": "disk"},
+        }
+        mock_machine.expanded_config = expanded_config
+        mock_machine.expanded_devices = expanded_devices
+        mock_machine.status_code = 100
+        mock_storage_pool = Mock()
+        mock_storage_pool.name = "default"
+        mock_storage_pool_resources = Mock()
+        mock_storage_pool_resources.space = {
+            "used": 207111192576,
+            "total": 306027577344,
+        }
+        mock_storage_pool.resources.get.return_value = (
+            mock_storage_pool_resources
+        )
+        mock_machine.storage_pools.get.return_value = mock_storage_pool
+        discovered_machine = yield driver.get_discovered_machine(
+            mock_machine, [mock_storage_pool], cpu_speed=2500
+        )
+
+        self.assertEquals("unknown", discovered_machine.power_state)