Merge pull request #489 from albertodonato/machine-location-none-if-n…

…o-cluster

set Instance.location to None for non-clustred servers

pylxd/client.py

@@ -391,9 +391,8 @@ def __init__(
         ) as e:
             raise exceptions.ClientConnectionFailed(str(e))
 
-        if (
-            self.project not in (None, "default")
-            and "projects" not in self.host_info["api_extensions"]
+        if self.project not in (None, "default") and not self.has_api_extension(
+            "projects"
         ):
             raise exceptions.ClientConnectionFailed(
                 "Remote server doesn't handle projects"
@@ -416,6 +415,10 @@ def __init__(
     def trusted(self):
         return self.host_info["auth"] == "trusted"
 
+    @property
+    def server_clustered(self):
+        return self.host_info["environment"].get("server_clustered", False)
+
     @property
     def resources(self):
         if self._resource_cache is None:

pylxd/models/instance.py

@@ -69,6 +69,12 @@ class Instance(model.Model):
 
     _endpoint = "instances"
 
+    def __setattr__(self, name, value):
+        if name == "location" and not self.client.server_clustered:
+            # LXD reports "none" as location when not in a cluster
+            value = None
+        super().__setattr__(name, value)
+
     @property
     def api(self):
         return self.client.api[self._endpoint][self.name]

pylxd/models/tests/test_instance.py

@@ -83,17 +83,27 @@ def test_create(self):
 
         self.assertEqual(config["name"], an_new_instance.name)
 
-    def test_create_remote(self):
+    def test_create_remote_location(self):
         """A new instance is created at target."""
         config = {"name": "an-new-remote-instance"}
 
+        # the server must be in a cluster for the location to be set
+        self.client.host_info["environment"]["server_clustered"] = True
+
         an_new_remote_instance = models.Instance.create(
             self.client, config, wait=True, target="an-remote"
         )
 
         self.assertEqual(config["name"], an_new_remote_instance.name)
         self.assertEqual("an-remote", an_new_remote_instance.location)
 
+    def test_create_location_none(self):
+        config = {"name": "an-new-remote-instance"}
+
+        instance = models.Instance.create(self.client, config, wait=True)
+
+        self.assertIsNone(instance.location)
+
     def test_exists(self):
         """A instance exists."""
         name = "an-instance"

pylxd/tests/test_client.py

@@ -160,6 +160,34 @@ def test_connection_trusted(self):
 
         self.assertTrue(an_client.trusted)
 
+    def test_server_clustered_false_no_info(self):
+        """Client.server_clustered is False if the info is not available in metadata."""
+        response = mock.MagicMock(status_code=200)
+        response.json.return_value = {"metadata": {"environment": {}}}
+        self.get.return_value = response
+        a_client = client.Client()
+        self.assertFalse(a_client.server_clustered)
+
+    def test_server_clustered_false(self):
+        """Client.server_clustered is False if not clustered."""
+        response = mock.MagicMock(status_code=200)
+        response.json.return_value = {
+            "metadata": {"environment": {"server_clustered": False}}
+        }
+        self.get.return_value = response
+        a_client = client.Client()
+        self.assertFalse(a_client.server_clustered)
+
+    def test_server_clustered_true(self):
+        """Client.server_clustered is True if clustered."""
+        response = mock.MagicMock(status_code=200)
+        response.json.return_value = {
+            "metadata": {"environment": {"server_clustered": True}}
+        }
+        self.get.return_value = response
+        a_client = client.Client()
+        self.assertTrue(a_client.server_clustered)
+
     def test_authenticate(self):
         """A client is authenticated."""
         response = mock.MagicMock(status_code=200)