def image_disk(auth_client, server_uuid, default_user, diskIndex): # Details of the server print("Details for the server we will Image:") print("============================") server_resultset = list_resource_by_uuid(auth_client, server_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): server = server_resultset['list'][l] #baseUUID = server['resourceUUID'] clusterUUID = server['clusterUUID'] vdcUUID = server['vdcUUID'] # Image should be same size as the source disk disk = server['disks'][diskIndex] size = disk['size'] baseUUID = disk['resourceUUID'] print("Create Image input:") response = rest_create_image(auth_client, baseUUID, clusterUUID, vdcUUID, size, default_user) print("=============================") print response print("Details for newly created image:") createdImage = list_resource_by_uuid(auth_client, response['itemUUID'],"IMAGE") for l in range(0, createdImage['totalCount']): image = createdImage['list'][l] print image sys.stdout.flush() return image
def _detach_disk(self, node_instance): """Detach disk from the VM. :param node_instance: node instance object :type node_instance: <NodeInstance> """ print 'Scaling down in progress for NODE INSTANCE name: %s' %node_instance.get_name() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) vm_uuid = vm['id'] print 'Stopping the VM: %s to detach disk' %vm # Stop the VM before detaching the disk try: ret = StopVM( vm_uuid, self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_username(), self.user_info.get_cloud_password(), self.user_info.get_cloud_endpoint(), self.verbose) except Exception as ex: raise CloudError('Failed to stop VM %s with: %s' % (vm_uuid, str(ex))) endpoint = self.user_info.get_cloud_endpoint() token = getToken(self.user_info.get_cloud_endpoint(), self.user_info.get_cloud_username(), self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_password()) auth = dict(endpoint=endpoint, token=token) server_resultset = list_resource_by_uuid(auth, vm_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): server = server_resultset['list'][l] disks = server['disks'] # Get the UUID of the disk to be detached detach_diskUUID = node_instance.get_disk_detach_device() print '\n\n\n' print 'detach_diskUUID passed = %s' %detach_diskUUID found = False for disk in disks: if(disk['resourceUUID'] == detach_diskUUID): print 'Disk found on the server' found = True if (found == False): raise Exceptions.ExecutionException("Disk not found on the server %s" %vm_uuid) print 'Detaching the additional volatile disk' # Detach it now if (detach_diskUUID != ""): detach_disk(auth, vm_uuid, detach_diskUUID) # Delete the resource rest_delete_resource(auth, detach_diskUUID, "DISK") print 'Restart the VM' server_data=[vm_uuid] start_server(auth, server_data) print("Waiting for the server to get in RUNNING state") ret = wait_for_server(auth, vm_uuid, 'RUNNING') if (ret != 0): raise Exceptions.ExecutionException("Server is not in RUNNING state")
def start_server(auth_parms, server_data): """Function to start server, uuid in server_data""" server_uuid = server_data[0] server_state = get_server_state(auth_parms, server_uuid) if server_state == 'STOPPED': rc = change_server_status(auth_parms=auth_parms, server_uuid=server_uuid, state='RUNNING') # change_server_status() waits on the server getting to the requested state, so we don't # need to call wait_for_server() here. However, we do (1) need to check the status and (2) # wait on the server actually being accessible (as opposed to having a RUNNING state in # FCO, which really just means that the underlying kvm process has started). # # 1. Check rc (0 is good) if (rc != 0): raise Exceptions.ExecutionException("Failed to put server " + server_uuid + " in to running state") server_resultset = list_resource_by_uuid(auth_parms, uuid=server_uuid, res_type='SERVER') print("Server result set is:") print server_resultset server_ip = server_resultset['list'][0]['nics'][0]['ipAddresses'][0]['ipAddress'] # yuk print("server IP=" + server_ip) # Step 2. Wait on it being accessible. It is possible that the server doesn't have ssh installed, # or it is firewalled, so don't fail here if we can't connect, just carry on and let # the caller deal with any potential issue. The alternative is a hard-coded sleep, or # trying a ping (platform specific and/or root privs needed). is_ssh_port_open(server_ip, 30) server_data.append(server_ip) return server_data
def ListVM(server_uuid, customerUUID, customerUsername, customerPassword, endpoint, isVerbose=False): # Actually just defines the global variables now (since all config bits are passed on the command line) config.get_config("") config.CUST_UUID = customerUUID config.USER_LOGIN = customerUsername config.USER_PASSWORD = customerPassword config.HOST_NAME = endpoint # config.NETWORK_TYPE = networkType auth_client = setup_test() server_resultset = list_resource_by_uuid(auth_client, server_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): server = server_resultset['list'][l] return server
def start_server(auth_parms, server_data): """Function to start server, uuid in server_data""" server_uuid = server_data[0] server_state = get_server_state(auth_parms, server_uuid) if server_state == 'STOPPED': rc = change_server_status(auth_parms=auth_parms, server_uuid=server_uuid, state='RUNNING') # change_server_status() waits on the server getting to the requested state, so we don't # need to call wait_for_server() here. However, we do (1) need to check the status and (2) # wait on the server actually being accessible (as opposed to having a RUNNING state in # FCO, which really just means that the underlying kvm process has started). # # 1. Check rc (0 is good) if (rc != 0): raise Exceptions.ExecutionException("Failed to put server " + server_uuid + " in to running state") server_resultset = list_resource_by_uuid(auth_parms, uuid=server_uuid, res_type='SERVER') print("Server result set is:") print server_resultset server_ip = server_resultset['list'][0]['nics'][0]['ipAddresses'][0][ 'ipAddress'] # yuk print("server IP=" + server_ip) # Step 2. Wait on it being accessible. It is possible that the server doesn't have ssh installed, # or it is firewalled, so don't fail here if we can't connect, just carry on and let # the caller deal with any potential issue. The alternative is a hard-coded sleep, or # trying a ping (platform specific and/or root privs needed). is_ssh_port_open(server_ip, 30) server_data.append(server_ip) return server_data
def build_server(auth_parms, customer_uuid, image_uuid, vdc_uuid, server_po_uuid, boot_disk_po_uuid, server_name, ram_amount, cpu_count, networkType, cluster_uuid, public_key, context_script): """Function to create a server""" print "FCOMakeOrchestrator.py:build_server args:" print "customer_uuid: " + customer_uuid print "image_uuid: " + image_uuid print "cluster_uuid: " + cluster_uuid print "vdc_uuid: " + vdc_uuid print "server_po_uuid: " + server_po_uuid print "boot_disk_po_uuid:" + boot_disk_po_uuid, print "server_name: " + server_name print "ram_amount: " + ram_amount print "cpu_count: " + str(cpu_count) print "public_key: " + public_key print "context_script: " + context_script print "=== end FCOMakeOrchestrator.py:build_server args ===" create_server_job = rest_create_server(auth_parms, server_name, server_po_uuid, image_uuid, cluster_uuid, vdc_uuid, cpu_count, ram_amount, boot_disk_po_uuid, context_script) # print create_server_jobid server_uuid = create_server_job['itemUUID'] print "--- createServer done with UUID " + server_uuid + " -----" print("public_key = " + public_key) # # The public_key arg might be a list of public keys, separated by cr/lf. So split # the list and process each key individually for single_key in public_key.splitlines(): print("Processing key: " + single_key) add_ret = AddKey(auth_parms, server_uuid, customer_uuid, single_key) print("== AddKey Result ==") print add_ret print("====") wait_for_install(auth_parms, server_uuid=server_uuid) # Add NIC to server print "Calling create_nic for network " + networkType nic_uuid = create_nic(auth_parms=auth_parms, nic_count='0', network_type=networkType, cluster_uuid=cluster_uuid, vdc_uuid=vdc_uuid) print "create_nic returned nic_uuid: " + nic_uuid wait_for_resource(auth_parms=auth_parms, res_uuid=nic_uuid, state='ACTIVE', res_type='nic') print "nic uuid: " + nic_uuid add_nic_response = add_nic_to_server(auth_parms=auth_parms, server_uuid=server_uuid, nic_uuid=nic_uuid, index='1') # Wait on the addNic job completing status = wait_for_job(auth_parms, add_nic_response['resourceUUID'], "SUCCESSFUL", 90) if (status != 0): raise Exceptions.ExecutionException("Failed to add NIC to server") # Lookup server properties to get UUID, and password, that have been assigned to it server_resultset = list_resource_by_uuid(auth_parms, uuid=server_uuid, res_type='SERVER') server = server_resultset['list'][0] # print server_resultset server_uuid = server['resourceUUID'] server_pw = server['initialPassword'] server_user = server['initialUser'] # server_ip = server_resultset.list[0].nics[0].ipAddresses[0].ipAddress server_data = [server_uuid, server_pw, server_user] return server_data
def _resize(self, node_instance): """ :param node_instance: node instance object :type node_instance: <NodeInstance> """ print 'Node instance name: %s' %node_instance.get_name() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) vm_uuid = vm['id'] # Get the Product Offer UUID of the Standard Server product product_offer = 'Standard Server' endpoint = self.user_info.get_cloud_endpoint() token = getToken(self.user_info.get_cloud_endpoint(), self.user_info.get_cloud_username(), self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_password()) auth = dict(endpoint=endpoint, token=token) server_resultset = list_resource_by_uuid(auth, vm_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): server = server_resultset['list'][l] vdc_uuid = server['vdcUUID'] ram = 0 cpu = 0 # get the RAM in GB. ram = node_instance.get_ram() # get the Number of CPUs. cpu = node_instance.get_cpu() print '\n\n\n' print 'CPU = ', cpu print 'RAM = ', ram # Validate the size of the CPU and the RAM input validate_ram_cpu_size(auth, product_offer, cpu, ram) print 'Resizing in progress' print 'Stopping the VM: %s to resize CPU/RAM' %vm # Stop the VM before attaching the disk try: ret = StopVM( vm_uuid, self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_username(), self.user_info.get_cloud_password(), self.user_info.get_cloud_endpoint(), self.verbose) except Exception as ex: raise CloudError('Failed to stop VM %s with: %s' % (vm_uuid, str(ex))) clusterUUID = server['clusterUUID'] vdcUUID = server['vdcUUID'] disks = server['disks'] serverName = server['resourceName'] # Resize the server resize_cpu_ram(auth, vm_uuid, serverName, clusterUUID, vdcUUID, cpu, ram) # Restart the VM and wait till it gets in RUNNING state print 'Restart the VM' server_data = [vm_uuid] start_server(auth, server_data) print("Waiting for the server to get in RUNNING state") ret = wait_for_server(auth, vm_uuid, 'RUNNING') if (ret != 0): raise Exceptions.ExecutionException("Server is not in RUNNING state")
def _attach_disk(self, node_instance): """Attach extra disk to the VM. :param node_instance: node instance object :type node_instance: <NodeInstance> :return: name of the device that was attached :rtype: string """ print 'Scaling in progress' current_time = time.strftime("%Y-%m-%d %H:%M:%S") disk_device_name = "Disk " + current_time + " #2" print 'Node instance name: %s' %node_instance.get_name() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) vm_uuid = vm['id'] endpoint = self.user_info.get_cloud_endpoint() token = getToken(self.user_info.get_cloud_endpoint(), self.user_info.get_cloud_username(), self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_password()) auth = dict(endpoint=endpoint, token=token) # Size of the disk to attach (in GB). disk_size_GB = int(node_instance.get_disk_attach_size()) print '\n\n\n' print 'disk_size = ',disk_size_GB server_resultset = list_resource_by_uuid(auth, vm_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): vdc = server_resultset['list'][l] vdc_uuid = vdc['vdcUUID'] # Validate the size of the disk to be attached validate_disk_size(auth, 'Standard Disk', disk_size_GB, disk_device_name, vdc_uuid) print 'Stopping the VM: %s to attach disk' %vm # Stop the VM before attaching the disk try: ret = StopVM( vm_uuid, self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_username(), self.user_info.get_cloud_password(), self.user_info.get_cloud_endpoint(), self.verbose) except Exception as ex: raise CloudError('Failed to stop VM %s with: %s' % (vm_uuid, str(ex))) disk_uuid = "" if (int(disk_size_GB) > 0): print('Creating additional volatile disk') # Create the disk disk_uuid = create_disk(auth, 'Standard Disk', disk_size_GB, disk_device_name, vdc_uuid) print 'Attaching the additional volatile disk' # If we created an extra disk, attach it now if (disk_uuid != ""): attach_disk(auth, vm_uuid, disk_uuid=disk_uuid, index='2') print 'Restart the VM' server_data=[vm_uuid] start_server(auth, server_data) print("Waiting for the server to get in RUNNING state") ret = wait_for_server(auth, vm_uuid, 'RUNNING') if (ret != 0): raise Exceptions.ExecutionException("Server is not in RUNNING state") # Return the created disk's uuid return disk_uuid
def _resize(self, node_instance): """ :param node_instance: node instance object :type node_instance: <NodeInstance> """ print 'Node instance name: %s' % node_instance.get_name() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) vm_uuid = vm['id'] # Get the Product Offer UUID of the Standard Server product product_offer = 'Standard Server' endpoint = self.user_info.get_cloud_endpoint() token = getToken(self.user_info.get_cloud_endpoint(), self.user_info.get_cloud_username(), self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_password()) auth = dict(endpoint=endpoint, token=token) server_resultset = list_resource_by_uuid(auth, vm_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): server = server_resultset['list'][l] vdc_uuid = server['vdcUUID'] ram = 0 cpu = 0 # get the RAM in GB. ram = node_instance.get_ram() # get the Number of CPUs. cpu = node_instance.get_cpu() print '\n\n\n' print 'CPU = ', cpu print 'RAM = ', ram # Validate the size of the CPU and the RAM input validate_ram_cpu_size(auth, product_offer, cpu, ram) print 'Resizing in progress' print 'Stopping the VM: %s to resize CPU/RAM' % vm # Stop the VM before attaching the disk try: ret = StopVM(vm_uuid, self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_username(), self.user_info.get_cloud_password(), self.user_info.get_cloud_endpoint(), self.verbose) except Exception as ex: raise CloudError('Failed to stop VM %s with: %s' % (vm_uuid, str(ex))) clusterUUID = server['clusterUUID'] vdcUUID = server['vdcUUID'] disks = server['disks'] serverName = server['resourceName'] # Resize the server resize_cpu_ram(auth, vm_uuid, serverName, clusterUUID, vdcUUID, cpu, ram) # Restart the VM and wait till it gets in RUNNING state print 'Restart the VM' server_data = [vm_uuid] start_server(auth, server_data) print("Waiting for the server to get in RUNNING state") ret = wait_for_server(auth, vm_uuid, 'RUNNING') if (ret != 0): raise Exceptions.ExecutionException( "Server is not in RUNNING state")
def _detach_disk(self, node_instance): """Detach disk from the VM. :param node_instance: node instance object :type node_instance: <NodeInstance> """ print 'Scaling down in progress for NODE INSTANCE name: %s' % node_instance.get_name( ) machine_name = node_instance.get_name() vm = self._get_vm(machine_name) vm_uuid = vm['id'] print 'Stopping the VM: %s to detach disk' % vm # Stop the VM before detaching the disk try: ret = StopVM(vm_uuid, self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_username(), self.user_info.get_cloud_password(), self.user_info.get_cloud_endpoint(), self.verbose) except Exception as ex: raise CloudError('Failed to stop VM %s with: %s' % (vm_uuid, str(ex))) endpoint = self.user_info.get_cloud_endpoint() token = getToken(self.user_info.get_cloud_endpoint(), self.user_info.get_cloud_username(), self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_password()) auth = dict(endpoint=endpoint, token=token) server_resultset = list_resource_by_uuid(auth, vm_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): server = server_resultset['list'][l] disks = server['disks'] # Get the UUID of the disk to be detached detach_diskUUID = node_instance.get_disk_detach_device() print '\n\n\n' print 'detach_diskUUID passed = %s' % detach_diskUUID found = False for disk in disks: if (disk['resourceUUID'] == detach_diskUUID): print 'Disk found on the server' found = True if (found == False): raise Exceptions.ExecutionException( "Disk not found on the server %s" % vm_uuid) print 'Detaching the additional volatile disk' # Detach it now if (detach_diskUUID != ""): detach_disk(auth, vm_uuid, detach_diskUUID) # Delete the resource rest_delete_resource(auth, detach_diskUUID, "DISK") print 'Restart the VM' server_data = [vm_uuid] start_server(auth, server_data) print("Waiting for the server to get in RUNNING state") ret = wait_for_server(auth, vm_uuid, 'RUNNING') if (ret != 0): raise Exceptions.ExecutionException( "Server is not in RUNNING state")
def _attach_disk(self, node_instance): """Attach extra disk to the VM. :param node_instance: node instance object :type node_instance: <NodeInstance> :return: name of the device that was attached :rtype: string """ print 'Scaling in progress' current_time = time.strftime("%Y-%m-%d %H:%M:%S") disk_device_name = "Disk " + current_time + " #2" print 'Node instance name: %s' % node_instance.get_name() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) vm_uuid = vm['id'] endpoint = self.user_info.get_cloud_endpoint() token = getToken(self.user_info.get_cloud_endpoint(), self.user_info.get_cloud_username(), self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_password()) auth = dict(endpoint=endpoint, token=token) # Size of the disk to attach (in GB). disk_size_GB = int(node_instance.get_disk_attach_size()) print '\n\n\n' print 'disk_size = ', disk_size_GB server_resultset = list_resource_by_uuid(auth, vm_uuid, res_type='SERVER') for l in range(0, server_resultset['totalCount']): vdc = server_resultset['list'][l] vdc_uuid = vdc['vdcUUID'] # Validate the size of the disk to be attached validate_disk_size(auth, 'Standard Disk', disk_size_GB, disk_device_name, vdc_uuid) print 'Stopping the VM: %s to attach disk' % vm # Stop the VM before attaching the disk try: ret = StopVM(vm_uuid, self.user_info.get_cloud('user.uuid'), self.user_info.get_cloud_username(), self.user_info.get_cloud_password(), self.user_info.get_cloud_endpoint(), self.verbose) except Exception as ex: raise CloudError('Failed to stop VM %s with: %s' % (vm_uuid, str(ex))) disk_uuid = "" if (int(disk_size_GB) > 0): print('Creating additional volatile disk') # Create the disk disk_uuid = create_disk(auth, 'Standard Disk', disk_size_GB, disk_device_name, vdc_uuid) print 'Attaching the additional volatile disk' # If we created an extra disk, attach it now if (disk_uuid != ""): attach_disk(auth, vm_uuid, disk_uuid=disk_uuid, index='2') print 'Restart the VM' server_data = [vm_uuid] start_server(auth, server_data) print("Waiting for the server to get in RUNNING state") ret = wait_for_server(auth, vm_uuid, 'RUNNING') if (ret != 0): raise Exceptions.ExecutionException( "Server is not in RUNNING state") # Return the created disk's uuid return disk_uuid