def update_eip_runtime(self): eip_instance = self.get_eip() eip_id = eip_instance.runtime_properties[common_constants.EXTERNAL_ID] eip_instance.runtime_properties = {} request_body = {'AllocationId.1': eip_id} eip_info = Helper().execute_request('eip', 'describe_addresses', request_body)['AddressesSet'][0] eip_instance.runtime_properties[ common_constants.EXTERNAL_ID] = eip_info['AllocationId'] eip_instance.runtime_properties[ common_constants.EIP_ADDRESS] = eip_info['PublicIp'] eip_instance.runtime_properties[ common_constants.EIP_STATUS] = eip_info['State'] eip_instance.runtime_properties[ ksyun_constants.KS_EIP_TYPE] = eip_info.get('InstanceType') instance_id = eip_info.get('InstanceId') if instance_id and eip_info.get('InstanceType') == 'Ipfwd': vm_info = self.describe_vm(eip_info['InstanceId']) if vm_info: eip_instance.runtime_properties[ common_constants. EIP_RELATED_INSTANCE_ID] = eip_info['InstanceId'] eip_instance.runtime_properties[ common_constants.EIP_RELATED_INSTANCE_NAME] = vm_info.get( 'InstanceName') eip_instance.update()
def create(self): slb_id = self.get_related_slb() if not slb_id: raise NonRecoverableError( 'Unable to obtain load balancer ID, single node deployment is not supported!' ) listener_params = self.prepare_params(slb_id) ctx.logger.info( 'Attempting to create listeners parameters: {0}'.format( listener_params)) result = Helper().execute_request('slb', 'create_listeners', listener_params) listener_id = result.get('ListenerId') if not listener_id: raise NonRecoverableError('Listener create failed!') self.update_listener_runtime(listener_id) ctx.logger.info( 'Create listeners: {0} successfully'.format(listener_id)) health_check_params = self.get_health_check_params(listener_id) ctx.logger.info( 'Attempting to create health check parameters: {0}'.format( health_check_params)) res = Helper().execute_request('slb', 'configure_health_check', health_check_params) health_check_id = res.get('HealthCheckId') if health_check_id: self.update_listener_runtime(listener_id) ctx.logger.info( 'Create listeners: {0} and health check: {1} successfully.'. format(listener_id, health_check_id)) else: raise NonRecoverableError('Create health check failed!')
def describe_instance_cloud_volumes(self): instance_id = ctx.instance.runtime_properties['external_id'] cloud_volumes = Helper().execute_request('ebs', 'describe_instance_volumes', {"InstanceId": instance_id}) cloud_volumes = cloud_volumes.get('Attachments') or [] return cloud_volumes
def describe_instance_local_volumes(self): instance_id = ctx.instance.runtime_properties['external_id'] local_volumes = Helper().execute_request('kec', 'describe_local_volumes', {"InstanceId": instance_id}) local_volumes = local_volumes.get('LocalVolumeSet') or [] return local_volumes
def update_eip_runtime(eip_id): ctx.instance.runtime_properties = {} request_body = { 'AllocationId.1': eip_id } eip_obj = Helper().execute_request('eip', 'describe_addresses', request_body)['AddressesSet'] if not eip_obj: return eip_obj eip_obj = eip_obj[0] ctx.instance.runtime_properties[common_constants.EXTERNAL_ID] = eip_obj['AllocationId'] ctx.instance.runtime_properties[common_constants.EIP_ADDRESS] = eip_obj['PublicIp'] ctx.instance.runtime_properties[common_constants.EIP_STATUS] = eip_obj['State'] ctx.instance.runtime_properties[ksyun_constants.KS_EIP_TYPE] = eip_obj.get('InstanceType') instance_id = eip_obj.get('InstanceId') if instance_id and eip_obj.get('InstanceType') == 'Ipfwd': request_body = { 'InstanceId.1': eip_obj['InstanceId'] } instance_obj = Helper().execute_request('kec', 'describe_instances', request_body)['InstancesSet'][0] ctx.instance.runtime_properties[common_constants.EIP_RELATED_INSTANCE_ID] = eip_obj['InstanceId'] ctx.instance.runtime_properties[common_constants.EIP_RELATED_INSTANCE_NAME] = instance_obj.get( 'InstanceName')
def delete(self): listener_id = ctx.instance.runtime_properties.get( constants.EXTERNAL_ID) if not listener_id: ctx.logger.info('The listener was not created successfully') return request_body = {'ListenerId': listener_id} result = Helper().execute_request('slb', 'delete_listeners', request_body) if result.get('Return'): ctx.instance.runtime_properties = {} ctx.instance.update() ctx.logger.info( 'Delete listeners: {0} successfully.'.format(listener_id)) else: raise NonRecoverableError( 'Delete listeners: {0} failed.'.format(listener_id))
def update_listener_runtime(listener_id): request_body = {'ListenerId.1': listener_id} result = Helper().execute_request('slb', 'describe_listeners', request_body) listeners_obj = result.get('ListenerSet') if listeners_obj: external_slb_id = listeners_obj[0].pop('LoadBalancerId') listener_obj = listeners_obj[0] ctx.instance.runtime_properties['external_id'] = listener_obj.get( 'ListenerId') ctx.instance.runtime_properties[ 'external_name'] = listener_obj.get('ListenerName') ctx.instance.runtime_properties['status'] = listener_obj.get( 'ListenerState') ctx.instance.runtime_properties[ 'external_slb_id'] = external_slb_id ctx.instance.runtime_properties.update(listener_obj) ctx.instance.update() else: ctx.logger.info('Listeners does not exist!')
def create(self): ''' There will be two situations: 1.EIP is to be created with no relationship 2.EIP is to be created with instance and should be associate with instance ''' if not convert2bool(self.resource_config.get('allocate_eip', True)): return if self.use_external_resource: self._create_external_eip() return resource_config = ctx.node.properties['resource_config'] ctx.logger.info('Allocate Eip...resource_config:{}'.format(resource_config)) request_body = { 'BandWidth': validate_parameter('band_width', resource_config), 'ChargeType': resource_config.get('charge_type', 'HourlyInstantSettlement'), } line_id = resource_config.get('line_id', None) if line_id: request_body['LineId'] = line_id ctx.logger.info('Allocate Eip...request_body:{}'.format(request_body)) eip_obj = Helper().execute_request('eip', 'allocate_address', request_body) ctx.logger.info('Allocate Eip successfully....Eip info:{}'.format(eip_obj)) self.update_eip_runtime(eip_obj.get('AllocationId'))
def describe_vm(self, instance_id): res = Helper().execute_request('kec', 'describe_instances', {"InstanceId.1": instance_id}) return None if not res.get("InstancesSet") else res['InstancesSet'][0]