FM / drivers

/opt/imh-python/lib/python3.9/site-packages/libcloud/loadbalancer/drivers/

/opt/imh-python/lib/python3.9/site-packages/libcloud/loadbalancer/drivers

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
alb.py	37448	0644	edit dl rm
brightbox.py	4831	0644	edit dl rm
cloudstack.py	7735	0644	edit dl rm
dimensiondata.py	43388	0644	edit dl rm
elb.py	14254	0644	edit dl rm
gce.py	13672	0644	edit dl rm
gogrid.py	8360	0644	edit dl rm
ninefold.py	1173	0644	edit dl rm
nttcis.py	61849	0644	edit dl rm
rackspace.py	56883	0644	edit dl rm
slb.py	30518	0644	edit dl rm
softlayer.py	15132	0644	edit dl rm
__init__.py	840	0644	edit dl rm

Edit: /opt/imh-python/lib/python3.9/site-packages/libcloud/loadbalancer/drivers/cloudstack.py (7735B)

# 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.cloudstack import CloudStackDriverMixIn
from libcloud.loadbalancer.base import LoadBalancer, Member, Driver, Algorithm
from libcloud.loadbalancer.base import DEFAULT_ALGORITHM
from libcloud.loadbalancer.types import Provider
from libcloud.loadbalancer.types import State
from libcloud.utils.misc import reverse_dict

class CloudStackLBDriver(CloudStackDriverMixIn, Driver):
    """Driver for CloudStack load balancers."""

api_name = 'cloudstack_lb'
    name = 'CloudStack'
    website = 'http://cloudstack.org/'
    type = Provider.CLOUDSTACK

_VALUE_TO_ALGORITHM_MAP = {
        'roundrobin': Algorithm.ROUND_ROBIN,
        'leastconn': Algorithm.LEAST_CONNECTIONS
    }
    _ALGORITHM_TO_VALUE_MAP = reverse_dict(_VALUE_TO_ALGORITHM_MAP)

LB_STATE_MAP = {
        'Active': State.RUNNING,
    }

def __init__(self, key, secret=None, secure=True, host=None,
                 path=None, port=None, *args, **kwargs):
        """
        @inherits: :class:`Driver.__init__`
        """
        host = host if host else self.host
        path = path if path else self.path

if path is not None:
            self.path = path

if host is not None:
            self.host = host

if (self.type == Provider.CLOUDSTACK) and (not host or not path):
            raise Exception('When instantiating CloudStack driver directly ' +
                            'you also need to provide host and path argument')

super(CloudStackLBDriver, self).__init__(key=key, secret=secret,
                                                 secure=secure,
                                                 host=host, port=port)

def list_protocols(self):
        """
        We don't actually have any protocol awareness beyond TCP.

:rtype: ``list`` of ``str``
        """
        return ['tcp']

def list_balancers(self):
        balancers = self._sync_request(command='listLoadBalancerRules',
                                       method='GET')
        balancers = balancers.get('loadbalancerrule', [])
        return [self._to_balancer(balancer) for balancer in balancers]

def get_balancer(self, balancer_id):
        balancer = self._sync_request(command='listLoadBalancerRules',
                                      params={'id': balancer_id},
                                      method='GET')
        balancer = balancer.get('loadbalancerrule', [])
        if not balancer:
            raise Exception("no such load balancer: " + str(balancer_id))
        return self._to_balancer(balancer[0])

def create_balancer(self, name, members, protocol='http', port=80,
                        algorithm=DEFAULT_ALGORITHM, location=None,
                        private_port=None, network_id=None, vpc_id=None):
        """
        @inherits: :class:`Driver.create_balancer`

:param location: Location
        :type  location: :class:`NodeLocation`

:param private_port: Private port
        :type  private_port: ``int``

:param network_id: The guest network this rule will be created for.
        :type  network_id: ``str``
        """

args = {}
        ip_args = {}

if location is None:
            locations = self._sync_request(command='listZones', method='GET')
            location = locations['zone'][0]['id']
        else:
            location = location.id
        if private_port is None:
            private_port = port

if network_id is not None:
            args['networkid'] = network_id
            ip_args['networkid'] = network_id

if vpc_id is not None:
            ip_args['vpcid'] = vpc_id

ip_args.update({'zoneid': location,
                        'networkid': network_id,
                        'vpc_id': vpc_id})

result = self._async_request(command='associateIpAddress',
                                     params=ip_args,
                                     method='GET')
        public_ip = result['ipaddress']

args.update({'algorithm': self._ALGORITHM_TO_VALUE_MAP[algorithm],
                     'name': name,
                     'privateport': private_port,
                     'publicport': port,
                     'publicipid': public_ip['id']})

result = self._sync_request(
            command='createLoadBalancerRule',
            params=args,
            method='GET')

listbalancers = self._sync_request(
            command='listLoadBalancerRules',
            params=args,
            method='GET')

listbalancers = [rule for rule in listbalancers['loadbalancerrule'] if
                         rule['id'] == result['id']]
        if len(listbalancers) != 1:
            return None

balancer = self._to_balancer(listbalancers[0])

for member in members:
            balancer.attach_member(member)

return balancer

def destroy_balancer(self, balancer):
        self._async_request(command='deleteLoadBalancerRule',
                            params={'id': balancer.id},

method='GET')
        self._async_request(command='disassociateIpAddress',
                            params={'id': balancer.ex_public_ip_id},
                            method='GET')

def balancer_attach_member(self, balancer, member):
        member.port = balancer.ex_private_port
        self._async_request(command='assignToLoadBalancerRule',
                            params={'id': balancer.id,
                                    'virtualmachineids': member.id},
                            method='GET')
        return True

def balancer_detach_member(self, balancer, member):
        self._async_request(command='removeFromLoadBalancerRule',
                            params={'id': balancer.id,
                                    'virtualmachineids': member.id},
                            method='GET')
        return True

def balancer_list_members(self, balancer):
        members = self._sync_request(command='listLoadBalancerRuleInstances',
                                     params={'id': balancer.id},
                                     method='GET')
        members = members['loadbalancerruleinstance']
        return [self._to_member(m, balancer.ex_private_port, balancer)
                for m in members]

def _to_balancer(self, obj):
        balancer = LoadBalancer(
            id=obj['id'],
            name=obj['name'],
            state=self.LB_STATE_MAP.get(obj['state'], State.UNKNOWN),
            ip=obj['publicip'],
            port=obj['publicport'],
            driver=self.connection.driver
        )
        balancer.ex_private_port = obj['privateport']
        balancer.ex_public_ip_id = obj['publicipid']
        return balancer

def _to_member(self, obj, port, balancer):
        return Member(
            id=obj['id'],
            ip=obj['nic'][0]['ipaddress'],
            port=port,
            balancer=balancer
        )

cmd: