Server IP : 85.214.239.14 / Your IP : 3.144.104.175 Web Server : Apache/2.4.62 (Debian) System : Linux h2886529.stratoserver.net 4.9.0 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.18 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /proc/2/root/proc/3/root/lib/python3/dist-packages/libcloud/loadbalancer/ |
Upload File : |
# 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. from libcloud.common.base import ConnectionKey, BaseDriver from libcloud.common.types import LibcloudError __all__ = [ 'Member', 'LoadBalancer', 'Algorithm', 'Driver', 'DEFAULT_ALGORITHM' ] class Member(object): """ Represents a load balancer member. """ def __init__(self, id, ip, port, balancer=None, extra=None): """ :param id: Member ID. :type id: ``str`` :param ip: IP address of this member. :param ip: ``str`` :param port: Port of this member :param port: ``str`` :param balancer: Balancer this member is attached to. (optional) :param balancer: :class:`.LoadBalancer` :param extra: Provider specific attributes. :type extra: ``dict`` """ self.id = str(id) if id else None self.ip = ip self.port = port self.balancer = balancer self.extra = extra or {} def __repr__(self): return ('<Member: id=%s, address=%s:%s>' % (self.id, self.ip, self.port)) class LoadBalancer(object): """ Provide a common interface for handling Load Balancers. """ def __init__(self, id, name, state, ip, port, driver, extra=None): """ :param id: Load balancer ID. :type id: ``str`` :param name: Load balancer name. :type name: ``str`` :param state: State this loadbalancer is in. :type state: :class:`libcloud.loadbalancer.types.State` :param ip: IP address of this loadbalancer. :type ip: ``str`` :param port: Port of this loadbalancer. :type port: ``int`` :param driver: Driver this loadbalancer belongs to. :type driver: :class:`.Driver` :param extra: Provider specific attributes. (optional) :type extra: ``dict`` """ self.id = str(id) if id else None self.name = name self.state = state self.ip = ip self.port = port self.driver = driver self.extra = extra or {} def attach_compute_node(self, node): return self.driver.balancer_attach_compute_node(balancer=self, node=node) def attach_member(self, member): return self.driver.balancer_attach_member(balancer=self, member=member) def detach_member(self, member): return self.driver.balancer_detach_member(balancer=self, member=member) def list_members(self): return self.driver.balancer_list_members(balancer=self) def destroy(self): return self.driver.destroy_balancer(balancer=self) def __repr__(self): return ('<LoadBalancer: id=%s, name=%s, state=%s, ip=%s, ' 'port=%s>' % (self.id, self.name, self.state, self.ip, self.port)) class Algorithm(object): """ Represents a load balancing algorithm. """ RANDOM = 0 ROUND_ROBIN = 1 LEAST_CONNECTIONS = 2 WEIGHTED_ROUND_ROBIN = 3 WEIGHTED_LEAST_CONNECTIONS = 4 SHORTEST_RESPONSE = 5 PERSISTENT_IP = 6 LEAST_CONNECTIONS_MEMBER = 7 LEAST_CONNECTIONS_NODE = 8 OBSERVED_MEMBER = 9 OBSERVED_NODE = 10 PREDICTIVE_MEMBER = 11 PREDICTIVE_NODE = 12 DEFAULT_ALGORITHM = Algorithm.ROUND_ROBIN class Driver(BaseDriver): """ A base Driver class to derive from This class is always subclassed by a specific driver. """ name = None website = None connectionCls = ConnectionKey _ALGORITHM_TO_VALUE_MAP = {} _VALUE_TO_ALGORITHM_MAP = {} def __init__(self, key, secret=None, secure=True, host=None, port=None, **kwargs): super(Driver, self).__init__(key=key, secret=secret, secure=secure, host=host, port=port, **kwargs) def list_protocols(self): """ Return a list of supported protocols. :rtype: ``list`` of ``str`` """ raise NotImplementedError( 'list_protocols not implemented for this driver') def list_balancers(self): """ List all loadbalancers :rtype: ``list`` of :class:`LoadBalancer` """ raise NotImplementedError( 'list_balancers not implemented for this driver') def create_balancer(self, name, port, protocol, algorithm, members): """ Create a new load balancer instance :param name: Name of the new load balancer (required) :type name: ``str`` :param port: Port the load balancer should listen on, defaults to 80 :type port: ``str`` :param protocol: Loadbalancer protocol, defaults to http. :type protocol: ``str`` :param members: list of Members to attach to balancer :type members: ``list`` of :class:`Member` :param algorithm: Load balancing algorithm, defaults to ROUND_ROBIN. :type algorithm: :class:`.Algorithm` :rtype: :class:`LoadBalancer` """ raise NotImplementedError( 'create_balancer not implemented for this driver') def destroy_balancer(self, balancer): """ Destroy a load balancer :param balancer: LoadBalancer which should be used :type balancer: :class:`LoadBalancer` :return: ``True`` if the destroy was successful, otherwise ``False``. :rtype: ``bool`` """ raise NotImplementedError( 'destroy_balancer not implemented for this driver') def get_balancer(self, balancer_id): """ Return a :class:`LoadBalancer` object. :param balancer_id: id of a load balancer you want to fetch :type balancer_id: ``str`` :rtype: :class:`LoadBalancer` """ raise NotImplementedError( 'get_balancer not implemented for this driver') def update_balancer(self, balancer, **kwargs): """ Sets the name, algorithm, protocol, or port on a load balancer. :param balancer: LoadBalancer which should be used :type balancer: :class:`LoadBalancer` :param name: New load balancer name :type name: ``str`` :param algorithm: New load balancer algorithm :type algorithm: :class:`.Algorithm` :param protocol: New load balancer protocol :type protocol: ``str`` :param port: New load balancer port :type port: ``int`` :rtype: :class:`LoadBalancer` """ raise NotImplementedError( 'update_balancer not implemented for this driver') def balancer_attach_compute_node(self, balancer, node): """ Attach a compute node as a member to the load balancer. :param balancer: LoadBalancer which should be used :type balancer: :class:`LoadBalancer` :param node: Node to join to the balancer :type node: :class:`Node` :return: Member after joining the balancer. :rtype: :class:`Member` """ member = Member(id=None, ip=node.public_ips[0], port=balancer.port) return self.balancer_attach_member(balancer, member) def balancer_attach_member(self, balancer, member): """ Attach a member to balancer :param balancer: LoadBalancer which should be used :type balancer: :class:`LoadBalancer` :param member: Member to join to the balancer :type member: :class:`Member` :return: Member after joining the balancer. :rtype: :class:`Member` """ raise NotImplementedError( 'balancer_attach_member not implemented for this driver') def balancer_detach_member(self, balancer, member): """ Detach member from balancer :param balancer: LoadBalancer which should be used :type balancer: :class:`LoadBalancer` :param member: Member which should be used :type member: :class:`Member` :return: ``True`` if member detach was successful, otherwise ``False``. :rtype: ``bool`` """ raise NotImplementedError( 'balancer_detach_member not implemented for this driver') def balancer_list_members(self, balancer): """ Return list of members attached to balancer :param balancer: LoadBalancer which should be used :type balancer: :class:`LoadBalancer` :rtype: ``list`` of :class:`Member` """ raise NotImplementedError( 'balancer_list_members not implemented for this driver') def list_supported_algorithms(self): """ Return algorithms supported by this driver. :rtype: ``list`` of ``str`` """ return list(self._ALGORITHM_TO_VALUE_MAP.keys()) def _value_to_algorithm(self, value): """ Return :class:`.Algorithm` based on the value. :param value: Algorithm name (e.g. http, tcp, ...). :type value: ``str`` :rtype: :class:`.Algorithm` """ try: return self._VALUE_TO_ALGORITHM_MAP[value] except KeyError: raise LibcloudError(value='Invalid value: %s' % (value), driver=self) def _algorithm_to_value(self, algorithm): """ Return string value for the provided algorithm. :param value: Algorithm enum. :type value: :class:`Algorithm` :rtype: ``str`` """ try: return self._ALGORITHM_TO_VALUE_MAP[algorithm] except KeyError: raise LibcloudError(value='Invalid algorithm: %s' % (algorithm), driver=self)