Resolve "Implement client for Datacenter endpoint"

Author: LKaemmerling

hcloud/datacenters/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

hcloud/datacenters/client.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from hcloud.core.client import ClientEntityBase, BoundModelBase
+
+from hcloud.datacenters.domain import Datacenter, DatacenterServerTypes
+from hcloud.locations.client import BoundLocation
+from hcloud.server_types.client import BoundServerType
+
+
+class BoundDatacenter(BoundModelBase):
+    model = Datacenter
+
+    def __init__(self, client, data):
+        location = data.get("location")
+        if location is not None:
+            data['location'] = BoundLocation(client._client.locations, location)
+
+        server_types = data.get("server_types")
+        if server_types is not None:
+            DatacenterServerTypes
+            available = [BoundServerType(client._client.server_types, {"id": server_type}, complete=False) for server_type in server_types['available']]
+            supported = [BoundServerType(client._client.server_types, {"id": server_type}, complete=False) for server_type in server_types['supported']]
+            available_for_migration = [BoundServerType(client._client.server_types, {"id": server_type}, complete=False) for server_type in server_types['available_for_migration']]
+            data['server_types'] = DatacenterServerTypes(available=available, supported=supported, available_for_migration=available_for_migration)
+
+        super(BoundDatacenter, self).__init__(client, data)
+
+
+class DatacentersClient(ClientEntityBase):
+
+    def get_by_id(self, id):
+        # type: (int) -> datacenters.client.BoundDatacenter
+        response = self._client.request(url="/datacenters/{datacenter_id}".format(datacenter_id=id), method="GET")
+        return BoundDatacenter(self, response['datacenter'])
+
+    def get_all(self, name=None):
+        # type: (Optional[str]) -> List[BoundAction]
+        params = {}
+        if name is not None:
+            params.update({"name": name})
+
+        response = self._client.request(url="/datacenters", method="GET", params=params)
+        return [BoundDatacenter(self, datacenter_data) for datacenter_data in response['datacenters']]

hcloud/datacenters/domain.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+from hcloud.core.domain import BaseDomain
+
+
+class Datacenter(BaseDomain):
+
+    __slots__ = (
+        "id",
+        "name",
+        "description",
+        "location",
+        "server_types",
+    )
+
+    def __init__(
+        self,
+        id=None,
+        name=None,
+        description=None,
+        location=None,
+        server_types=None
+    ):
+        self.id = id
+        self.name = name
+        self.description = description
+        self.location = location
+        self.server_types = server_types
+
+
+class DatacenterServerTypes:
+    __slots__ = (
+        "available",
+        "supported",
+        "available_for_migration"
+    )
+
+    def __init__(self, available, supported, available_for_migration):
+        self.available = available
+        self.supported = supported
+        self.available_for_migration = available_for_migration

hcloud/hcloud.py

@@ -7,6 +7,8 @@
 from hcloud.servers.client import ServersClient
 from hcloud.server_types.client import ServerTypesClient
 from hcloud.volumes.client import VolumesClient
+from hcloud.locations.client import LocationsClient
+from hcloud.datacenters.client import DatacentersClient
 
 
 from .version import VERSION
@@ -26,6 +28,8 @@ def __init__(self, token):
         self.token = token
         self.api_endpoint = "https://api.hetzner.cloud/v1"
 
+        self.datacenters = DatacentersClient(self)
+        self.locations = LocationsClient(self)
         self.servers = ServersClient(self)
         self.server_types = ServerTypesClient(self)
         self.volumes = VolumesClient(self)

hcloud/locations/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

hcloud/locations/client.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+from hcloud.core.client import ClientEntityBase, BoundModelBase
+
+from hcloud.locations.domain import Location
+
+
+class BoundLocation(BoundModelBase):
+    model = Location
+
+
+class LocationsClient(ClientEntityBase):
+
+    def get_by_id(self, id):
+        # type: (int) -> locations.client.BoundLocation
+        response = self._client.request(url="/locations/{location_id}".format(location_id=id), method="GET")
+        return BoundLocation(self, response['location'])
+
+    def get_all(self, name=None):
+        # type: # type: (Optional[str]) -> List[BoundAction]
+        params = {}
+        if name is not None:
+            params.update({"name": name})
+
+        response = self._client.request(url="/locations", method="GET", params=params)
+        return [BoundLocation(self, location_data) for location_data in response['locations']]

hcloud/locations/domain.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+from hcloud.core.domain import BaseDomain
+
+
+class Location(BaseDomain):
+
+    __slots__ = (
+        "id",
+        "name",
+        "description",
+        "country",
+        "city",
+        "latitude",
+        "longitude"
+    )
+
+    def __init__(
+        self,
+        id=None,
+        name=None,
+        description=None,
+        country=None,
+        city=None,
+        latitude=None,
+        longitude=None
+    ):
+        self.id = id
+        self.name = name
+        self.description = description
+        self.country = country
+        self.city = city
+        self.latitude = latitude
+        self.longitude = longitude

hcloud/servers/client.py

@@ -7,12 +7,18 @@
 from hcloud.images.domain import Image, CreateImageResponse
 from hcloud.iso.domain import Iso
 from hcloud.server_types.client import BoundServerType
