Python ELBConnection.deregister_instances方法代码示例

# 需要导入模块: from boto.ec2.elb import ELBConnection [as 别名]
# 或者: from boto.ec2.elb.ELBConnection import deregister_instances [as 别名]
def _remove_instance_from_load_balancer(conn, instance, instance_info) :
    if 'load_balancer' in instance_info : 
        load_balancer_name = instance_info['load_balancer']
                
        elb_conn = ELBConnection()
        
        if _instance_in_load_balancer(elb_conn, load_balancer_name, instance.id) :
            print("Removing Instance(s) " + str([instance.id]) + " from load balancer " + load_balancer_name)
            elb_conn.deregister_instances(load_balancer_name, [instance.id])
        else :
            print("Instance(s) " + str([instance.id]) + " not associated with load balancer " + load_balancer_name + ", Nothing left to do")
        
    else :
        print("Skipping disassociation with Load Balancer ")

# 需要导入模块: from boto.ec2.elb import ELBConnection [as 别名]
# 或者: from boto.ec2.elb.ELBConnection import deregister_instances [as 别名]
def _add_instance_to_load_balancer(conn, instance, instance_info) :
    if 'load_balancer' in instance_info : 
        load_balancer_name = instance_info['load_balancer']
                
        elb_conn = ELBConnection()
        
        if _instance_in_load_balancer(elb_conn, load_balancer_name, instance.id) :
            print("Removing Instance(s) " + str([instance.id]) + " from load balancer " + load_balancer_name)
            elb_conn.deregister_instances(load_balancer_name, [instance.id])

        print("Adding Instance(s) " + str([instance.id]) + " to load balancer " + load_balancer_name)
        elb_conn.register_instances(load_balancer_name, [instance.id])
        
    else :
        print("Skipping association with Load Balancer ")

# 需要导入模块: from boto.ec2.elb import ELBConnection [as 别名]
# 或者: from boto.ec2.elb.ELBConnection import deregister_instances [as 别名]
class BotoBalanceInterface(BalanceInterface):
    conn = None
    saveclcdata = False

    def __init__(self, clc_host, access_id, secret_key, token):
        #boto.set_stream_logger('foo')
        path='/services/elb'
        port=8773
        if clc_host[len(clc_host)-13:] == 'amazonaws.com':
            clc_host = clc_host.replace('ec2', 'elasticloadbalancing', 1)
            path = '/'
            reg = None
            port=443
        reg = RegionInfo(name='eucalyptus', endpoint=clc_host)
        self.conn = ELBConnection(access_id, secret_key, region=reg,
                                  port=port, path=path,
                                  is_secure=True, security_token=token, debug=0)
        self.conn.https_validate_certificates = False
        self.conn.http_connection_kwargs['timeout'] = 30

    def __save_json__(self, obj, name):
        f = open(name, 'w')
        json.dump(obj, f, cls=BotoJsonBalanceEncoder, indent=2)
        f.close()

    def create_load_balancer(self, name, zones, listeners, subnets=None,
                             security_groups=None, scheme='internet-facing'):
        return self.conn.create_load_balancer(name, zones, listeners, subnets, security_groups, scheme)
    
    def delete_load_balancer(self, name):
        return self.conn.delete_load_balancer(name)

    def get_all_load_balancers(self, load_balancer_names=None):
        return []
        obj = self.conn.get_all_load_balancers(load_balancer_names)
        if self.saveclcdata:
            self.__save_json__(obj, "mockdata/ELB_Balancers.json")
        return obj

    def deregister_instances(self, load_balancer_name, instances):
        return self.conn.deregister_instances(load_balancer_name, instances)

    def register_instances(self, load_balancer_name, instances):
        return self.conn.register_instances(load_balancer_name, instances)

    def create_load_balancer_listeners(self, name, listeners):
        return self.conn.create_load_balancer_listeners(name, listeners)

    def delete_load_balancer_listeners(self, name, ports):
        return self.conn.delete_load_balancer_listeners(name, ports)

    def configure_health_check(self, name, health_check):
        return self.conn.configure_health_check(name, health_check)

    def describe_instance_health(self, load_balancer_name, instances=None):
        obj = self.conn.describe_instance_health(load_balancer_name, instances)
        if self.saveclcdata:
            self.__save_json__(obj, "mockdata/ELB_Instances.json")
        return obj

