Add network.create()

Add NetworkRouteDomain

Author: LKaemmerling

hcloud/networks/client.py

@@ -3,12 +3,31 @@
 from hcloud.core.domain import add_meta_to_result
 
 from hcloud.actions.client import BoundAction
-from hcloud.networks.domain import Network
+from hcloud.networks.domain import Network, NetworkRoute, NetworkSubnet
 
 
 class BoundNetwork(BoundModelBase):
     model = Network
 
+    def __init__(self, client, data, complete=True):
+        subnets = data.get("subnets", [])
+        if subnets is not None:
+            subnets = [NetworkSubnet(**subnet) for subnet in subnets]
+            data['subnets'] = subnets
+
+        routes = data.get("routes", [])
+        if routes is not None:
+            routes = [NetworkRoute(**route) for route in routes]
+            data['routes'] = routes
+
+        from hcloud.servers.client import BoundServer
+        servers = data.get("servers",[])
+        if servers is not None:
+            servers = [BoundServer(client._client.servers, {"id": server}, complete=False) for server in servers]
+            data['servers'] = servers
+
+        super(BoundNetwork, self).__init__(client, data, complete)
+
     def update(self, name=None, labels=None):
         # type: (Optional[str], Optional[Dict[str, str]]) -> BoundNetwork
         """Updates a network. You can update a network’s name and a networks’s labels.
@@ -59,7 +78,7 @@ def get_actions(self, status=None, sort=None):
 
 
 class NetworksClient(ClientEntityBase, GetEntityByNameMixin):
-    results_list_attribute_name = 'networks'
+    results_list_attribute_name = "networks"
 
     def get_by_id(self, id):
         # type: (int) -> BoundNetwork
@@ -68,15 +87,18 @@ def get_by_id(self, id):
         :param id: int
         :return: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>
         """
-        response = self._client.request(url="/networks/{network_id}".format(network_id=id), method="GET")
-        return BoundNetwork(self, response['network'])
-
-    def get_list(self,
-                 name=None,  # type: Optional[str]
-                 label_selector=None,  # type: Optional[str]
-                 page=None,  # type: Optional[int]
-                 per_page=None,  # type: Optional[int]
-                 ):
+        response = self._client.request(
+            url="/networks/{network_id}".format(network_id=id), method="GET"
+        )
+        return BoundNetwork(self, response["network"])
+
+    def get_list(
+        self,
+        name=None,  # type: Optional[str]
+        label_selector=None,  # type: Optional[str]
+        page=None,  # type: Optional[int]
+        per_page=None,  # type: Optional[int]
+    ):
         # type: (...) -> PageResults[List[BoundNetwork], Meta]
         """Get a list of networks from this account
 
@@ -92,17 +114,19 @@ def get_list(self,
         """
         params = {}
         if name:
-            params['name'] = name
+            params["name"] = name
         if label_selector:
-            params['label_selector'] = label_selector
+            params["label_selector"] = label_selector
         if page:
-            params['page'] = page
+            params["page"] = page
         if per_page:
-            params['per_page'] = per_page
+            params["per_page"] = per_page
 
         response = self._client.request(url="/networks", method="GET", params=params)
 
-        ass_networks = [BoundNetwork(self, network_data) for network_data in response['networks']]
+        ass_networks = [
+            BoundNetwork(self, network_data) for network_data in response["networks"]
+        ]
         return self._add_meta_to_result(ass_networks, response)
 
     def get_all(self, name=None, label_selector=None):
@@ -115,7 +139,9 @@ def get_all(self, name=None, label_selector=None):
                Can be used to filter networks by labels. The response will only contain networks matching the label selector.
         :return: List[:class:`BoundNetwork <hcloud.networks.client.BoundNetwork>`]
         """
-        return super(NetworksClient, self).get_all(name=name, label_selector=label_selector)
+        return super(NetworksClient, self).get_all(
+            name=name, label_selector=label_selector
+        )
 
     def get_by_name(self, name):
         # type: (str) -> BoundNetwork
@@ -127,9 +153,39 @@ def get_by_name(self, name):
         """
         return super(NetworksClient, self).get_by_name(name)
 
-    def create(self):
-        #  TODO
-        pass
+    def create(
+        self,
+        name,  # type: str
+        ip_range,  # type: str
+        subnets=None,  # type: Optional[List[NetworkSubnet]]
+        routes=None,  # type:  Optional[List[NetworkRoute]]
+        labels=None,  # type:  Optional[Dict[str, str]]
+    ):
+        """Creates a network with range ip_range.
+
+        :param name: str
+                Name of the network
+        :param ip_range: str
+                IP range of the whole network which must span all included subnets and route destinations
+        :param subnets: List[:class:`NetworkSubnet <hcloud.networks.domain.NetworkSubnet>`]
+                Array of subnets allocated
+        :param routes: List[:class:`NetworkRoute <hcloud.networks.domain.NetworkRoute>`]
+                Array of routes set in this network
+        :param labels: Dict[str, str] (optional)
+                User-defined labels (key-value pairs)
+        :return: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>`
+        """
+        data = {"name": name, "ip_range": ip_range}
+        if subnets is not None:
+            data["subnets"] = subnets
+        if routes is not None:
+            data["routes"] = routes
+        if labels is not None:
+            data["labels"] = labels
+
+        response = self._client.request(url="/networks", method="POST", json=data)
+
+        return BoundNetwork(self, response["network"])
 
     def update(self, network, name=None, labels=None):
         # type:(Network,  Optional[str],  Optional[Dict[str, str]]) -> BoundNetwork