+from hcloud.datacenters.client import BoundDatacenter
 
 
 class BoundServer(BoundModelBase):
     model = Server
 
     def __init__(self, client, data):
+
+        datacenter = data.get('datacenter')
+        if datacenter is not None:
+            data['datacenter'] = BoundDatacenter(client._client.datacenters, datacenter)
+
         volumes = data.get('volumes', [])
         if volumes:
             volumes = [BoundVolume(client._client.volumes, {"id": volume}, complete=False) for volume in volumes]
@@ -22,7 +28,6 @@ def __init__(self, client, data):
         if image is not None:
             # data['image'] = BoundImage(client._client.images, image, complete=True) # When Image Client is implemented
             data['image'] = Image(**image)
-            print(data['image'].id)
 
         iso = data.get("iso", None)
         if iso is not None:
@@ -139,20 +144,19 @@ def get_all(self, name=None, label_selector=None):
         return [BoundServer(self, server_data) for server_data in response['servers']]
 
     def create(self,
-               name,                     # type: str
-               server_type,              # type: str
-               image,                    # type: Image
-               ssh_keys=None,            # type: Optional[List[str]]
-               volumes=None,             # type: Optional[List[Volume]]
-               user_data=None,           # type: Optional[str]
-               labels=None,              # type: Optional[Dict[str, str]]
-               location=None,            # type: Optional[str]
-               datacenter=None,          # type: Optional[str]
-               start_after_create=True   # type: Optional[bool]
+               name,                      # type: str
+               server_type,               # type: str
+               image,                     # type: Image
+               ssh_keys=None,             # type: Optional[List[str]]
+               volumes=None,              # type: Optional[List[Volume]]
+               user_data=None,            # type: Optional[str]
+               labels=None,               # type: Optional[Dict[str, str]]
+               location=None,             # type: Optional[Location]
+               datacenter=None,           # type: Optional[Datacenter]
+               start_after_create=True,   # type: Optional[bool]
+               automount=None             # type: Optional[bool]
                ):
         # type: (...) -> CreateServerResponse
-        # TODO: convert location str type to locations.domain.Location type, when implementation is ready
-        # TODO: convert datacenter str type to datacenters.domain.Datacenter type, when implementation is ready
         """
         Should be visible in docs
         :param name:
@@ -170,12 +174,15 @@ def create(self,
         data = {
             'name': name,
             'server_type': server_type,
-            "start_after_create": start_after_create
+            "start_after_create": start_after_create,
+            "image": image.id_or_name
         }
-        if image.id is not None:
-            data['image'] = image.id
-        else:
-            data['image'] = image.name
+
+        if location is not None:
+            data['location'] = location.id_or_name
+
+        if datacenter is not None:
+            data['datacenter'] = datacenter.id_or_name
 
         if ssh_keys is not None:
             data['ssh_keys'] = ssh_keys
@@ -185,10 +192,8 @@ def create(self,
             data['user_data'] = user_data
         if labels is not None:
             data['labels'] = labels
-        if location is not None:
-            data['location'] = location
-        if datacenter is not None:
-            data["datacenter"] = datacenter
+        if automount is not None:
+            data["automount"] = automount
 
         response = self._client.request(url="/servers", method="POST", json=data)
 

hcloud/volumes/client.py

@@ -3,11 +3,18 @@
 
 from hcloud.actions.client import BoundAction
 from hcloud.volumes.domain import Volume, CreateVolumeResponse
+from hcloud.locations.client import BoundLocation
 
 
 class BoundVolume(BoundModelBase):
     model = Volume
 
+    def __init__(self, client, data, complete=True):
+        location = data.get("location")
+        if location is not None:
+            data['location'] = BoundLocation(client._client.locations, location)
+        super(BoundVolume, self).__init__(client, data, complete)
+
     def attach(self, server):
         # type: (Union[Server, BoundServer]) -> Action
         return self._client.attach(server, self)
@@ -34,14 +41,15 @@ def get_all(self, label_selector=None):
         return [BoundVolume(self, volume_data) for volume_data in response['volumes']]
 
     def create(self,
-               size,           # type: int
-               name,           # type: str
-               labels=None,    # type: Optional[str]
-               location=None,  # type: Optional[str]
-               server=None     # type: Optional[Server]
+               size,            # type: int
+               name,            # type: str
+               labels=None,     # type: Optional[str]
+               location=None,   # type: Optional[Location]
+               server=None,     # type: Optional[Server],
+               automount=None,  # type: Optional[bool],
+               format=None,     # type: Optional[str],
                ):
         # type: (...) -> CreateVolumeResponse
-        # TODO: convert location str type to locations.domain.Location type, when implementation is ready
 
         if size <= 0:
             raise ValueError("size must be greater than 0")
@@ -56,9 +64,14 @@ def create(self,
         if labels is not None:
             data['labels'] = labels
         if location is not None:
-            data['location'] = location
+            data['location'] = location.id_or_name
+
         if server is not None:
             data['server'] = server.id
+        if automount is not None:
+            data['automount'] = automount
+        if format is not None:
+            data['format'] = format
 
         response = self._client.request(url="/volumes", json=data, method="POST")