def connect(logger, cloud_provider_resource, set_vlan_action): """ :param logging.Logger logger: :param L2HeavenlyCloudShell cloud_provider_resource: :param SetVlan set_vlan_action: :return: :rtype: SetVlanResult """ try: vnic_name = '' if not 'Vnic Name' in set_vlan_action.customActionAttributes else \ set_vlan_action.customActionAttributes['Vnic Name'] vm_id = set_vlan_action.customActionAttributes['VM_UUID'] vlan_mode = set_vlan_action.connectionParams.mode #access or trunk vlan_id = set_vlan_action.connectionParams.vlanId interface_id = HeavenlyCloudService.connect_vlan( cloud_provider_resource, vm_id, vlan_id, vlan_mode, vnic_name) return SetVlanResult(actionId=set_vlan_action.actionId, success=True, infoMessage='vnic name: {0}, ' 'vlan mode: {1}, ' 'interface id: {2}, ' 'vlan id: {3}'.format(vnic_name, vlan_mode, interface_id, vlan_id), updatedInterface=interface_id) except Exception as e: return SetVlanResult(actionId=set_vlan_action.actionId, success=False, errorMessage=traceback.format_exc())
def remote_refresh_ip(cloud_provider_resource, cancellation_context, cloudshell_session, resource_full_name, vm_id, deployed_app_private_ip, deployed_app_public_ip): """ :param L2HeavenlyCloudShell cloud_provider_resource: :param CancellationContext cancellation_context: :param CloudShellAPISession cloudshell_session: :param str resource_full_name: :param str vm_id: :param str deployed_app_private_ip: :param str deployed_app_public_ip: """ check_cancellation_context(cancellation_context) vm_instance = HeavenlyCloudService.get_instance_full( cloud_provider_resource, resource_full_name, vm_id) if deployed_app_private_ip != vm_instance.private_ip: cloudshell_session.UpdateResourceAddress(resource_full_name, vm_instance.private_ip) if not deployed_app_public_ip or deployed_app_public_ip != vm_instance.public_ip: cloudshell_session.SetAttributeValue(resource_full_name, "Public IP", vm_instance.public_ip) check_cancellation_context_and_do_rollback(cancellation_context)
def disconnect(cloud_provider_resource, remove_vlan_action): """ :param L2HeavenlyCloudShell cloud_provider_resource: :param RemoveVlan remove_vlan_action: :return: :rtype: RemoveVlanResult """ try: disconnect_interface_id = remove_vlan_action.connectorAttributes[ 'Interface'] vm_instance_id = remove_vlan_action.customActionAttributes[ 'VM_UUID'] HeavenlyCloudService.disconnect_vlan(cloud_provider_resource, disconnect_interface_id, vm_instance_id) return RemoveVlanResult(actionId=remove_vlan_action.actionId, success=True) except Exception as e: return RemoveVlanResult(actionId=remove_vlan_action.actionId, success=False, errorMessage=traceback.format_exc())
def get_vm_details(logger, cloud_provider_resource, cancellation_context, requests_json): """ :param logging.Logger logger: :param L2HeavenlyCloudShell cloud_provider_resource: :param CancellationContext cancellation_context: :param str requests_json: :param str vm_id: """ check_cancellation_context(cancellation_context) requests = json.loads(requests_json) results = [] for request in requests[u'items']: if cancellation_context.is_cancelled: break vm_name = request[u'deployedAppJson'][u'name'] vm_uid = request[u'deployedAppJson'][u'vmdetails'][u'uid'] address = request[u'deployedAppJson'][u'address'] vm_instance = HeavenlyCloudService.get_instance( cloud_provider_resource, vm_name, vm_uid, address) vm_instance_data = HeavenlyCloudServiceWrapper.extract_vm_instance_data( vm_instance) vm_network_data = HeavenlyCloudServiceWrapper.extract_vm_instance_network_data( vm_instance) # example of reading custom data created via deployed_app_additional_data_dict at delpoy stage # created_by = next((deployed_app_additional_data['value'] for deployed_app_additional_data in request[u'deployedAppJson'][u'vmdetails'][u'vmCustomParams'] if # deployed_app_additional_data['name'] == 'CreatedBy'), None) # if created_by: # vm_instance_data.append(VmDetailsProperty(key='CreatedBy',value=created_by)) result = VmDetailsData(vmInstanceData=vm_instance_data, vmNetworkData=vm_network_data, appName=vm_name) results.append(result) check_cancellation_context(cancellation_context) return results
def prepare_sandbox_infra(logger, cloud_provider_resource, prepare_infa_action, create_keys_action, prepare_subnet_actions, cancellation_context): """ :param logging.Logger logger: :param L3HeavenlyCloudShell cloud_provider_resource: :param PrepareCloudInfra prepare_infa_action: :param CreateKeys create_keys_action: :param List[PrepareSubnet] prepare_subnet_actions: :param CancellationContext cancellation_context: :return: :rtype: """ results = [] check_cancellation_context_and_do_rollback(cancellation_context) cidr = prepare_infa_action.actionParams.cidr try: # handle PrepareInfraAction - extract sandbox CIDR and create/allocate a network in the cloud provider with # an address range of the provided CIDR logger.info("Received CIDR {0} from server".format(cidr)) HeavenlyCloudService.prepare_infra(cloud_provider_resource, cidr) results.append( PrepareCloudInfraResult(prepare_infa_action.actionId)) except: logger.error(traceback.format_exc()) results.append( PrepareCloudInfraResult(prepare_infa_action.actionId, success=False, errorMessage=traceback.format_exc())) check_cancellation_context_and_do_rollback(cancellation_context) try: # handle CreateKeys - generate key pair or get it from the cloud provider and save it in a secure location # that will be accessible from the Deploy method sandbx_ssh_key = HeavenlyCloudService.get_or_create_ssh_key() results.append( CreateKeysActionResult(create_keys_action.actionId, accessKey=sandbx_ssh_key)) except: logger.error(traceback.format_exc()) results.append( CreateKeysActionResult(create_keys_action.actionId, success=False, errorMessage=traceback.format_exc())) check_cancellation_context_and_do_rollback(cancellation_context) # handle PrepareSubnetsAction for action in prepare_subnet_actions: try: subnet_id = HeavenlyCloudService.prepare_subnet( action.actionParams.cidr, action.actionParams.isPublic, action.actionParams.subnetServiceAttributes) results.append( PrepareSubnetActionResult(action.actionId, subnet_id=subnet_id)) except: logger.error(traceback.format_exc()) results.append( PrepareSubnetActionResult( action.actionId, success=False, errorMessage=traceback.format_exc())) check_cancellation_context_and_do_rollback(cancellation_context) return results
def delete_instance(cloud_provider_resource, vm_id): HeavenlyCloudService.delete_instance(cloud_provider_resource, vm_id)
def deploy_angel(context, cloudshell_session, cloud_provider_resource, deploy_app_action, connect_subnet_actions, cancellation_context): check_cancellation_context(cancellation_context) # deployment_model type : HeavenlyCloudAngelDeploymentModel deployment_model = deploy_app_action.actionParams.deployment.customModel # generate unique name to avoid name collisions vm_unique_name = deploy_app_action.actionParams.appName + '__' + str( uuid.uuid4())[:6] input_user = deploy_app_action.actionParams.appResource.attributes[ 'User'] encrypted_pass = deploy_app_action.actionParams.appResource.attributes[ 'Password'] decrypted_input_password = cloudshell_session.DecryptPassword( encrypted_pass).Value deployed_app_attributes = [] if not decrypted_input_password: decrypted_input_password = HeavenlyCloudService.create_new_password( cloud_provider_resource, input_user, decrypted_input_password) # optional # deployedAppAttributes contains the attributes on the deployed app # use to override attributes default values deployed_app_attributes.append( Attribute('Password', decrypted_input_password)) # convert the ConnectSubnet actions to networking metadata for cloud provider SDK network_data = HeavenlyCloudService.prepare_network_for_instance( connect_subnet_actions) try: # using cloud provider SDK, creating the instance vm_instance = HeavenlyCloudService.create_angel_instance( input_user, decrypted_input_password, cloud_provider_resource, vm_unique_name, deployment_model.wing_count, deployment_model.flight_speed, deployment_model.cloud_size, deployment_model.cloud_image_id, network_data) except Exception as e: return DeployAppResult(actionId=deploy_app_action.actionId, success=False, errorMessage=e.message) # Creating VmDetailsData vm_details_data = HeavenlyCloudServiceWrapper.extract_vm_details( vm_instance) # result must include the action id it results for, so server can match result to action action_id = deploy_app_action.actionId # optional # deployedAppAdditionalData can contain dynamic data on the deployed app # similar to AWS tags deployed_app_additional_data_dict = { 'Reservation Id': context.reservation.reservation_id, 'CreatedBy': str(os.path.abspath(__file__)) } deploy_result = DeployAppResult( actionId=action_id, success=True, vmUuid=vm_instance.id, vmName=vm_unique_name, deployedAppAddress=vm_instance.private_ip, deployedAppAttributes=deployed_app_attributes, deployedAppAdditionalData=deployed_app_additional_data_dict, vmDetailsData=vm_details_data) connect_subnet_results = [] for connect_subnet_action in connect_subnet_actions: connect_subnet_results.append( ConnectToSubnetActionResult( connect_subnet_action.actionId, interface=network_data[ connect_subnet_action.actionParams.subnetId])) check_cancellation_context_and_do_rollback(cancellation_context) return [deploy_result] + connect_subnet_results
def power_off(cloud_provider_resource, vm_id): """ :param L2HeavenlyCloudShell cloud_provider_resource: :param str vm_id: """ HeavenlyCloudService.power_off(cloud_provider_resource, vm_id)
def deploy_man(context, cloudshell_session, cloud_provider_resource, deploy_app_action, cancellation_context): """ :param ResourceCommandContext context: :param CloudShellAPISession cloudshell_session: :param L2HeavenlyCloudShell cloud_provider_resource: :param DeployApp deploy_app_action: :param CancellationContext cancellation_context: """ check_cancellation_context(cancellation_context) # deployment_model type : HeavenlyCloudAngelDeploymentModel deployment_model = deploy_app_action.actionParams.deployment.customModel # generate unique name to avoid name collisions vm_unique_name = deploy_app_action.actionParams.appName + '__' + str( uuid.uuid4())[:6] input_user = deploy_app_action.actionParams.appResource.attributes[ 'User'] encrypted_pass = deploy_app_action.actionParams.appResource.attributes[ 'Password'] decrypted_input_password = cloudshell_session.DecryptPassword( encrypted_pass).Value deployed_app_attributes = [] if not decrypted_input_password: decrypted_input_password = HeavenlyCloudService.create_new_password( cloud_provider_resource, input_user, decrypted_input_password) # optional # deployedAppAttributes contains the attributes on the deployed app # use to override attributes default values deployed_app_attributes.append( Attribute('Password', decrypted_input_password)) try: # using cloud provider SDK, creating the instance vm_instance = HeavenlyCloudService.create_man_instance( input_user, decrypted_input_password, cloud_provider_resource, vm_unique_name, deployment_model.weight, deployment_model.height, deployment_model.cloud_size, deployment_model.cloud_image_id) except Exception as e: return DeployAppResult(actionId=deploy_app_action.actionId, success=False, errorMessage=traceback.format_exc()) # Creating VmDetailsData vm_details_data = HeavenlyCloudServiceWrapper.extract_vm_details( vm_instance) # result must include the action id it results for, so server can match result to action action_id = deploy_app_action.actionId # optional # deployedAppAdditionalData can contain dynamic data on the deployed app # similar to AWS tags deployed_app_additional_data_dict = { 'Reservation Id': context.reservation.reservation_id, 'CreatedBy': str(os.path.abspath(__file__)) } check_cancellation_context_and_do_rollback(cancellation_context) return DeployAppResult( actionId=action_id, success=True, vmUuid=vm_instance.id, vmName=vm_unique_name, deployedAppAddress=vm_instance.private_ip, deployedAppAttributes=deployed_app_attributes, deployedAppAdditionalData=deployed_app_additional_data_dict, vmDetailsData=vm_details_data)