@@ -147,8 +203,12 @@ def update(self, network, name=None, labels=None):
             data.update({"name": name})
         if labels is not None:
             data.update({"labels": labels})
-        response = self._client.request(url="/networks/{network_id}".format(network_id=network.id), method="PUT", json=data)
-        return BoundNetwork(self, response['network'])
+        response = self._client.request(
+            url="/networks/{network_id}".format(network_id=network.id),
+            method="PUT",
+            json=data,
+        )
+        return BoundNetwork(self, response["network"])
 
     def delete(self, network):
         # type: (Network) -> BoundAction
@@ -157,10 +217,14 @@ def delete(self, network):
         :param network: :class:`BoundNetwork <hcloud.networks.client.BoundNetwork>` or :class:`Network <hcloud.networks.domain.Network>`
         :return:  :class:`BoundAction <hcloud.actions.client.BoundAction>`
         """
-        response = self._client.request(url="/networks/{network_id}".format(network_id=network.id), method="DELETE")
-        return BoundAction(self._client.actions, response['action'])
-
-    def get_actions_list(self, network, status=None, sort=None, page=None, per_page=None):
+        response = self._client.request(
+            url="/networks/{network_id}".format(network_id=network.id), method="DELETE"
+        )
+        return BoundAction(self._client.actions, response["action"])
+
+    def get_actions_list(
+        self, network, status=None, sort=None, page=None, per_page=None
+    ):
         # type: (Network, Optional[List[str]], Optional[List[str]], Optional[int], Optional[int]) -> PageResults[List[BoundAction], Meta]
         """Returns all action objects for a network.
 
@@ -185,10 +249,16 @@ def get_actions_list(self, network, status=None, sort=None, page=None, per_page=
         if per_page is not None:
             params["per_page"] = per_page
 
-        response = self._client.request(url="/networks/{network_id}/actions".format(network_id=network.id), method="GET",
-                                        params=params)
-        actions = [BoundAction(self._client.actions, action_data) for action_data in response['actions']]
-        return add_meta_to_result(actions, response, 'actions')
+        response = self._client.request(
+            url="/networks/{network_id}/actions".format(network_id=network.id),
+            method="GET",
+            params=params,
+        )
+        actions = [
+            BoundAction(self._client.actions, action_data)
+            for action_data in response["actions"]
+        ]
+        return add_meta_to_result(actions, response, "actions")
 
     def get_actions(self, network, status=None, sort=None):
         # type: (Network, Optional[List[str]], Optional[List[str]]) -> List[BoundAction]
@@ -201,4 +271,6 @@ def get_actions(self, network, status=None, sort=None):
                Specify how the results are sorted. Choices: `id` `id:asc` `id:desc` `command` `command:asc` `command:desc` `status` `status:asc` `status:desc` `progress` `progress:asc` `progress:desc` `started` `started:asc` `started:desc` `finished` `finished:asc` `finished:desc`
         :return: List[:class:`BoundAction <hcloud.actions.client.BoundAction>`]
         """
-        return super(NetworksClient, self).get_actions(network, status=status, sort=sort)
+        return super(NetworksClient, self).get_actions(
+            network, status=status, sort=sort
+        )

hcloud/networks/domain.py

@@ -22,6 +22,7 @@ class Network(BaseDomain):
     :param labels: dict
            User-defined labels (key-value pairs)
     """
+
     __slots__ = (
         "id",
         "name",
@@ -30,20 +31,19 @@ class Network(BaseDomain):
         "routes",
         "servers",
         "protection",
-        "labels"
+        "labels",
     )
 
     def __init__(
-            self,
-            id=None,
-            name=None,
-            ip_range=None,
-            subnets=None,
-            routes=None,
-            servers=None,
-            protection=None,
-            labels=None
-
+        self,
+        id=None,
+        name=None,
+        ip_range=None,
+        subnets=None,
+        routes=None,
+        servers=None,
+        protection=None,
+        labels=None,
     ):
         self.id = id
         self.name = name
@@ -56,13 +56,20 @@ def __init__(
 
 
 class NetworkSubnet(BaseDomain):
-    #  TODO
-    pass
+    __slots__ = ("type", "ip_range", "network_zone")
+
+    def __init__(self, type=None, ip_range=None, network_zone=None):
+        self.type = type
+        self.ip_range = ip_range
+        self.network_zone = network_zone
 
 
 class NetworkRoute(BaseDomain):
-    #  TODO
-    pass
+    __slots__ = ("destination", "gateway", "network_zone")
+
+    def __init__(self, destination=None, gateway=None):
+        self.destination = destination
+        self.gateway = gateway
 
 
 class CreateNetworkResponse(BaseDomain):
@@ -73,15 +80,9 @@ class CreateNetworkResponse(BaseDomain):
     :param action: :class:`BoundAction <hcloud.actions.client.BoundAction>`
            The Action which shows the progress of the network Creation
     """
-    __slots__ = (
-        "network",
-        "action"
-    )
 
-    def __init__(
-            self,
-            network,  # type: BoundNetwork
-            action,  # type: BoundAction
-    ):
+    __slots__ = ("network", "action")
+
+    def __init__(self, network, action):  # type: BoundNetwork  # type: BoundAction
         self.network = network
         self.action = action