Add support for Target IP and Target LabelSelector (#99)

Author: LKaemmerling

CHANGELOG.rst

@@ -4,8 +4,10 @@ History
 master (XXXX-XX-XX)
 --------------------
 
-* Feature:Add `included_traffic`, `outgoing_traffic` and `ingoing_traffic` properties to Load Balancer domain
+* Feature: Add `included_traffic`, `outgoing_traffic` and `ingoing_traffic` properties to Load Balancer domain
 * Feature: Add `change_type`-method to `LoadBalancersClient`
+* Feature: Add support for `LoadBalancerTargetLabelSelector`
+* Feature: Add support for `LoadBalancerTargetLabelSelector`
 
 v1.8.2 (2020-07-20)
 --------------------

docs/api.clients.load_balancers.rst

@@ -2,7 +2,7 @@ LoadBalancerClient
 ==================
 
 
-.. autoclass:: hcloud.load_balancers.client.LoadBalancerClient
+.. autoclass:: hcloud.load_balancers.client.LoadBalancersClient
     :members:
 
 .. autoclass:: hcloud.load_balancers.client.BoundLoadBalancer
@@ -26,5 +26,11 @@ LoadBalancerClient
 .. autoclass:: hcloud.load_balancers.domain.LoadBalancerTarget
     :members:
 
+.. autoclass:: hcloud.load_balancers.domain.LoadBalancerTargetLabelSelector
+    :members:
+
+.. autoclass:: hcloud.load_balancers.domain.LoadBalancerTargetIP
+    :members:
+
 .. autoclass:: hcloud.load_balancers.domain.LoadBalancerAlgorithm
     :members:

hcloud/load_balancers/client.py

@@ -12,7 +12,8 @@
 from hcloud.actions.client import BoundAction
 from hcloud.load_balancers.domain import LoadBalancer, IPv4Address, IPv6Network, PublicNetwork, PrivateNet, \
     CreateLoadBalancerResponse, LoadBalancerTarget, LoadBalancerService, LoadBalancerServiceHttp, \
-    LoadBalancerHealthCheck, LoadBalancerHealtCheckHttp, LoadBalancerAlgorithm
+    LoadBalancerHealthCheck, LoadBalancerHealtCheckHttp, LoadBalancerAlgorithm, LoadBalancerTargetLabelSelector, \
+    LoadBalancerTargetIP
 
 
 class BoundLoadBalancer(BoundModelBase):
@@ -43,6 +44,11 @@ def __init__(self, client, data, complete=True):
                 tmp_target = LoadBalancerTarget(type=target["type"], use_private_ip=target["use_private_ip"])
                 if target["type"] == "server":
                     tmp_target.server = BoundServer(client._client.servers, data=target['server'], complete=False)
+                elif target["type"] == "label_selector":
+                    tmp_target.label_selector = LoadBalancerTargetLabelSelector(
+                        selector=target['label_selector']['selector'])
+                elif target["type"] == "ip":
+                    tmp_target.label_selector = LoadBalancerTargetIP(ip=target['ip']['ip'])
                 tmp_targets.append(tmp_target)
             data['targets'] = tmp_targets
 
@@ -186,7 +192,7 @@ def remove_target(self, target):
         return self._client.remove_target(self, target)
 
     def change_algorithm(self, algorithm):
-        # type: (LoadBalancerService) -> List[BoundAction]
+        # type: (LoadBalancerAlgorithm) -> List[BoundAction]
         """Changes the algorithm used by the Load Balancer
 
         :param algorithm: :class:`LoadBalancerAlgorithm <hcloud.load_balancers.domain.LoadBalancerAlgorithm>`
@@ -386,9 +392,14 @@ def create(
             for target in targets:
                 target_data = {
                     "type": target.type,
-                    "server": target.server,
                     "use_private_ip": target.use_private_ip
                 }
+                if target.type == "server":
+                    target_data['server'] = {"id": target.server.id}
+                elif target.type == "label_selector":
+                    target_data['label_selector'] = {"selector": target.label_selector.selector}
+                elif target.type == "ip":
+                    target_data['ip'] = {"ip": target.ip.ip}
                 target_list.append(target_data)
 
             data["targets"] = target_list
@@ -609,9 +620,14 @@ def add_target(self, load_balancer, target):
         """
         data = {
             "type": target.type,
-            "server": {"id": target.server.id},
             "use_private_ip": target.use_private_ip
         }
+        if target.type == "server":
+            data['server'] = {"id": target.server.id}
+        elif target.type == "label_selector":
+            data['label_selector'] = {"selector": target.label_selector.selector}
+        elif target.type == "ip":
+            data['ip'] = {"ip": target.ip.ip}
 
         response = self._client.request(
             url="/load_balancers/{load_balancer_id}/actions/add_target".format(load_balancer_id=load_balancer.id),
@@ -629,8 +645,13 @@ def remove_target(self, load_balancer, target):
         """
         data = {
             "type": target.type,
-            "server": {"id": target.server.id},
         }
+        if target.type == "server":
+            data['server'] = {"id": target.server.id}
+        elif target.type == "label_selector":
+            data['label_selector'] = {"selector": target.label_selector.selector}
+        elif target.type == "ip":
+            data['ip'] = {"ip": target.ip.ip}
 
         response = self._client.request(
             url="/load_balancers/{load_balancer_id}/actions/remove_target".format(load_balancer_id=load_balancer.id),
@@ -754,6 +775,7 @@ def change_type(self, load_balancer, load_balancer_type):
         data = {
             "load_balancer_type": load_balancer_type.id_or_name,
         }
-        response = self._client.request(url="/load_balancers/{load_balancer_id}/actions/change_type".format(load_balancer_id=load_balancer.id),
-                                        method="POST", json=data)
+        response = self._client.request(
+            url="/load_balancers/{load_balancer_id}/actions/change_type".format(load_balancer_id=load_balancer.id),
+            method="POST", json=data)
         return BoundAction(self._client.actions, response['action'])

hcloud/load_balancers/domain.py

@@ -197,19 +197,42 @@ class LoadBalancerTarget(BaseDomain):
                         Type of the resource, can be server or label_selector
                 :param server: Server
                         Target server
-                :param label_selector: str
-                        Target label selector string
+                :param label_selector: LoadBalancerTargetLabelSelector
+                        Target label selector
+                :param ip: LoadBalancerTargetIP
+                        Target IP
                 :param use_private_ip: bool
                         use the private IP instead of primary public IP
     """
 
-    def __init__(self, type=None, server=None, label_selector=None, use_private_ip=None):
+    def __init__(self, type=None, server=None, label_selector=None, ip=None, use_private_ip=None):
         self.type = type
         self.server = server
         self.label_selector = label_selector
+        self.ip = ip
         self.use_private_ip = use_private_ip
 
 
+class LoadBalancerTargetLabelSelector(BaseDomain):
+    """LoadBalancerTargetLabelSelector Domain
+            :param selector: str
+                    Target label selector
+    """
+
+    def __init__(self, selector=None):
+        self.selector = selector
+
+
+class LoadBalancerTargetIP(BaseDomain):
+    """LoadBalancerTargetIP Domain
+            :param ip: str
+                    Target IP
+    """
+
+    def __init__(self, ip=None):
+        self.ip = ip
+
+
 class LoadBalancerAlgorithm(BaseDomain):
     """LoadBalancerAlgorithm Domain
                     :param type: str

tests/unit/load_balancers/test_client.py

@@ -9,7 +9,7 @@
 from hcloud.load_balancers.client import BoundLoadBalancer, LoadBalancersClient
 
 from hcloud.load_balancers.domain import LoadBalancerAlgorithm, LoadBalancerHealthCheck, \
-    LoadBalancerService, LoadBalancerTarget, LoadBalancer
+    LoadBalancerService, LoadBalancerTarget, LoadBalancer, LoadBalancerTargetIP, LoadBalancerTargetLabelSelector
 from hcloud.actions.client import BoundAction
 
 
@@ -108,22 +108,32 @@ def test_delete_service(self, hetzner_client, response_delete_service, bound_loa
         assert action.progress == 100
         assert action.command == "delete_service"
 
-    def test_add_target(self, hetzner_client, response_add_target, bound_load_balancer):
+    @pytest.mark.parametrize("target,params", [
+        (LoadBalancerTarget(type="server", server=Server(id=1), use_private_ip=True), {'server': {"id": 1}}),
+        (LoadBalancerTarget(type="ip", ip=LoadBalancerTargetIP(ip="127.0.0.1")), {'ip': {"ip": "127.0.0.1"}}),
+        (LoadBalancerTarget(type="label_selector", label_selector=LoadBalancerTargetLabelSelector(selector="abc=def")), {'label_selector': {"selector": "abc=def"}})
+    ])
+    def test_add_target(self, hetzner_client, response_add_target, bound_load_balancer, target, params):
         hetzner_client.request.return_value = response_add_target
-        target = LoadBalancerTarget(server=Server(id=1), use_private_ip=True)
         action = bound_load_balancer.add_target(target)
-        hetzner_client.request.assert_called_with(json={'type': None, 'server': {"id": 1}, 'use_private_ip': True},
+        params.update({'type': target.type, 'use_private_ip': target.use_private_ip})
+        hetzner_client.request.assert_called_with(json=params,
                                                   url="/load_balancers/14/actions/add_target", method="POST")
 
         assert action.id == 13
         assert action.progress == 100
         assert action.command == "add_target"
 
-    def test_remove_target(self, hetzner_client, response_remove_target, bound_load_balancer):
+    @pytest.mark.parametrize("target,params", [
+        (LoadBalancerTarget(type="server", server=Server(id=1), use_private_ip=True), {'server': {"id": 1}}),
+        (LoadBalancerTarget(type="ip", ip=LoadBalancerTargetIP(ip="127.0.0.1")), {'ip': {"ip": "127.0.0.1"}}),
+        (LoadBalancerTarget(type="label_selector", label_selector=LoadBalancerTargetLabelSelector(selector="abc=def")), {'label_selector': {"selector": "abc=def"}})
+    ])
+    def test_remove_target(self, hetzner_client, response_remove_target, bound_load_balancer, target, params):
         hetzner_client.request.return_value = response_remove_target
-        target = LoadBalancerTarget(server=Server(id=100))
         action = bound_load_balancer.remove_target(target)
-        hetzner_client.request.assert_called_with(json={'type': None, 'server': {"id": 100}},
+        params.update({'type': target.type})
+        hetzner_client.request.assert_called_with(json=params,
                                                   url="/load_balancers/14/actions/remove_target", method="POST")
 
         assert action.id == 13