| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. |
| # The ASF licenses this file to You under the Apache License, Version 2.0 |
| # (the "License"); you may not use this file except in compliance with |
| # the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| __all__ = ["SLB_API_VERSION", "SLBDriver"] |
| |
| try: |
| import simplejson as json |
| except ImportError: |
| import json |
| |
| from libcloud.common.aliyun import AliyunXmlResponse, SignedAliyunConnection |
| from libcloud.common.types import LibcloudError |
| from libcloud.loadbalancer.types import State |
| from libcloud.loadbalancer.base import Algorithm, Driver, LoadBalancer, Member |
| from libcloud.utils.misc import ReprMixin |
| from libcloud.utils.py3 import u |
| from libcloud.utils.xml import findattr, findtext, findall |
| |
| |
| SLB_API_VERSION = "2014-05-15" |
| SLB_API_HOST = "slb.aliyuncs.com" |
| DEFAULT_SIGNATURE_VERSION = "1.0" |
| |
| |
| STATE_MAPPINGS = { |
| "inactive": State.UNKNOWN, |
| "active": State.RUNNING, |
| "locked": State.PENDING, |
| } |
| |
| |
| RESOURCE_EXTRA_ATTRIBUTES_MAP = { |
| "balancer": { |
| "create_timestamp": {"xpath": "CreateTimeStamp", "transform_func": int}, |
| "address_type": {"xpath": "AddressType", "transform_func": u}, |
| "region_id": {"xpath": "RegionId", "transform_func": u}, |
| "region_id_alias": {"xpath": "RegionIdAlias", "transform_func": u}, |
| "create_time": {"xpath": "CreateTime", "transform_func": u}, |
| "master_zone_id": {"xpath": "MasterZoneId", "transform_func": u}, |
| "slave_zone_id": {"xpath": "SlaveZoneId", "transform_func": u}, |
| "network_type": {"xpath": "NetworkType", "transform_func": u}, |
| } |
| } |
| |
| |
| SLB_SCHEDULER_TO_ALGORITHM = { |
| "wrr": Algorithm.WEIGHTED_ROUND_ROBIN, |
| "wlc": Algorithm.WEIGHTED_LEAST_CONNECTIONS, |
| } |
| |
| |
| ALGORITHM_TO_SLB_SCHEDULER = { |
| Algorithm.WEIGHTED_ROUND_ROBIN: "wrr", |
| Algorithm.WEIGHTED_LEAST_CONNECTIONS: "wlc", |
| } |
| |
| |
| class SLBConnection(SignedAliyunConnection): |
| api_version = SLB_API_VERSION |
| host = SLB_API_HOST |
| responseCls = AliyunXmlResponse |
| service_name = "slb" |
| |
| |
| class SLBLoadBalancerAttribute(object): |
| """ |
| This class used to get listeners and backend servers related to a balancer |
| listeners is a ``list`` of ``dict``, each element contains |
| 'ListenerPort' and 'ListenerProtocol' keys. |
| backend_servers is a ``list`` of ``dict``, each element contains |
| 'ServerId' and 'Weight' keys. |
| """ |
| |
| def __init__(self, balancer, listeners, backend_servers, extra=None): |
| self.balancer = balancer |
| self.listeners = listeners or [] |
| self.backend_servers = backend_servers or [] |
| self.extra = extra or {} |
| |
| def is_listening(self, port): |
| for listener in self.listeners: |
| if listener.get("ListenerPort") == port: |
| return True |
| return False |
| |
| def is_attached(self, member): |
| for server in self.backend_servers: |
| if server.get("Serverid") == member.id: |
| return True |
| return False |
| |
| def __repr__(self): |
| return "<SLBLoadBalancerAttribute id=%s, ports=%s, servers=%s ...>" % ( |
| self.balancer.id, |
| self.listeners, |
| self.backend_servers, |
| ) |
| |
| |
| class SLBLoadBalancerListener(ReprMixin, object): |
| """ |
| Base SLB load balancer listener class |
| """ |
| |
| _repr_attributes = ["port", "backend_port", "scheduler", "bandwidth"] |
| action = None |
| option_keys = [] |
| |
| def __init__(self, port, backend_port, algorithm, bandwidth, extra=None): |
| self.port = port |
| self.backend_port = backend_port |
| self.scheduler = ALGORITHM_TO_SLB_SCHEDULER.get(algorithm, "wrr") |
| self.bandwidth = bandwidth |
| self.extra = extra or {} |
| |
| @classmethod |
| def create(cls, port, backend_port, algorithm, bandwidth, extra=None): |
| return cls(port, backend_port, algorithm, bandwidth, extra=extra) |
| |
| def get_create_params(self): |
| params = self.get_required_params() |
| options = self.get_optional_params() |
| options.update(params) |
| return options |
| |
| def get_required_params(self): |
| params = { |
| "Action": self.action, |
| "ListenerPort": self.port, |
| "BackendServerPort": self.backend_port, |
| "Scheduler": self.scheduler, |
| "Bandwidth": self.bandwidth, |
| } |
| return params |
| |
| def get_optional_params(self): |
| options = {} |
| for option in self.option_keys: |
| if self.extra and option in self.extra: |
| options[option] = self.extra[option] |
| return options |
| |
| |
| class SLBLoadBalancerHttpListener(SLBLoadBalancerListener): |
| """ |
| This class represents a rule to route http request to the backends. |
| """ |
| |
| action = "CreateLoadBalancerHTTPListener" |
| option_keys = [ |
| "XForwardedFor", |
| "StickySessionType", |
| "CookieTimeout", |
| "Cookie", |
| "HealthCheckDomain", |
| "HealthCheckURI", |
| "HealthCheckConnectPort", |
| "HealthyThreshold", |
| "UnhealthyThreshold", |
| "HealthCheckTimeout", |
| "HealthCheckInterval", |
| "HealthCheckHttpCode", |
| ] |
| |
| def __init__( |
| self, |
| port, |
| backend_port, |
| algorithm, |
| bandwidth, |
| sticky_session, |
| health_check, |
| extra=None, |
| ): |
| super(SLBLoadBalancerHttpListener, self).__init__( |
| port, backend_port, algorithm, bandwidth, extra=extra |
| ) |
| self.sticky_session = sticky_session |
| self.health_check = health_check |
| |
| def get_required_params(self): |
| params = super(SLBLoadBalancerHttpListener, self).get_required_params() |
| params["StickySession"] = self.sticky_session |
| params["HealthCheck"] = self.health_check |
| return params |
| |
| @classmethod |
| def create(cls, port, backend_port, algorithm, bandwidth, extra={}): |
| if "StickySession" not in extra: |
| raise AttributeError("StickySession is required") |
| if "HealthCheck" not in extra: |
| raise AttributeError("HealthCheck is required") |
| sticky_session = extra["StickySession"] |
| health_check = extra["HealthCheck"] |
| return cls( |
| port, |
| backend_port, |
| algorithm, |
| bandwidth, |
| sticky_session, |
| health_check, |
| extra=extra, |
| ) |
| |
| |
| class SLBLoadBalancerHttpsListener(SLBLoadBalancerListener): |
| """ |
| This class represents a rule to route https request to the backends. |
| """ |
| |
| action = "CreateLoadBalancerHTTPSListener" |
| option_keys = [ |
| "XForwardedFor", |
| "StickySessionType", |
| "CookieTimeout", |
| "Cookie", |
| "HealthCheckDomain", |
| "HealthCheckURI", |
| "HealthCheckConnectPort", |
| "HealthyThreshold", |
| "UnhealthyThreshold", |
| "HealthCheckTimeout", |
| "HealthCheckInterval", |
| "HealthCheckHttpCode", |
| ] |
| |
| def __init__( |
| self, |
| port, |
| backend_port, |
| algorithm, |
| bandwidth, |
| sticky_session, |
| health_check, |
| certificate_id, |
| extra=None, |
| ): |
| super(SLBLoadBalancerHttpsListener, self).__init__( |
| port, backend_port, algorithm, bandwidth, extra=extra |
| ) |
| self.sticky_session = sticky_session |
| self.health_check = health_check |
| self.certificate_id = certificate_id |
| |
| def get_required_params(self): |
| params = super(SLBLoadBalancerHttpsListener, self).get_required_params() |
| params["StickySession"] = self.sticky_session |
| params["HealthCheck"] = self.health_check |
| params["ServerCertificateId"] = self.certificate_id |
| return params |
| |
| @classmethod |
| def create(cls, port, backend_port, algorithm, bandwidth, extra={}): |
| if "StickySession" not in extra: |
| raise AttributeError("StickySession is required") |
| if "HealthCheck" not in extra: |
| raise AttributeError("HealthCheck is required") |
| if "ServerCertificateId" not in extra: |
| raise AttributeError("ServerCertificateId is required") |
| sticky_session = extra["StickySession"] |
| health_check = extra["HealthCheck"] |
| certificate_id = extra["ServerCertificateId"] |
| return cls( |
| port, |
| backend_port, |
| algorithm, |
| bandwidth, |
| sticky_session, |
| health_check, |
| certificate_id, |
| extra=extra, |
| ) |
| |
| |
| class SLBLoadBalancerTcpListener(SLBLoadBalancerListener): |
| """ |
| This class represents a rule to route tcp request to the backends. |
| """ |
| |
| action = "CreateLoadBalancerTCPListener" |
| option_keys = [ |
| "PersistenceTimeout", |
| "HealthCheckType", |
| "HealthCheckDomain", |
| "HealthCheckURI", |
| "HealthCheckConnectPort", |
| "HealthyThreshold", |
| "UnhealthyThreshold", |
| "HealthCheckConnectTimeout", |
| "HealthCheckInterval", |
| "HealthCheckHttpCode", |
| ] |
| |
| |
| class SLBLoadBalancerUdpListener(SLBLoadBalancerTcpListener): |
| """ |
| This class represents a rule to route udp request to the backends. |
| """ |
| |
| action = "CreateLoadBalancerUDPListener" |
| option_keys = [ |
| "PersistenceTimeout", |
| "HealthCheckConnectPort", |
| "HealthyThreshold", |
| "UnhealthyThreshold", |
| "HealthCheckConnectTimeout", |
| "HealthCheckInterval", |
| ] |
| |
| |
| class SLBServerCertificate(ReprMixin, object): |
| _repr_attributes = ["id", "name", "fingerprint"] |
| |
| def __init__(self, id, name, fingerprint): |
| self.id = id |
| self.name = name |
| self.fingerprint = fingerprint |
| |
| |
| PROTOCOL_TO_LISTENER_MAP = { |
| "http": SLBLoadBalancerHttpListener, |
| "https": SLBLoadBalancerHttpsListener, |
| "tcp": SLBLoadBalancerTcpListener, |
| "udp": SLBLoadBalancerUdpListener, |
| } |
| |
| |
| class SLBDriver(Driver): |
| """ |
| Aliyun SLB load balancer driver. |
| """ |
| |
| name = "Aliyun Server Load Balancer" |
| website = "https://www.aliyun.com/product/slb" |
| connectionCls = SLBConnection |
| path = "/" |
| namespace = None |
| |
| _VALUE_TO_ALGORITHM_MAP = SLB_SCHEDULER_TO_ALGORITHM |
| |
| _ALGORITHM_TO_VALUE_MAP = ALGORITHM_TO_SLB_SCHEDULER |
| |
| def __init__(self, access_id, secret, region): |
| super(SLBDriver, self).__init__(access_id, secret) |
| self.region = region |
| |
| def list_protocols(self): |
| return list(PROTOCOL_TO_LISTENER_MAP.keys()) |
| |
| def list_balancers(self, ex_balancer_ids=None, ex_filters=None): |
| """ |
| List all loadbalancers |
| |
| @inherits :class:`Driver.list_balancers` |
| |
| :keyword ex_balancer_ids: a list of balancer ids to filter results |
| Only balancers which's id in this list |
| will be returned |
| :type ex_balancer_ids: ``list`` of ``str`` |
| |
| :keyword ex_filters: attributes to filter results. Only balancers |
| which have all the desired attributes |
| and values will be returned |
| :type ex_filters: ``dict`` |
| """ |
| |
| params = {"Action": "DescribeLoadBalancers", "RegionId": self.region} |
| if ex_balancer_ids and isinstance(ex_balancer_ids, list): |
| params["LoadBalancerId"] = ",".join(ex_balancer_ids) |
| |
| if ex_filters and isinstance(ex_filters, dict): |
| ex_filters.update(params) |
| params = ex_filters |
| resp_body = self.connection.request(self.path, params=params).object |
| return self._to_balancers(resp_body) |
| |
| def create_balancer( |
| self, |
| name, |
| port, |
| protocol, |
| algorithm, |
| members, |
| ex_bandwidth=None, |
| ex_internet_charge_type=None, |
| ex_address_type=None, |
| ex_vswitch_id=None, |
| ex_master_zone_id=None, |
| ex_slave_zone_id=None, |
| ex_client_token=None, |
| **kwargs, |
| ): |
| """ |
| Create a new load balancer instance |
| |
| @inherits: :class:`Driver.create_balancer` |
| |
| :keyword ex_bandwidth: The max bandwidth limit for `paybybandwidth` |
| internet charge type, in Mbps unit |
| :type ex_bandwidth: ``int`` in range [1, 1000] |
| |
| :keyword ex_internet_charge_type: The internet charge type |
| :type ex_internet_charge_type: a ``str`` of `paybybandwidth` |
| or `paybytraffic` |
| |
| :keyword ex_address_type: The listening IP address type |
| :type ex_address_type: a ``str`` of `internet` or `intranet` |
| |
| :keyword ex_vswitch_id: The vswitch id in a VPC network |
| :type ex_vswitch_id: ``str`` |
| |
| :keyword ex_master_zone_id: The id of the master availability zone |
| :type ex_master_zone_id: ``str`` |
| |
| :keyword ex_slave_zone_id: The id of the slave availability zone |
| :type ex_slave_zone_id: ``str`` |
| |
| :keyword ex_client_token: The token generated by client to |
| identify requests |
| :type ex_client_token: ``str`` |
| """ |
| |
| # 1.Create load balancer |
| params = {"Action": "CreateLoadBalancer", "RegionId": self.region} |
| if name: |
| params["LoadBalancerName"] = name |
| if not port: |
| raise AttributeError("port is required") |
| if not protocol: |
| # NOTE(samsong8610): Use http listener as default |
| protocol = "http" |
| if protocol not in PROTOCOL_TO_LISTENER_MAP: |
| raise AttributeError("unsupport protocol %s" % protocol) |
| |
| # Bandwidth in range [1, 1000] Mbps |
| bandwidth = -1 |
| if ex_bandwidth: |
| try: |
| bandwidth = int(ex_bandwidth) |
| except ValueError: |
| raise AttributeError( |
| "ex_bandwidth should be a integer in " "range [1, 1000]." |
| ) |
| params["Bandwidth"] = bandwidth |
| |
| if ex_internet_charge_type: |
| if ex_internet_charge_type.lower() == "paybybandwidth": |
| if bandwidth == -1: |
| raise AttributeError( |
| "PayByBandwidth internet charge type" |
| " need ex_bandwidth be set" |
| ) |
| params["InternetChargeType"] = ex_internet_charge_type |
| |
| if ex_address_type: |
| if ex_address_type.lower() not in ("internet", "intranet"): |
| raise AttributeError( |
| 'ex_address_type should be "internet" ' 'or "intranet"' |
| ) |
| params["AddressType"] = ex_address_type |
| |
| if ex_vswitch_id: |
| params["VSwitchId"] = ex_vswitch_id |
| |
| if ex_master_zone_id: |
| params["MasterZoneId"] = ex_master_zone_id |
| if ex_slave_zone_id: |
| params["SlaveZoneId"] = ex_slave_zone_id |
| |
| if ex_client_token: |
| params["ClientToken"] = ex_client_token |
| |
| if members and isinstance(members, list): |
| backend_ports = [member.port for member in members] |
| if len(set(backend_ports)) != 1: |
| raise AttributeError("the ports of members should be unique") |
| # NOTE(samsong8610): If members do not provide backend port, |
| # default to listening port |
| backend_port = backend_ports[0] or port |
| else: |
| backend_port = port |
| |
| balancer = None |
| try: |
| resp_body = self.connection.request(self.path, params).object |
| balancer = self._to_balancer(resp_body) |
| balancer.port = port |
| |
| # 2.Add backend servers |
| if members is None: |
| members = [] |
| for member in members: |
| self.balancer_attach_member(balancer, member) |
| # 3.Create listener |
| # NOTE(samsong8610): Assume only create a listener which uses all |
| # the bandwidth. |
| self.ex_create_listener( |
| balancer, backend_port, protocol, algorithm, bandwidth, **kwargs |
| ) |
| self.ex_start_listener(balancer, port) |
| return balancer |
| except Exception as e: |
| if balancer is not None: |
| try: |
| self.destroy_balancer(balancer) |
| except Exception: |
| pass |
| raise e |
| |
| def destroy_balancer(self, balancer): |
| params = {"Action": "DeleteLoadBalancer", "LoadBalancerId": balancer.id} |
| resp = self.connection.request(self.path, params) |
| return resp.success() |
| |
| def get_balancer(self, balancer_id): |
| balancers = self.list_balancers(ex_balancer_ids=[balancer_id]) |
| if len(balancers) != 1: |
| raise LibcloudError("could not find load balancer with id %s" % balancer_id) |
| return balancers[0] |
| |
| def balancer_attach_compute_node(self, balancer, node): |
| if len(node.public_ips) > 0: |
| ip = node.public_ips[0] |
| else: |
| ip = node.private_ips[0] |
| member = Member(id=node.id, ip=ip, port=balancer.port) |
| return self.balancer_attach_member(balancer, member) |
| |
| def balancer_attach_member(self, balancer, member): |
| params = {"Action": "AddBackendServers", "LoadBalancerId": balancer.id} |
| if member and isinstance(member, Member): |
| params["BackendServers"] = self._to_servers_json([member]) |
| self.connection.request(self.path, params) |
| return member |
| |
| def balancer_detach_member(self, balancer, member): |
| params = {"Action": "RemoveBackendServers", "LoadBalancerId": balancer.id} |
| if member and isinstance(member, Member): |
| params["BackendServers"] = self._list_to_json([member.id]) |
| self.connection.request(self.path, params) |
| return member |
| |
| def balancer_list_members(self, balancer): |
| attribute = self.ex_get_balancer_attribute(balancer) |
| members = [ |
| Member( |
| server["ServerId"], |
| None, |
| None, |
| balancer=balancer, |
| extra={"Weight": server["Weight"]}, |
| ) |
| for server in attribute.backend_servers |
| ] |
| return members |
| |
| def ex_get_balancer_attribute(self, balancer): |
| """ |
| Get balancer attribute |
| |
| :param balancer: the balancer to get attribute |
| :type balancer: ``LoadBalancer`` |
| |
| :return: the balancer attribute |
| :rtype: ``SLBLoadBalancerAttribute`` |
| """ |
| |
| params = { |
| "Action": "DescribeLoadBalancerAttribute", |
| "LoadBalancerId": balancer.id, |
| } |
| resp_body = self.connection.request(self.path, params).object |
| attribute = self._to_balancer_attribute(resp_body) |
| return attribute |
| |
| def ex_list_listeners(self, balancer): |
| """ |
| Get all listener related to the given balancer |
| |
| :param balancer: the balancer to list listeners |
| :type balancer: ``LoadBalancer`` |
| |
| :return: a list of listeners |
| :rtype: ``list`` of ``SLBLoadBalancerListener`` |
| """ |
| |
| attribute = self.ex_get_balancer_attribute(balancer) |
| listeners = [ |
| SLBLoadBalancerListener(each["ListenerPort"], None, None, None) |
| for each in attribute.listeners |
| ] |
| return listeners |
| |
| def ex_create_listener( |
| self, balancer, backend_port, protocol, algorithm, bandwidth, **kwargs |
| ): |
| """ |
| Create load balancer listening rule. |
| |
| :param balancer: the balancer which the rule belongs to. |
| The listener created will listen on the port of the |
| the balancer as default. 'ListenerPort' in kwargs |
| will *OVERRIDE* it. |
| :type balancer: ``LoadBalancer`` |
| |
| :param backend_port: the backend server port |
| :type backend_port: ``int`` |
| |
| :param protocol: the balancer protocol, default to http |
| :type protocol: ``str`` |
| |
| :param algorithm: the balancer routing algorithm |
| :type algorithm: ``Algorithm`` |
| |
| :param bandwidth: the listener bandwidth limits |
| :type bandwidth: ``str`` |
| |
| :return: the created listener |
| :rtype: ``SLBLoadBalancerListener`` |
| """ |
| |
| cls = PROTOCOL_TO_LISTENER_MAP.get(protocol, SLBLoadBalancerHttpListener) |
| if "ListenerPort" in kwargs: |
| port = kwargs["ListenerPort"] |
| else: |
| port = balancer.port |
| listener = cls.create(port, backend_port, algorithm, bandwidth, extra=kwargs) |
| params = listener.get_create_params() |
| params["LoadBalancerId"] = balancer.id |
| params["RegionId"] = self.region |
| resp = self.connection.request(self.path, params) |
| return resp.success() |
| |
| def ex_start_listener(self, balancer, port): |
| """ |
| Start balancer's listener listening the given port. |
| |
| :param balancer: a load balancer |
| :type balancer: ``LoadBalancer`` |
| |
| :param port: listening port |
| :type port: ``int`` |
| |
| :return: whether operation is success |
| :rtype: ``bool`` |
| """ |
| |
| params = { |
| "Action": "StartLoadBalancerListener", |
| "LoadBalancerId": balancer.id, |
| "ListenerPort": port, |
| } |
| resp = self.connection.request(self.path, params) |
| return resp.success() |
| |
| def ex_stop_listener(self, balancer, port): |
| """ |
| Stop balancer's listener listening the given port. |
| |
| :param balancer: a load balancer |
| :type balancer: ``LoadBalancer`` |
| |
| :param port: listening port |
| :type port: ``int`` |
| |
| :return: whether operation is success |
| :rtype: ``bool`` |
| """ |
| |
| params = { |
| "Action": "StopLoadBalancerListener", |
| "LoadBalancerId": balancer.id, |
| "ListenerPort": port, |
| } |
| resp = self.connection.request(self.path, params) |
| return resp.success() |
| |
| def ex_upload_certificate(self, name, server_certificate, private_key): |
| """ |
| Upload certificate and private key for https load balancer listener |
| |
| :param name: the certificate name |
| :type name: ``str`` |
| |
| :param server_certificate: the content of the certificate to upload |
| in PEM format |
| :type server_certificate: ``str`` |
| |
| :param private_key: the content of the private key to upload |
| in PEM format |
| :type private_key: ``str`` |
| |
| :return: new created certificate info |
| :rtype: ``SLBServerCertificate`` |
| """ |
| |
| params = { |
| "Action": "UploadServerCertificate", |
| "RegionId": self.region, |
| "ServerCertificate": server_certificate, |
| "PrivateKey": private_key, |
| } |
| if name: |
| params["ServerCertificateName"] = name |
| resp_body = self.connection.request(self.path, params).object |
| return self._to_server_certificate(resp_body) |
| |
| def ex_list_certificates(self, certificate_ids=[]): |
| """ |
| List all server certificates |
| |
| :param certificate_ids: certificate ids to filter results |
| :type certificate_ids: ``str`` |
| |
| :return: certificates |
| :rtype: ``SLBServerCertificate`` |
| """ |
| |
| params = {"Action": "DescribeServerCertificates", "RegionId": self.region} |
| if certificate_ids and isinstance(certificate_ids, list): |
| params["ServerCertificateId"] = ",".join(certificate_ids) |
| |
| resp_body = self.connection.request(self.path, params).object |
| cert_elements = findall( |
| resp_body, "ServerCertificates/ServerCertificate", namespace=self.namespace |
| ) |
| certificates = [self._to_server_certificate(el) for el in cert_elements] |
| return certificates |
| |
| def ex_delete_certificate(self, certificate_id): |
| """ |
| Delete the given server certificate |
| |
| :param certificate_id: the id of the certificate to delete |
| :type certificate_id: ``str`` |
| |
| :return: whether process is success |
| :rtype: ``bool`` |
| """ |
| |
| params = { |
| "Action": "DeleteServerCertificate", |
| "RegionId": self.region, |
| "ServerCertificateId": certificate_id, |
| } |
| resp = self.connection.request(self.path, params) |
| return resp.success() |
| |
| def ex_set_certificate_name(self, certificate_id, name): |
| """ |
| Set server certificate name. |
| |
| :param certificate_id: the id of the server certificate to update |
| :type certificate_id: ``str`` |
| |
| :param name: the new name |
| :type name: ``str`` |
| |
| :return: whether updating is success |
| :rtype: ``bool`` |
| """ |
| |
| params = { |
| "Action": "SetServerCertificateName", |
| "RegionId": self.region, |
| "ServerCertificateId": certificate_id, |
| "ServerCertificateName": name, |
| } |
| resp = self.connection.request(self.path, params) |
| return resp.success() |
| |
| def _to_balancers(self, element): |
| xpath = "LoadBalancers/LoadBalancer" |
| return [ |
| self._to_balancer(el) |
| for el in findall(element=element, xpath=xpath, namespace=self.namespace) |
| ] |
| |
| def _to_balancer(self, el): |
| _id = findtext(element=el, xpath="LoadBalancerId", namespace=self.namespace) |
| name = findtext(element=el, xpath="LoadBalancerName", namespace=self.namespace) |
| status = findtext( |
| element=el, xpath="LoadBalancerStatus", namespace=self.namespace |
| ) |
| state = STATE_MAPPINGS.get(status, State.UNKNOWN) |
| address = findtext(element=el, xpath="Address", namespace=self.namespace) |
| extra = self._get_extra_dict(el, RESOURCE_EXTRA_ATTRIBUTES_MAP["balancer"]) |
| |
| balancer = LoadBalancer( |
| id=_id, |
| name=name, |
| state=state, |
| ip=address, |
| port=None, |
| driver=self, |
| extra=extra, |
| ) |
| return balancer |
| |
| def _create_list_params(self, params, items, label): |
| """ |
| return parameter list |
| """ |
| if isinstance(items, str): |
| items = [items] |
| for index, item in enumerate(items): |
| params[label % (index + 1)] = item |
| return params |
| |
| def _get_extra_dict(self, element, mapping): |
| """ |
| Extract attributes from the element based on rules provided in the |
| mapping dictionary. |
| |
| :param element: Element to parse the values from. |
| :type element: xml.etree.ElementTree.Element. |
| |
| :param mapping: Dictionary with the extra layout |
| :type node: :class:`Node` |
| |
| :rtype: ``dict`` |
| """ |
| extra = {} |
| for attribute, values in mapping.items(): |
| transform_func = values["transform_func"] |
| value = findattr( |
| element=element, xpath=values["xpath"], namespace=self.namespace |
| ) |
| if value: |
| try: |
| extra[attribute] = transform_func(value) |
| except Exception: |
| extra[attribute] = None |
| else: |
| extra[attribute] = value |
| |
| return extra |
| |
| def _to_servers_json(self, members): |
| servers = [] |
| for each in members: |
| server = {"ServerId": each.id, "Weight": "100"} |
| if "Weight" in each.extra: |
| server["Weight"] = each.extra["Weight"] |
| servers.append(server) |
| try: |
| return json.dumps(servers) |
| except Exception: |
| raise AttributeError("could not convert member to backend server") |
| |
| def _to_balancer_attribute(self, element): |
| balancer = self._to_balancer(element) |
| port_proto_elements = findall( |
| element, |
| "ListenerPortsAndProtocol/ListenerPortAndProtocol", |
| namespace=self.namespace, |
| ) |
| if len(port_proto_elements) > 0: |
| listeners = [self._to_port_and_protocol(el) for el in port_proto_elements] |
| else: |
| port_elements = findall( |
| element, "ListenerPorts/ListenerPort", namespace=self.namespace |
| ) |
| listeners = [ |
| {"ListenerPort": el.text, "ListenerProtocol": "http"} |
| for el in port_elements |
| ] |
| server_elements = findall( |
| element, "BackendServers/BackendServer", namespace=self.namespace |
| ) |
| backend_servers = [self._to_server_and_weight(el) for el in server_elements] |
| return SLBLoadBalancerAttribute(balancer, listeners, backend_servers) |
| |
| def _to_port_and_protocol(self, el): |
| port = findtext(el, "ListenerPort", namespace=self.namespace) |
| protocol = findtext(el, "ListenerProtocol", namespace=self.namespace) |
| return {"ListenerPort": port, "ListenerProtocol": protocol} |
| |
| def _to_server_and_weight(self, el): |
| server_id = findtext(el, "ServerId", namespace=self.namespace) |
| weight = findtext(el, "Weight", namespace=self.namespace) |
| return {"ServerId": server_id, "Weight": weight} |
| |
| def _to_server_certificate(self, el): |
| _id = findtext(el, "ServerCertificateId", namespace=self.namespace) |
| name = findtext(el, "ServerCertificateName", namespace=self.namespace) |
| fingerprint = findtext(el, "Fingerprint", namespace=self.namespace) |
| return SLBServerCertificate(id=_id, name=name, fingerprint=fingerprint) |
| |
| def _list_to_json(self, value): |
| try: |
| return json.dumps(value) |
| except Exception: |
| return "[]" |
