def build(self, package_folder, skip_validation=False, skip_charm_build=False): """ **Creates a .tar.gz file given a package_folder** :params: - package_folder: is the name of the folder to be packaged - skip_validation: is the flag to validate or not the descriptors on the folder before build :returns: message result for the build process """ self._logger.debug("") package_folder = package_folder.rstrip('/') if not os.path.exists("{}".format(package_folder)): return "Fail, package is not in the specified path" if not skip_validation: print('Validating package {}'.format(package_folder)) results = self.validate(package_folder, recursive=False) if results: for result in results: if result["valid"] != "OK": raise ClientException( "There was an error validating the file {} with error: {}" .format(result["path"], result["error"])) print('Validation OK') else: raise ClientException( "No descriptor file found in: {}".format(package_folder)) charm_list = self.build_all_charms(package_folder, skip_charm_build) return self.build_tarfile(package_folder, charm_list)
def create(self, pdu, update_endpoint=None): headers = self._client._headers headers['Content-Type'] = 'application/yaml' http_header = [ '{}: {}'.format(key, val) for (key, val) in list(headers.items()) ] self._http.set_http_header(http_header) if update_endpoint: http_code, resp = self._http.put_cmd(endpoint=update_endpoint, postfields_dict=pdu) else: endpoint = self._apiBase #endpoint = '{}{}'.format(self._apiBase,ow_string) http_code, resp = self._http.post_cmd(endpoint=endpoint, postfields_dict=pdu) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code in (200, 201, 202, 204): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server: '.format(resp)) print(resp['id']) else: msg = "Error {}".format(http_code) if resp: try: msg = "{} - {}".format(msg, json.loads(resp)) except ValueError: msg = "{} - {}".format(msg, resp) raise ClientException( "failed to create/update pdu - {}".format(msg))
def update(self, project, project_changes): """Updates an OSM project identified by name """ proj = self.get(project) http_code, resp = self._http.put_cmd(endpoint='{}/{}'.format( self._apiBase, proj['_id']), postfields_dict=project_changes) # print('HTTP CODE: {}'.format(http_code)) # print('RESP: {}'.format(resp)) if http_code in (200, 201, 202): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server - {}'.format(resp)) print(resp['id']) elif http_code == 204: print("Updated") else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException("failed to update project {} - {}".format( project, msg))
def list_op(self, name, filter=None): """Returns the list of operations of a NSI """ nsi = self.get(name) try: self._apiResource = '/nsi_lcm_op_occs' self._apiBase = '{}{}{}'.format(self._apiName, self._apiVersion, self._apiResource) filter_string = '' if filter: filter_string = '&{}'.format(filter) http_code, resp = self._http.get2_cmd( '{}?netsliceInstanceId={}'.format(self._apiBase, nsi['_id'], filter_string)) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code == 200: if resp: resp = json.loads(resp) return resp else: raise ClientException('unexpected response from server') else: msg = "" if resp: try: resp = json.loads(resp) msg = resp['detail'] except ValueError: msg = resp raise ClientException(msg) except ClientException as exc: message = "failed to get operation list of NSI {}:\nerror:\n{}".format( name, exc.message) raise ClientException(message)
def scale_vnf(self, ns_name, vnf_name, scaling_group, scale_in, scale_out, wait=False, timeout=None): """Scales a VNF by adding/removing VDUs """ self._logger.debug("") self._client.get_token() try: op_data={} op_data["scaleType"] = "SCALE_VNF" op_data["scaleVnfData"] = {} if scale_in and not scale_out: op_data["scaleVnfData"]["scaleVnfType"] = "SCALE_IN" elif not scale_in and scale_out: op_data["scaleVnfData"]["scaleVnfType"] = "SCALE_OUT" else: raise ClientException("you must set either 'scale_in' or 'scale_out'") op_data["scaleVnfData"]["scaleByStepData"] = { "member-vnf-index": vnf_name, "scaling-group-descriptor": scaling_group, } if timeout: op_data["timeout_ns_scale"] = timeout op_id = self.exec_op(ns_name, op_name='scale', op_data=op_data, wait=wait) print(str(op_id)) except ClientException as exc: message="failed to scale vnf {} of ns {}:\nerror:\n{}".format( vnf_name, ns_name, str(exc)) raise ClientException(message)
def delete(self, ns_name, wait=True): vnfs = self.get_field(ns_name, 'constituent-vnfr-ref') resp = self._terminate(ns_name) if 'success' not in resp: raise ClientException("failed to delete ns {}".format(ns_name)) # helper method to check if pkg exists def check_not_exists(func): try: func() return False except NotFound: return True for vnf in vnfs: if (not utils.wait_for_value( lambda: check_not_exists(lambda: self._client.vnf.get(vnf['vnfr-id'])))): raise ClientException( "vnf {} failed to delete".format(vnf['vnfr-id'])) if not utils.wait_for_value(lambda: check_not_exists(lambda: self.get(ns_name))): raise ClientException("ns {} failed to delete".format(ns_name))
def get_op(self, operationId): """Returns the status of an operation """ try: self._apiResource = '/nsi_lcm_op_occs' self._apiBase = '{}{}{}'.format(self._apiName, self._apiVersion, self._apiResource) http_code, resp = self._http.get2_cmd('{}/{}'.format( self._apiBase, operationId)) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code == 200: if resp: resp = json.loads(resp) return resp else: raise ClientException('unexpected response from server') else: msg = "" if resp: try: resp = json.loads(resp) msg = resp['detail'] except ValueError: msg = resp raise ClientException(msg) except ClientException as exc: message = "failed to get status of operation {}:\nerror:\n{}".format( operationId, exc.message) raise ClientException(message)
def get_pkg(self, pkgtype, name, repo, filter, version): """ Returns the filename of the PKG downloaded to disk """ self._logger.debug("") self._client.get_token() f = None f_name = None # Get OSM registered repository list pkgs = self.pkg_list(pkgtype, filter, repo) for pkg in pkgs: if pkg.get('repository') == repo and pkg.get('name') == name: if 'latest' in version: if not pkg.get('latest'): continue else: version = pkg.get('version') if pkg.get('version') == version: r = requests.get('{}{}'.format(pkg.get('repourl'), pkg.get('location')), stream=True) if r.status_code != 200: raise ClientException("Package not found") with tempfile.NamedTemporaryFile(delete=False) as f: f.write(r.raw.read()) f_name = f.name if not f_name: raise ClientException( "{} {} not found at repo {}".format( pkgtype, name, repo)) return f_name
def exec_op(self, name, op_name, op_data=None): """Executes an operation on a NSI """ nsi = self.get(name) try: self._apiResource = '/netslice_instances' self._apiBase = '{}{}{}'.format(self._apiName, self._apiVersion, self._apiResource) endpoint = '{}/{}/{}'.format(self._apiBase, nsi['_id'], op_name) #print 'OP_NAME: {}'.format(op_name) #print 'OP_DATA: {}'.format(json.dumps(op_data)) http_code, resp = self._http.post_cmd(endpoint=endpoint, postfields_dict=op_data) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code in (200, 201, 202, 204): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server - {}'.format(resp)) print(resp['id']) else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException(msg) except ClientException as exc: message = "failed to exec operation {}:\nerror:\n{}".format( name, exc.message) raise ClientException(message)
def get_op(self, operationId): """Returns the status of an operation """ self._logger.debug("") self._client.get_token() try: self._apiResource = '/ns_lcm_op_occs' self._apiBase = '{}{}{}'.format(self._apiName, self._apiVersion, self._apiResource) http_code, resp = self._http.get2_cmd('{}/{}'.format( self._apiBase, operationId)) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) if http_code == 200: if resp: resp = json.loads(resp) return resp else: raise ClientException('unexpected response from server') else: msg = resp or "" # if resp: # try: # resp = json.loads(resp) # msg = resp['detail'] # except ValueError: # msg = resp raise ClientException(msg) except ClientException as exc: message = "failed to get status of operation {}:\nerror:\n{}".format( operationId, str(exc)) raise ClientException(message)
def delete_alarm(self, name): data = {} data["delete_alarm_request"] = {} data["delete_alarm_request"]["alarm_delete_request"] = {} data["delete_alarm_request"]["alarm_delete_request"][ "alarm_uuid"] = name try: http_code, resp = self._http.post_cmd( endpoint='/test/message/alarm_request', postfields_dict=data) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code in (200, 201, 202, 204): #resp = json.loads(resp) print('Alarm deleted') else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException('error: code: {}, resp: {}'.format( http_code, msg)) except ClientException as exc: message = "failed to delete alarm: alarm {}\n{}".format( name, exc.message) raise ClientException(message)
def create(self, filename, overwrite=None, update_endpoint=None): mime_type = magic.from_file(filename, mime=True) if mime_type is None: raise ClientException( "failed to guess MIME type for file '{}'".format(filename)) headers = self._client._headers headers['Content-Filename'] = basename(filename) if mime_type in ['application/yaml', 'text/plain', 'application/json']: headers['Content-Type'] = 'text/plain' elif mime_type in ['application/gzip', 'application/x-gzip']: headers['Content-Type'] = 'application/gzip' #headers['Content-Type'] = 'application/binary' # Next three lines are to be removed in next version #headers['Content-Filename'] = basename(filename) #file_size = stat(filename).st_size #headers['Content-Range'] = 'bytes 0-{}/{}'.format(file_size - 1, file_size) else: raise ClientException( "Unexpected MIME type for file {}: MIME type {}".format( filename, mime_type)) headers["Content-File-MD5"] = utils.md5(filename) http_header = [ '{}: {}'.format(key, val) for (key, val) in list(headers.items()) ] self._http.set_http_header(http_header) if update_endpoint: http_code, resp = self._http.put_cmd(endpoint=update_endpoint, filename=filename) else: ow_string = '' if overwrite: ow_string = '?{}'.format(overwrite) self._apiResource = '/vnf_packages_content' self._apiBase = '{}{}{}'.format(self._apiName, self._apiVersion, self._apiResource) endpoint = '{}{}'.format(self._apiBase, ow_string) http_code, resp = self._http.post_cmd(endpoint=endpoint, filename=filename) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code in (200, 201, 202): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server: '.format(resp)) return resp['id'] elif http_code == 204: print('Updated') else: msg = "Error {}".format(http_code) if resp: try: msg = "{} - {}".format(msg, json.loads(resp)) except ValueError: msg = "{} - {}".format(msg, resp) raise ClientException( "failed to create/update vnfd - {}".format(msg))
def wait_for_upload(self, filename): """wait(block) for an upload to succeed. The filename passed is assumed to be a descriptor tarball. """ pkg_type = utils.get_key_val_from_pkg(filename) if pkg_type is None: raise ClientException("Cannot determine package type") if not self._wait_for_package(pkg_type): raise ClientException( "package {} failed to upload".format(filename))
def create(self, name, vim_access, sdn_controller=None, sdn_port_mapping=None, wait=False): if 'vim-type' not in vim_access: #'openstack' not in vim_access['vim-type']): raise Exception("vim type not provided") vim_account = {} vim_account['name'] = name vim_account = self.update_vim_account_dict(vim_account, vim_access) vim_config = {} if 'config' in vim_access and vim_access['config'] is not None: vim_config = yaml.safe_load(vim_access['config']) if sdn_controller: sdnc = self._client.sdnc.get(sdn_controller) vim_config['sdn-controller'] = sdnc['_id'] if sdn_port_mapping: with open(sdn_port_mapping, 'r') as f: vim_config['sdn-port-mapping'] = yaml.safe_load(f.read()) if vim_config: vim_account['config'] = vim_config #vim_account['config'] = json.dumps(vim_config) http_code, resp = self._http.post_cmd(endpoint=self._apiBase, postfields_dict=vim_account) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code in (200, 201, 202, 204): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server - {}'.format(resp)) if wait: # Wait for status for VIM instance creation self._wait(resp.get('id')) print(resp['id']) else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException("failed to create vim {} - {}".format( name, msg))
def update(self, vim_name, vim_account, sdn_controller, sdn_port_mapping, wait=False): vim = self.get(vim_name) vim_id_for_wait = self._get_id_for_wait(vim_name) vim_config = {} if 'config' in vim_account: if vim_account.get('config') == "" and (sdn_controller or sdn_port_mapping): raise ClientException( "clearing config is incompatible with updating SDN info") if vim_account.get('config') == "": vim_config = None else: vim_config = yaml.safe_load(vim_account['config']) if sdn_controller: sdnc = self._client.sdnc.get(sdn_controller) vim_config['sdn-controller'] = sdnc['_id'] if sdn_port_mapping: with open(sdn_port_mapping, 'r') as f: vim_config['sdn-port-mapping'] = yaml.safe_load(f.read()) vim_account['config'] = vim_config #vim_account['config'] = json.dumps(vim_config) http_code, resp = self._http.put_cmd(endpoint='{}/{}'.format( self._apiBase, vim['_id']), postfields_dict=vim_account) # print 'HTTP CODE: {}'.format(http_code) # print 'RESP: {}'.format(resp) if http_code in (200, 201, 202, 204): if wait: # In this case, 'resp' always returns None, so 'resp['id']' cannot be used. # Use the previously obtained id instead. wait_id = vim_id_for_wait # Wait for status for VI instance update self._wait(wait_id) else: pass else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException("failed to update vim {} - {}".format( vim_name, msg))
def delete(self, name, force=False): self._client.get_token() repo_id = name if not utils.validate_uuid4(name): repo_id = self.get_id(name) querystring = '' if force: querystring = '?FORCE=True' http_code, resp = self._http.delete_cmd('{}/{}{}'.format( self._apiBase, repo_id, querystring)) #print 'HTTP CODE: {}'.format(http_code) #print 'RESP: {}'.format(resp) if http_code == 202: print('Deletion in progress') elif http_code == 204: print('Deleted') else: msg = resp or "" # if resp: # try: # msg = json.loads(resp) # except ValueError: # msg = resp raise ClientException("failed to delete repo {} - {}".format( name, msg))
def delete(self, name, force=False, wait=False): nsi = self.get(name) querystring = '' if force: querystring = '?FORCE=True' http_code, resp = self._http.delete_cmd('{}/{}{}'.format( self._apiBase, nsi['_id'], querystring)) # print 'HTTP CODE: {}'.format(http_code) # print 'RESP: {}'.format(resp) if http_code == 202: if wait and resp: resp = json.loads(resp) # Wait for status for NSI instance deletion # For the 'delete' operation, '_id' is used self._wait(resp.get('_id'), deleteFlag=True) else: print('Deletion in progress') elif http_code == 204: print('Deleted') else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException("failed to delete nsi {} - {}".format( name, msg))
def pkg_get(self, pkgtype, name, repo, version, filter): pkg_name = self.get_pkg(pkgtype, name, repo, filter, version) if not pkg_name: raise ClientException('Package not found') folder, descriptor = self.zip_extraction(pkg_name) with open(descriptor) as pkg: pkg_descriptor = yaml.safe_load(pkg) rmtree(folder, ignore_errors=False) if ((pkgtype == 'vnf' and (pkg_descriptor.get('vnfd') or pkg_descriptor.get('vnfd:vnfd_catalog'))) or (pkgtype == 'ns' and (pkg_descriptor.get('nsd') or pkg_descriptor.get('nsd:nsd_catalog')))): raise ClientException('Wrong Package type') return pkg_descriptor
def delete(self, name, force=False): """ Deletes an OSM role identified by name. :param name: :param force: :raises ClientException: when fails to delete a role. """ role = self.get(name) querystring = '' if force: querystring = '?FORCE=True' http_code, resp = self._http.delete_cmd('{}/{}{}'.format( self._apiBase, role['_id'], querystring)) # print('HTTP CODE: {}'.format(http_code)) # print('RESP: {}'.format(resp)) if http_code == 202: print('Deletion in progress') elif http_code == 204: print('Deleted') elif resp and 'result' in resp: print('Deleted') else: msg = "" if resp: try: msg = json.loads(resp) except ValueError: msg = resp raise ClientException("Failed to delete role {} - {}".format( name, msg))
def create(self, pdu, update_endpoint=None): self._logger.debug("") self._client.get_token() headers = self._client._headers headers['Content-Type'] = 'application/yaml' http_header = [ '{}: {}'.format(key, val) for (key, val) in list(headers.items()) ] self._http.set_http_header(http_header) if update_endpoint: http_code, resp = self._http.put_cmd(endpoint=update_endpoint, postfields_dict=pdu) else: endpoint = self._apiBase #endpoint = '{}{}'.format(self._apiBase,ow_string) http_code, resp = self._http.post_cmd(endpoint=endpoint, postfields_dict=pdu) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) #if http_code in (200, 201, 202, 204): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server: {}'.format(resp)) print(resp['id'])
def scale_vnf(self, ns_name, vnf_name, scaling_group, scale_in, scale_out, wait=False): """Scales a VNF by adding/removing VDUs """ try: op_data = {} op_data["scaleType"] = "SCALE_VNF" op_data["scaleVnfData"] = {} if scale_in: op_data["scaleVnfData"]["scaleVnfType"] = "SCALE_IN" else: op_data["scaleVnfData"]["scaleVnfType"] = "SCALE_OUT" op_data["scaleVnfData"]["scaleByStepData"] = { "member-vnf-index": vnf_name, "scaling-group-descriptor": scaling_group, } self.exec_op(ns_name, op_name='scale', op_data=op_data, wait=wait) except ClientException as exc: message = "failed to scale vnf {} of ns {}:\nerror:\n{}".format( vnf_name, ns_name, exc.message) raise ClientException(message)
def delete(self, name, force=False): """Deletes an existing OSM user identified by name """ self._logger.debug("") self._client.get_token() user = self.get(name) querystring = '' if force: querystring = '?FORCE=True' http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase, user['_id'], querystring), skip_query_admin=True) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) if http_code == 202: print('Deletion in progress') elif http_code == 204: print('Deleted') elif resp and 'result' in resp: print('Deleted') else: msg = resp or "" # if resp: # try: # msg = json.loads(resp) # except ValueError: # msg = resp raise ClientException("failed to delete user {} - {}".format(name, msg))
def delete(self, name, force=False, wait=False): self._logger.debug("") self._client.get_token() sdn_controller = self.get(name) sdnc_id_for_wait = self._get_id_for_wait(name) querystring = '' if force: querystring = '?FORCE=True' http_code, resp = self._http.delete_cmd('{}/{}{}'.format( self._apiBase, sdn_controller['_id'], querystring)) # print('HTTP CODE: {}'.format(http_code)) # print('RESP: {}'.format(resp)) if http_code == 202: if wait: # Wait for status for SDNC instance deletion self._wait(sdnc_id_for_wait, wait, deleteFlag=True) else: print('Deletion in progress') elif http_code == 204: print('Deleted') elif resp and 'result' in resp: print('Deleted') else: msg = resp or "" # if resp: # try: # msg = json.loads(resp) # except ValueError: # msg = resp raise ClientException( "failed to delete SDN controller {} - {}".format(name, msg))
def delete(self, vnfd_name): vnfd = self.get(vnfd_name) resp = self._http.delete_cmd( 'api/running/{}vnfd-catalog/vnfd/{}'.format( self._client.so_rbac_project_path, vnfd['id'])) if 'success' not in resp: raise ClientException("failed to delete vnfd {}".format(vnfd_name))
def create(self, name, wim_input, wim_port_mapping=None, wait=False): self._logger.debug("") self._client.get_token() if 'wim_type' not in wim_input: raise Exception("wim type not provided") wim_account = wim_input wim_account["name"] = name wim_config = {} if 'config' in wim_input and wim_input['config'] is not None: wim_config = yaml.safe_load(wim_input['config']) if wim_port_mapping: with open(wim_port_mapping, 'r') as f: wim_config['wim_port_mapping'] = yaml.safe_load(f.read()) if wim_config: wim_account['config'] = wim_config #wim_account['config'] = json.dumps(wim_config) http_code, resp = self._http.post_cmd(endpoint=self._apiBase, postfields_dict=wim_account) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) #if http_code in (200, 201, 202, 204): if resp: resp = json.loads(resp) if not resp or 'id' not in resp: raise ClientException( 'unexpected response from server - {}'.format(resp)) if wait: # Wait for status for WIM instance creation self._wait(resp.get('id'), wait) print(resp['id'])
def _detach(self, vim_name): tenant_name = 'osm' tenant = self._get_ro_tenant() if tenant is None: raise ClientException("tenant {} not found".format(tenant_name)) return self._ro_http.delete_cmd('openmano/{}/datacenters/{}'.format( tenant["uuid"], vim_name))
def export_metric(self, metric): self._logger.debug("") self._client.get_token() data = {} data["read_metric_data_request"] = metric try: http_code, resp = self._http.post_cmd( endpoint='/test/message/metric_request', postfields_dict=data) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) # if http_code in (200, 201, 202, 204): # resp = json.loads(resp) return 'Metric exported' #else: # msg = "" # if resp: # try: # msg = json.loads(resp) # except ValueError: # msg = resp # raise ClientException('error: code: {}, resp: {}'.format( # http_code, msg)) except ClientException as exc: message = "failed to export metric: metric {}\n{}".format( metric, str(exc)) raise ClientException(message)
def delete_alarm(self, name): self._logger.debug("") self._client.get_token() data = {} data["delete_alarm_request"] = {} data["delete_alarm_request"]["alarm_delete_request"] = {} data["delete_alarm_request"]["alarm_delete_request"][ "alarm_uuid"] = name try: http_code, resp = self._http.post_cmd( endpoint='/test/message/alarm_request', postfields_dict=data) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) # if http_code in (200, 201, 202, 204): # resp = json.loads(resp) print('Alarm deleted') #else: # msg = "" # if resp: # try: # msg = json.loads(resp) # except ValueError: # msg = resp # raise ClientException('error: code: {}, resp: {}'.format( # http_code, msg)) except ClientException as exc: message = "failed to delete alarm: alarm {}\n{}".format( name, str(exc)) raise ClientException(message)
def create(self, name, vim_access): vim_account = {} vim_account['datacenter'] = {} # currently assumes vim_acc if ('vim-type' not in vim_access): #'openstack' not in vim_access['vim-type']): raise Exception("vim type not provided") vim_account['datacenter']['name'] = name vim_account['datacenter']['type'] = vim_access['vim-type'] vim_config = {} if 'config' in vim_access and vim_access['config'] is not None: vim_config = yaml.safe_load(vim_access['config']) if vim_config: vim_account['datacenter']['config'] = vim_config vim_account = self.update_vim_account_dict(vim_account, vim_access, vim_config) resp = self._ro_http.post_cmd('openmano/datacenters', vim_account) if resp and 'error' in resp: raise ClientException("failed to create vim") else: self._attach(name, vim_account) self._update_ro_accounts()
def update(self, wim_name, wim_account, wim_port_mapping=None, wait=False): self._logger.debug("") self._client.get_token() wim = self.get(wim_name) wim_id_for_wait = self._get_id_for_wait(wim_name) wim_config = {} if 'config' in wim_account: if wim_account.get('config') == "" and (wim_port_mapping): raise ClientException( "clearing config is incompatible with updating SDN info") if wim_account.get('config') == "": wim_config = None else: wim_config = yaml.safe_load(wim_account['config']) if wim_port_mapping: with open(wim_port_mapping, 'r') as f: wim_config['wim_port_mapping'] = yaml.safe_load(f.read()) wim_account['config'] = wim_config #wim_account['config'] = json.dumps(wim_config) http_code, resp = self._http.patch_cmd(endpoint='{}/{}'.format( self._apiBase, wim['_id']), postfields_dict=wim_account) #print('HTTP CODE: {}'.format(http_code)) #print('RESP: {}'.format(resp)) #if http_code in (200, 201, 202, 204): if wait: # In this case, 'resp' always returns None, so 'resp['id']' cannot be used. # Use the previously obtained id instead. wait_id = wim_id_for_wait # Wait for status for WIM instance update self._wait(wait_id, wait)