829 lines
30 KiB
Python
829 lines
30 KiB
Python
# 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 '[]'
|