festival.edmaven.com:80

Linux b747.shapiroconsult.com 3.10.0-1160.119.1.vz7.224.4 #1 SMP Mon Sep 30 15:36:27 MSK 2024 x86_64
Apache
173.231.212.80

File Name : cloudstack.py

# 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
        )

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2025-01-07 04:51:40
..	dir	-	root/root	0755	2025-01-07 04:51:40
__pycache__	dir	-	root/root	0755	2025-01-07 04:51:40
__init__.py	text/plain	840 B	root/root	0644	2025-01-06 04:11:22
alb.py	text/x-python	36.57 KB	root/root	0644	2025-01-06 04:11:22
brightbox.py	text/x-python	4.72 KB	root/root	0644	2025-01-06 04:11:22
cloudstack.py	text/x-python	7.55 KB	root/root	0644	2025-01-06 04:11:22
dimensiondata.py	text/x-python	42.37 KB	root/root	0644	2025-01-06 04:11:22
elb.py	text/x-python	13.92 KB	root/root	0644	2025-01-06 04:11:22
gce.py	text/x-python	13.35 KB	root/root	0644	2025-01-06 04:11:22
gogrid.py	text/x-python	8.16 KB	root/root	0644	2025-01-06 04:11:22
ninefold.py	text/x-python	1.15 KB	root/root	0644	2025-01-06 04:11:22
nttcis.py	text/x-python	60.4 KB	root/root	0644	2025-01-06 04:11:22
rackspace.py	text/x-python	55.55 KB	root/root	0644	2025-01-06 04:11:22
slb.py	text/x-python	29.8 KB	root/root	0644	2025-01-06 04:11:22
softlayer.py	text/x-python	14.78 KB	root/root	0644	2025-01-06 04:11:22