Add placement_groups

Author: Adrian Huber

hcloud/hcloud.py

@@ -18,6 +18,7 @@
 from hcloud.datacenters.client import DatacentersClient
 from hcloud.load_balancers.client import LoadBalancersClient
 from hcloud.load_balancer_types.client import LoadBalancerTypesClient
+from hcloud.placement_groups.client import PlacementGroupsClient
 
 from .__version__ import VERSION
 from .firewalls.client import FirewallsClient
@@ -149,6 +150,12 @@ def __init__(
         :type: :class:`FirewallsClient <hcloud.firewalls.client.FirewallsClient>`
         """
 
+        self.placement_groups = PlacementGroupsClient(self)
+        """PlacementGroupsClient Instance
+
+        :type: :class:`PlacementGroupsClient <hcloud.placement_groups.client.PlacementGroupsClient>`
+        """
+
     def _get_user_agent(self):
         """Get the user agent of the hcloud-python instance with the user application name (if specified)
 

hcloud/placement_groups/__init__.py

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

hcloud/placement_groups/client.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+from hcloud.core.client import BoundModelBase, ClientEntityBase, GetEntityByNameMixin
+
+from hcloud.placement_groups.domain import PlacementGroup
+
+
+class BoundPlacementGroup(BoundModelBase):
+    model = PlacementGroup
+
+    def update(self, labels=None, name=None):
+        # type: (Optional[str], Optional[Dict[str, str]], Optional[str]) -> BoundPlacementGroup
+        """Updates the name or labels of a Placement Group
+
+        :param labels: Dict[str, str] (optional)
+               User-defined labels (key-value pairs)
+        :param name: str, (optional)
+               New Name to set
+        :return: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>`
+        """
+        return self._client.update(self, labels, name)
+
+    def delete(self):
+        # type: () -> bool
+        """Deletes a Placement Group
+
+        :return: boolean
+        """
+        return self._client.delete(self)
+
+
+class PlacementGroupsClient(ClientEntityBase, GetEntityByNameMixin):
+    results_list_attribute_name = "placement_groups"
+
+    def get_by_id(self, id):
+        # type: (int) -> BoundPlacementGroup
+        """Returns a specific Placement Group object
+
+        :param id: int
+        :return: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>`
+        """
+        response = self._client.request(url="/placement_groups/{placement_group_id}".format(placement_group_id=id), method="GET")
+        return BoundPlacementGroup(self, response['placement_group'])
+
+    def get_list(self,
+                 label_selector=None,  # type: Optional[str]
+                 page=None,  # type: Optional[int]
+                 per_page=None,  # type: Optional[int]
+                 name=None,  # type: Optional[str]
+                 sort=None,  # type: Optional[List[str]]
+                 type=None,  # type: Optional[str]
+                 ):
+        # type: (...) -> PageResults[List[BoundPlacementGroup]]
+        """Get a list of Placement Groups
+
+        :param label_selector: str (optional)
+               Can be used to filter Placement Groups by labels. The response will only contain Placement Groups matching the label selector values.
+        :param page: int (optional)
+               Specifies the page to fetch
+        :param per_page: int (optional)
+               Specifies how many results are returned by page
+        :param name: str (optional)
+               Can be used to filter Placement Groups by their name.
+        :param sort: List[str] (optional)
+               Choices: id name created (You can add one of ":asc", ":desc" to modify sort order. ( ":asc" is default))
+        :return: (List[:class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>`], :class:`Meta <hcloud.core.domain.Meta>`)
+        """
+
+        params = {}
+
+        if label_selector is not None:
+            params['label_selector'] = label_selector
+        if page is not None:
+            params['page'] = page
+        if per_page is not None:
+            params['per_page'] = per_page
+        if name is not None:
+            params['name'] = name
+        if sort is not None:
+            params['sort'] = sort
+        if type is not None:
+            params['type'] = type
+        response = self._client.request(url="/placement_groups", method="GET", params=params)
+        placement_groups = [BoundPlacementGroup(self, placement_group_data) for placement_group_data in response['placement_groups']]
+
+        return self._add_meta_to_result(placement_groups, response)
+
+    def get_all(self, label_selector=None, name=None, sort=None):
+        # type: (Optional[str], Optional[str],  Optional[List[str]]) -> List[BoundPlacementGroup]
+        """Get all Placement Groups
+
+        :param label_selector: str (optional)
+               Can be used to filter Placement Groups by labels. The response will only contain Placement Groups matching the label selector values.
+        :param name: str (optional)
+               Can be used to filter Placement Groups by their name.
+        :param sort: List[str] (optional)
+               Choices: id name created (You can add one of ":asc", ":desc" to modify sort order. ( ":asc" is default))
+        :return: List[:class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>`]
+        """
+        return super(PlacementGroupsClient, self).get_all(label_selector=label_selector, name=name, sort=sort)
+
+    def get_by_name(self, name):
+        # type: (str) -> BoundPlacementGroup
+        """Get Placement Group by name
+
+        :param name: str
+               Used to get Placement Group by name
+        :return: class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>`
+        """
+        return super(PlacementGroupsClient, self).get_by_name(name)
+
+    def update(self, placement_group, labels=None, name=None):
+        # type: (PlacementGroup, Optional[Dict[str, str]], Optional[str]) -> BoundPlacementGroup
+        """Updates the description or labels of a Placement Group.
+
+        :param placement_group: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>` or :class:`PlacementGroup <hcloud.placement_groups.domain.PlacementGroup>`
+        :param labels: Dict[str, str] (optional)
+               User-defined labels (key-value pairs)
+        :param name: str (optional)
+               New name to set
+        :return: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>`
+        """
+
+        data = {}
+        if labels is not None:
+            data['labels'] = labels
+        if name is not None:
+            data['name'] = name
+
+        response = self._client.request(url="/placement_groups/{placement_group_id}".format(placement_group_id=placement_group.id),
+                                        method="PUT", json=data)
+        return BoundPlacementGroup(self, response['placement_group'])
+
+    def delete(self, placement_group):
+        # type: (PlacementGroup) -> bool
+        """Deletes a Placement Group.
+
+        :param placement_group: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>` or :class:`PlacementGroup <hcloud.placement_groups.domain.PlacementGroup>`
+        :return: boolean
+        """
+        self._client.request(url="/placement_groups/{placement_group_id}".format(placement_group_id=placement_group.id),
+                             method="DELETE")
+        return True

hcloud/placement_groups/domain.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+from dateutil.parser import isoparse
+
+from hcloud.core.domain import BaseDomain
+
+
+class PlacementGroup(BaseDomain):
+    """Placement Group Domain
+
+    :param id: int
+           ID of the Placement Group
+    :param name: str
+           Name of the Placement Group
+    :param labels: dict
+           User-defined labels (key-value pairs)
+    :param servers: List[ int ]
+           List of server IDs assigned to the Placement Group
+    :param type: str
+           Type of the Placement Group
+    :param created: datetime
+           Point in time when the image was created
+    """
+
+    __slots__ = (
+        "id",
+        "name",
+        "labels",
+        "servers",
+        "type",
+        "created"
+    )
+
+    """Placement Group type spread
+       spreads all servers in the group on different vhosts
+    """
+    TYPE_SPREAD = "spread"
+
+    def __init__(
+        self,
+        id=None,
+        name=None,
+        labels=None,
+        servers=None,
+        type=None,
+        created=None
+    ):
+        self.id = id
+        self.name = name
+        self.labels = labels
+        self.servers = servers
+        self.type = type
+        self.created = isoparse(created) if created else None

hcloud/servers/client.py

@@ -355,6 +355,23 @@ def change_alias_ips(self, network, alias_ips):
         """
         return self._client.change_alias_ips(self, network, alias_ips)
 
+    def add_to_placement_group(self, placement_group):
+        # type: (Union[PlacementGroup,BoundPlacementGroup]) -> BoundAction
+        """Adds a server to a placement group.
+
+        :param placement_group: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>` or :class:`Network <hcloud.placement_groups.domain.PlacementGroup>`
+        :return: :class:`BoundAction <hcloud.actions.client.BoundAction>`
+        """
+        return self._client.add_to_placement_group(self, placement_group)
+
+    def remove_from_placement_group(self):
+        # type: () -> BoundAction
+        """Removes a server from a placement group.
+
+        :return: :class:`BoundAction <hcloud.actions.client.BoundAction>`
+        """
+        return self._client.remove_from_placement_group(self)
+
 
 class ServersClient(ClientEntityBase, GetEntityByNameMixin):
     results_list_attribute_name = "servers"
@@ -987,10 +1004,33 @@ def change_alias_ips(self, server, network, alias_ips):
         """
         data = {"network": network.id, "alias_ips": alias_ips}
         response = self._client.request(
-            url="/servers/{server_id}/actions/change_alias_ips".format(
-                server_id=server.id
-            ),
-            method="POST",
-            json=data,
-        )
-        return BoundAction(self._client.actions, response["action"])
+            url="/servers/{server_id}/actions/change_alias_ips".format(server_id=server.id), method="POST",
+            json=data)
+        return BoundAction(self._client.actions, response['action'])
+
+    def add_to_placement_group(self, server, placement_group):
+        # type: (Union[Server,BoundServer], Union[PlacementGroup,BoundPlacementGroup]) -> BoundAction
+        """Adds a server to a placement group.
+
+        :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>`
+        :param placement_group: :class:`BoundPlacementGroup <hcloud.placement_groups.client.BoundPlacementGroup>` or :class:`Network <hcloud.placement_groups.domain.PlacementGroup>`
+        :return: :class:`BoundAction <hcloud.actions.client.BoundAction>`
+        """
+        data = {
+            "placement_group": str(placement_group.id),
+        }
+        response = self._client.request(
+            url="/servers/{server_id}/actions/add_to_placement_group".format(server_id=server.id), method="POST",
+            json=data)
+        return BoundAction(self._client.actions, response['action'])
+
+    def remove_from_placement_group(self, server):
+        # type: (Union[Server,BoundServer]) -> BoundAction
+        """Removes a server from a placement group.
+
+        :param server: :class:`BoundServer <hcloud.servers.client.BoundServer>` or :class:`Server <hcloud.servers.domain.Server>`
+        :return: :class:`BoundAction <hcloud.actions.client.BoundAction>`
+        """
+        response = self._client.request(
+            url="/servers/{server_id}/actions/remove_from_placement_group".format(server_id=server.id), method="POST")
+        return BoundAction(self._client.actions, response['action'])

tests/unit/placement_groups/__init__.py

@@ -0,0 +1,76 @@
+import pytest
+
+
+@pytest.fixture()
+def one_placement_group_response():
+    return {
+        "placement_groups": [
+            {
+                "created": "2019-01-08T12:10:00+00:00",
+                "id": 897,
+                "labels": {
+                    "key": "value"
+                },
+                "name": "my Placement Group",
+                "servers": [
+                    4711,
+                    4712
+                ],
+                "type": "spread"
+            }
+        ]
+    }
+
+
+@pytest.fixture()
+def two_placement_groups_response():
+    return {
+        "placement_groups": [
+            {
+                "created": "2019-01-08T12:10:00+00:00",
+                "id": 897,
+                "labels": {
+                    "key": "value"
+                },
+                "name": "my Placement Group",
+                "servers": [
+                    4711,
+                    4712
+                ],
+                "type": "spread"
+            },
+            {
+                "created": "2019-01-08T12:10:00+00:00",
+                "id": 898,
+                "labels": {
+                    "key": "value"
+                },
+                "name": "my Placement Group",
+                "servers": [
+                    4713,
+                    4714,
+                    4715
+                ],
+                "type": "spread"
+            }
+        ]
+    }
+
+
+@pytest.fixture()
+def placement_group_response():
+    return {
+        "placement_group": {
+            "created": "2019-01-08T12:10:00+00:00",
+            "id": 897,
+            "labels": {
+                "key": "value"
+            },
+            "name": "my Placement Group",
+            "servers": [
+                4711,
+                4712
+            ],
+            "type": "spread"
+        }
+    }