# 需要导入模块: from boto.ec2.elb import ELBConnection [as 别名]
# 或者: from boto.ec2.elb.ELBConnection import deregister_instances [as 别名]
class BotoBalanceInterface(BalanceInterface):
    conn = None
    saveclcdata = False

    def __init__(self, clc_host, access_id, secret_key, token):
        self.access_id = access_id
        self.secret_key = secret_key
        self.token = token
        self.set_endpoint(clc_host)

    def set_endpoint(self, endpoint):
        #boto.set_stream_logger('foo')
        reg = RegionInfo(name='eucalyptus', endpoint=endpoint)
        path = '/services/LoadBalancing'
        port = 8773
        if endpoint[len(endpoint)-13:] == 'amazonaws.com':
            endpoint = endpoint.replace('ec2', 'elasticloadbalancing', 1)
            path = '/'
            reg = RegionInfo(endpoint=endpoint)
            port = 443
        self.conn = ELBConnection(self.access_id, self.secret_key, region=reg,
                                  port=port, path=path,
                                  is_secure=True, security_token=self.token, debug=0)
        self.conn.https_validate_certificates = False
        self.conn.http_connection_kwargs['timeout'] = 30

    def __save_json__(self, obj, name):
        f = open(name, 'w')
        json.dump(obj, f, cls=BotoJsonBalanceEncoder, indent=2)
        f.close()

    def create_load_balancer(self, name, zones, listeners, subnets=None,
                             security_groups=None, scheme='internet-facing'):
        return self.conn.create_load_balancer(name, zones, listeners, subnets, security_groups, scheme)

    def delete_load_balancer(self, name):
        return self.conn.delete_load_balancer(name)

    def get_all_load_balancers(self, load_balancer_names=None):
        params = {}
        if load_balancer_names:
            self.build_list_params(params, load_balancer_names,
                                   'LoadBalancerNames.member.%d')
        http_request = self.conn.build_base_http_request('GET', '/', None,
                                                         params, {}, '',
                                                         self.conn.server_name())
        http_request.params['Action'] = 'DescribeLoadBalancers'
        http_request.params['Version'] = self.conn.APIVersion
        response = self.conn._mexe(http_request, override_num_retries=2)
        body = response.read()
        boto.log.debug(body)
        if not body:
            boto.log.error('Null body %s' % body)
            raise self.conn.ResponseError(response.status, response.reason, body)
        elif response.status == 200:
            obj = boto.resultset.ResultSet([('member', boto.ec2.elb.loadbalancer.LoadBalancer)])
            h = boto.handler.XmlHandler(obj, self.conn)
            import xml.sax;

            xml.sax.parseString(body, h)
            if self.saveclcdata:
                self.__save_json__(obj, "mockdata/ELB_Balancers.json")
            return obj
        else:
            boto.log.error('%s %s' % (response.status, response.reason))
            boto.log.error('%s' % body)
            raise self.conn.ResponseError(response.status, response.reason, body)


    def deregister_instances(self, load_balancer_name, instances):
        return self.conn.deregister_instances(load_balancer_name, instances)

    def register_instances(self, load_balancer_name, instances):
        return self.conn.register_instances(load_balancer_name, instances)

    def create_load_balancer_listeners(self, name, listeners):
        return self.conn.create_load_balancer_listeners(name, listeners)

    def delete_load_balancer_listeners(self, name, ports):
        return self.conn.delete_load_balancer_listeners(name, ports)

    def configure_health_check(self, name, health_check):
        return self.conn.configure_health_check(name, health_check)

    def describe_instance_health(self, load_balancer_name, instances=None):
        obj = self.conn.describe_instance_health(load_balancer_name, instances)
        if self.saveclcdata:
            self.__save_json__(obj, "mockdata/ELB_Instances.json")
        return obj

# 需要导入模块: from boto.ec2.elb import ELBConnection [as 别名]
# 或者: from boto.ec2.elb.ELBConnection import deregister_instances [as 别名]
class LoadBalancer(BaseLoadBalancer):
    """The classic load balancer for ELB.

    This is used to interface with the classic Elastic Load Balancer, which
    can be used in VPC or in EC2-Classic.
    """

    def __init__(self, name):
        """Initialize the instance.

        Args:
            name (unicode):
                The name of the load balancer.
        """
        self.name = name
        self._cnx = ELBConnection()

    def register_instance(self, instance):
        """Register an instance on the load balancer.

        Args:
            instance (fabazon.ec2.EC2Instance):
                The instance to register.
        """
        self._cnx.register_instances(self.name, [instance.id])

    def unregister_instance(self, instance):
        """Unregister an instance from the load balancer.

        Args:
            instance (fabazon.ec2.EC2Instance):
                The instance to unregister.
        """
        self._cnx.deregister_instances(self.name, [instance.id])

    def is_instance_registered(self, instance):
        """Return whether an instance is registered.

        Args:
            instance (fabazon.ec2.EC2Instance):
                The instance to check.

        Returns:
            bool:
            ``True`` if the instance is registered on the load balancer.
            ``False`` if it's not registered.
        """
        health_info = self._get_instance_health_info(instance)

        return (health_info.description ==
                'Instance is not currently registered with the LoadBalancer.')

    def is_instance_healthy(self, instance):
        """Return whether an instance is healthy.

        Args:
            instance (fabazon.ec2.EC2Instance):
                The instance to check.

        Returns:
            bool:
            ``True`` if the instance is healthy.
            ``False`` if it's not healthy.
        """
        health_info = self._get_instance_health_info(instance)

        return health_info.state == 'InService'

    def _get_instance_health_info(self, instance):
        """Return health information for an instance.

        Args:
            instance (fabazon.ec2.EC2Instance):
                The instance to check.

        Returns:
            dict:
            Information on the instance's health.
        """
        health_info = self._cnx.describe_instance_health(self.name,
                                                         [instance.id])

        assert len(health_info) == 1
        assert health_info[0].instance_id == instance.id

        return health_info[0]