def _create_logical_interfaces(self, vnc_lib, logical_interfaces_payload): object_type = "logical_interface" success_intfs_names = [] log_intf_failed_info = [] for log_interface_dict in logical_interfaces_payload: try: try: cls = JobVncApi.get_vnc_cls(object_type) log_interface_obj = cls.from_dict(**log_interface_dict) existing_obj = vnc_lib.logical_interface_read( fq_name=log_interface_dict.get('fq_name')) existing_obj_dict = vnc_lib.obj_to_dict(existing_obj) for key in log_interface_dict: to_be_upd_value = log_interface_dict[key] existing_value = existing_obj_dict.get(key) if to_be_upd_value != existing_value: vnc_lib.logical_interface_update(log_interface_obj) break success_intfs_names.append( log_interface_dict['fq_name'][-1]) except NoIdError as exc: vnc_lib.logical_interface_create(log_interface_obj) success_intfs_names.append( log_interface_dict['fq_name'][-1]) except Exception as exc: _task_error_log(str(exc)) _task_error_log(traceback.format_exc()) log_intf_failed_info.append({ "log_interface_name": log_interface_dict['fq_name'][-1], "failure_msg": str(exc) }) return success_intfs_names, log_intf_failed_info
def get_mgmt_ips_frm_lo_ips(self, job_ctx, lo0_ips, device_name): FilterLog.instance("GetMgmtIPFilter", device_name) _task_log("Starting to get the mgmt_ips") mgmt_ips = [] try: _task_log("Getting the vnc handle") self.vnc_lib = JobVncApi.vnc_init(job_ctx) for lo0_ip in lo0_ips: if lo0_ip: mgmt_ip, dev_name = self._get_mgmt_ip(lo0_ip) if mgmt_ip: mgmt_ips.append({mgmt_ip: (dev_name, lo0_ip)}) _task_done() return { 'status': 'success', 'get_mgmt_ip_log': FilterLog.instance().dump(), 'get_mgmt_ips': mgmt_ips } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return { 'status': 'failure', 'error_msg': str(ex), 'get_mgmt_ips': mgmt_ips, 'get_mgmt_ip_log': FilterLog.instance().dump() }
def get_device_info( self, job_ctx, device_uuid, ): try: FilterLog.instance("HitlessUpgradeFilter") self.job_input = FilterModule._validate_job_ctx(job_ctx) self.fabric_uuid = self.job_input['fabric_uuid'] self.vncapi = JobVncApi.vnc_init(job_ctx) self.job_ctx = job_ctx self.ja = JobAnnotations(self.vncapi) self.advanced_parameters = self._get_advanced_params() self._cache_job_input() self.device_uuid = device_uuid device_info = self._get_device_info() return device_info except Exception as ex: errmsg = "Unexpected error getting device info: %s\n%s" % ( str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def _update_dataplane_ip(self, vnc_lib, dataplane_ip, prouter_name): warning_info = {} object_type = "physical_router" if dataplane_ip == "": return "", "", warning_info else: try: obj_dict = { "uuid": None, "fq_name": ["default-global-system-config", prouter_name], "physical_router_dataplane_ip": dataplane_ip, "physical_router_loopback_ip": dataplane_ip } cls = JobVncApi.get_vnc_cls(object_type) physical_router_obj = cls.from_dict(**obj_dict) vnc_lib.physical_router_update(physical_router_obj) upd_resp = "\nUpdated device with dataplane ip: " except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) upd_resp = "There was a problem while updating the" \ " device with dataplane ip: " warning_info = { "device_name": prouter_name, "dataplane_ip": dataplane_ip, "warning_message": str(ex) } return dataplane_ip, upd_resp, warning_info
def _create_physical_interface_refs(self, vnc_lib, topology_disc_payload): # create or update refs between physical interfaces # on the local device to the remote device object_type = "physical_interface" ref_type = object_type lldp_neighbors_success_names = [] lldp_neighbors_failed_info = [] for topology_disc_info in topology_disc_payload or []: try: object_fqname = topology_disc_info[0] ref_fqname = topology_disc_info[1] object_uuid = vnc_lib.fq_name_to_id(object_type, object_fqname) vnc_lib.ref_update(object_type, object_uuid, ref_type, None, ref_fqname, 'ADD') lldp_neighbors_success_names.append(object_fqname[-2] + " : " + object_fqname[-1] + " --> " + ref_fqname[-2] + " : " + ref_fqname[-1]) except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) lldp_neighbor_failed_obj = { "lldp_neighbor": object_fqname[-2] + " : " + object_fqname[-1] + " --> " + ref_fqname[-2] + " : " + ref_fqname[-1], "warning_message": str(ex) } lldp_neighbors_failed_info.append(lldp_neighbor_failed_obj) return { 'lldp_neighbors_success_names': lldp_neighbors_success_names, 'lldp_neighbors_failed_info': lldp_neighbors_failed_info }
def get_mgmt_ips_frm_lo_ips(self, job_ctx, lo0_ips, device_name): FilterLog.instance("GetMgmtIPFilter", device_name) _task_log("Starting to get the mgmt_ips") mgmt_ips = [] try: _task_log("Getting the vnc handle") self.vnc_lib = JobVncApi.vnc_init(job_ctx) for lo0_ip in lo0_ips: if lo0_ip: mgmt_ip, dev_name = self._get_mgmt_ip(lo0_ip) if mgmt_ip: mgmt_ips.append({mgmt_ip : (dev_name, lo0_ip)}) _task_done() return { 'status': 'success', 'get_mgmt_ip_log': FilterLog.instance().dump(), 'get_mgmt_ips': mgmt_ips } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return {'status': 'failure', 'error_msg': str(ex), 'get_mgmt_ips': mgmt_ips, 'get_mgmt_ip_log': FilterLog.instance().dump()}
def validate_critical_roles_for_hitless(self, job_ctx, image_upgrade_list): try: FilterLog.instance("HitlessUpgradeFilter") self.job_input = FilterModule._validate_job_ctx(job_ctx) self.fabric_uuid = self.job_input['fabric_uuid'] self.vncapi = JobVncApi.vnc_init(job_ctx) self.job_ctx = job_ctx self.ja = JobAnnotations(self.vncapi) self.advanced_parameters = self._get_advanced_params() self._cache_job_input() self.image_upgrade_list = image_upgrade_list self.device_uuid_list = [] for image_entry in self.image_upgrade_list: device_list = image_entry.get('device_list') image_uuid = image_entry.get('image_uuid') image_obj = self.vncapi.device_image_read(id=image_uuid) for device_uuid in device_list: device_obj = self.vncapi.physical_router_read( id=device_uuid) if image_obj.device_image_os_version !=\ device_obj.physical_router_os_version: self.device_uuid_list.append(device_uuid) results = self._validate_critical_roles_for_hitless_upgrade() return results except Exception as ex: errmsg = "Unexpected error validating: %s\n%s" % ( str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def get_hitless_upgrade_plan(self, job_ctx, image_upgrade_list, device_json): try: FilterLog.instance("HitlessUpgradeFilter") self.job_input = FilterModule._validate_job_ctx(job_ctx) self.fabric_uuid = self.job_input['fabric_uuid'] self.vncapi = JobVncApi.vnc_init(job_ctx) self.job_ctx = job_ctx self.ja = JobAnnotations(self.vncapi) self.advanced_parameters = self._get_advanced_params() self._cache_job_input() self.batch_limit = self.advanced_parameters.get( 'bulk_device_upgrade_count') self.image_upgrade_list = image_upgrade_list self.device_json = device_json upgrade_plan = self._get_hitless_upgrade_plan() return upgrade_plan except Exception as ex: errmsg = "Unexpected error: %s\n%s" % (str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def _create_logical_interfaces(self, vnc_lib, logical_interfaces_payload): object_type = "logical_interface" success_intfs_names = [] log_intf_failed_info = [] for log_interface_dict in logical_interfaces_payload: try: try: cls = JobVncApi.get_vnc_cls(object_type) log_interface_obj = cls.from_dict(**log_interface_dict) existing_obj = vnc_lib.logical_interface_read( fq_name=log_interface_dict.get('fq_name')) existing_obj_dict = vnc_lib.obj_to_dict(existing_obj) for key in log_interface_dict: to_be_upd_value = log_interface_dict[key] existing_value = existing_obj_dict.get(key) if to_be_upd_value != existing_value: vnc_lib.logical_interface_update(log_interface_obj) break success_intfs_names.append( log_interface_dict['fq_name'][-1]) except NoIdError as exc: vnc_lib.logical_interface_create(log_interface_obj) success_intfs_names.append( log_interface_dict['fq_name'][-1]) except Exception as exc: _task_error_log(str(exc)) _task_error_log(traceback.format_exc()) log_intf_failed_info.append({ "log_interface_name": log_interface_dict['fq_name'][-1], "failure_msg": str(exc) }) return success_intfs_names, log_intf_failed_info
def get_all_devices(self, job_ctx, upgrade_plan): try: return self._get_all_devices(upgrade_plan) except Exception as ex: errmsg = "Unexpected error attempting to get all devices: %s\n%s" % ( str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def get_next_batch(self, job_ctx, upgrade_plan, device_uuid): try: return self._get_next_batch(upgrade_plan, device_uuid) except Exception as ex: errmsg = "Unexpected error attempting to get next batch: %s\n%s" % ( str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def _render_config(self): # Get list of all legacy feature directories legacy_feature_list = \ [name[4:] for name in os.listdir('./roles') if name.startswith('cfg_')] feature_list = [name for name in os.listdir('./config_templates')] # Loop through all the features for feature in self.feature_apply_order: # If not managing underlay for this feature, skip if 'underlay' in feature and not self.manage_underlay \ and 'ip_clos' not in feature: continue feature_based_only = feature not in legacy_feature_list apply_feature_based = feature in self.feature_based_list if feature in feature_list and \ (apply_feature_based or feature_based_only): is_empty = not apply_feature_based feature_template_dir = './config_templates/' + feature else: feature_template_dir = './roles/cfg_' + feature + '/templates' is_empty = feature not in self.dev_feature_list feature_template_list = self._get_feature_templates( feature_template_dir, feature) # If feature not supported on this platform, skip if not feature_template_list: continue # For each feature template, including model-specific templates, # render the jinja template for template in feature_template_list: self._render_feature_config(feature, template, is_empty) # Write to config file which will be sent to device with open(self.combined_config_path, 'w') as f: f.write(self.final_config) # Generate return output to be used by playbook render_output = { 'conf_dir': self.conf_dir, 'combined_config': self.combined_config_path, 'device_mgmt_ip': self.device_mgmt_ip, 'device_vendor': self.device_vendor, 'device_name': self.device_name, 'device_uuid': self.device_uuid, 'device_username': self.device_username, 'device_password': "******", 'is_delete': self.is_delete, 'enterprise_style': self.enterprise_style, 'onboard_log': FilterLog.instance().dump(), 'results': {}, 'status': "success" } _task_error_log("render_output: %s" % render_output) render_output['device_password'] = self.device_password return render_output
def get_all_devices(self, job_ctx, upgrade_plan): try: return self._get_all_devices(upgrade_plan) except Exception as ex: errmsg = "Unexpected error attempting to get all devices: %s\n%s" % ( str(ex), traceback.format_exc() ) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def get_next_batch(self, job_ctx, upgrade_plan, device_uuid): try: return self._get_next_batch(upgrade_plan, device_uuid) except Exception as ex: errmsg = "Unexpected error attempting to get next batch: %s\n%s" % ( str(ex), traceback.format_exc() ) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def rma_get_device_password(self, job_ctx, rma_devices_list): try: self.vncapi = JobVncApi.vnc_init(job_ctx) device_uuid = rma_devices_list[0]['device_uuid'] device_obj = self.vncapi.physical_router_read(id=device_uuid) return self._get_password(device_obj) except Exception as ex: errmsg = "Unexpected error: %s\n%s" % (str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def validate_schema(self, schema_type, file_path, json_obj, device_name): self._instantiate_filter_log_instance(device_name) try: _task_log("Starting to validate " + schema_type) with open(file_path) as f: schema_json = json.load(f) jsonschema.validate(json_obj, schema_json.get(schema_type)) _task_done("Completed " + schema_type + " validation") return {'status': 'success'} except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return {'status': 'failure', 'error_msg': str(ex)}
def render_fabric_config(self, job_ctx): try: FilterLog.instance("FabricConfigFilter") self._initialize(job_ctx) self._get_feature_list() return self._render_config() except Exception as ex: errmsg = "Unexpected error: %s\n%s" % (str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, 'onboard_log': FilterLog.instance().dump() }
def rma_devices_to_ztp(self, job_ctx, rma_devices_list): try: FilterLog.instance("RmaDevicesFilter") self.job_input = FilterModule._validate_job_ctx(job_ctx) self.vncapi = JobVncApi.vnc_init(job_ctx) self.job_ctx = job_ctx return self._rma_devices_to_ztp(rma_devices_list) except Exception as ex: errmsg = "Unexpected error: %s\n%s" % (str(ex), traceback.format_exc()) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def cli_diff_list_update(self, job_ctx, cli_fq_name, total_commit_diff_list, final_commit_processed_list): try: vnc_lib = JobVncApi.vnc_init(job_ctx) pr_cli_obj_raw = vnc_lib.cli_config_read(fq_name=cli_fq_name) for item in final_commit_processed_list: total_commit_diff_list.remove(item) updated_dict = {"commit_diff_info": total_commit_diff_list} pr_cli_obj_raw.set_commit_diff_list(updated_dict) vnc_lib.cli_config_update(pr_cli_obj_raw) if len(total_commit_diff_list) == 0: return True except Exception as ex: errmsg = "Unexpected error: %s\n%s" % (str(ex), traceback.format_exc()) _task_error_log(errmsg)
def _create_physical_interface_refs(self, vnc_lib, topology_disc_payload): # create or update refs between physical interfaces # on the local device to the remote device object_type = "physical_interface" lldp_neighbors_success_names = [] lldp_neighbors_failed_info = [] for topology_disc_info in topology_disc_payload or []: try: object_fqname = topology_disc_info[0] ref_fqname = topology_disc_info[1] pi_obj = vnc_lib.physical_interface_read(fq_name=object_fqname) # Check ref already present or not refs = pi_obj.get_physical_interface_refs() is_link_found = False if refs: for ref in refs: if ref['to'] == ref_fqname: is_link_found = True if not is_link_found: ref_uuid = vnc_lib.fq_name_to_id(object_type, ref_fqname) pi_obj.set_physical_interface_list([{ "to": ref_fqname, "uuid": ref_uuid }]) vnc_lib.physical_interface_update(pi_obj) lldp_neighbors_success_names.append(object_fqname[-2] + " : " + object_fqname[-1] + " --> " + ref_fqname[-2] + " : " + ref_fqname[-1]) except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) lldp_neighbor_failed_obj = { "lldp_neighbor": object_fqname[-2] + " : " + object_fqname[-1] + " --> " + ref_fqname[-2] + " : " + ref_fqname[-1], "warning_message": str(ex) } lldp_neighbors_failed_info.append(lldp_neighbor_failed_obj) return { 'lldp_neighbors_success_names': lldp_neighbors_success_names, 'lldp_neighbors_failed_info': lldp_neighbors_failed_info }
def validate_schema(self, schema_type, file_path, json_obj, device_name): self._instantiate_filter_log_instance(device_name) try: _task_log("Starting to validate " + schema_type) with open(file_path) as f: schema_json = json.load(f) jsonschema.validate(json_obj, schema_json.get(schema_type)) _task_done("Completed "+ schema_type +" validation") return {'status': 'success'} except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return { 'status': 'failure', 'error_msg': str(ex) }
def get_device_info(self, job_ctx, device_uuid): try: FilterLog.instance("HitlessUpgradeFilter") self.job_input = FilterModule._validate_job_ctx(job_ctx) self.fabric_uuid = self.job_input['fabric_uuid'] self.vncapi = JobVncApi.vnc_init(job_ctx) self.job_ctx = job_ctx self.ja = JobAnnotations(self.vncapi) self.advanced_parameters = self._get_advanced_params() self._cache_job_input() self.device_uuid = device_uuid device_info = self._get_device_info() return device_info except Exception as ex: errmsg = "Unexpected error getting device info: %s\n%s" % ( str(ex), traceback.format_exc() ) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def get_hitless_upgrade_plan(self, job_ctx, image_upgrade_list): try: FilterLog.instance("HitlessUpgradeFilter") self.job_input = FilterModule._validate_job_ctx(job_ctx) self.fabric_uuid = self.job_input['fabric_uuid'] self.vncapi = JobVncApi.vnc_init(job_ctx) self.job_ctx = job_ctx self.ja = JobAnnotations(self.vncapi) self.advanced_parameters = self._get_advanced_params() self._cache_job_input() self.batch_limit = self.advanced_parameters.get( 'bulk_device_upgrade_count') self.image_upgrade_list = image_upgrade_list upgrade_plan = self._get_hitless_upgrade_plan() return upgrade_plan except Exception as ex: errmsg = "Unexpected error: %s\n%s" % ( str(ex), traceback.format_exc() ) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def _update_physical_router_object(self, obj_dict_payload, prouter_name): warning_info = {} object_type = "physical_router" try: cls = JobVncApi.get_vnc_cls(object_type) physical_router_obj = cls.from_dict(**obj_dict_payload) self.vnc_lib.physical_router_update(physical_router_obj) job_log_msg = "- loopback_ip: %s\n - OS Version: %s\n" \ % ( physical_router_obj. get_physical_router_loopback_ip(), physical_router_obj. get_physical_router_os_version() ) except NoIdError as exc: _task_error_log(str(exc)) _task_error_log(traceback.format_exc()) job_log_msg = "The device being updated was not found" \ " in the vnc database" warning_info = { "device_name": prouter_name, "obj_dict_payload": obj_dict_payload, "warning_message": str(exc) } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) job_log_msg = "There was a problem while updating the" \ " device" warning_info = { "device_name": prouter_name, "obj_dict_payload": obj_dict_payload, "warning_message": str(ex) } return { "warning_info": warning_info, "job_log_msg": job_log_msg }
def _update_physical_router_object(self, obj_dict_payload, prouter_name): warning_info = {} object_type = "physical_router" try: cls = JobVncApi.get_vnc_cls(object_type) physical_router_obj = cls.from_dict(**obj_dict_payload) self.vnc_lib.physical_router_update(physical_router_obj) job_log_msg = "- loopback_ip: %s\n - OS Version: %s\n" \ % ( physical_router_obj. get_physical_router_loopback_ip(), physical_router_obj. get_physical_router_os_version() ) except NoIdError as exc: _task_error_log(str(exc)) _task_error_log(traceback.format_exc()) job_log_msg = "The device being updated was not found" \ " in the vnc database" warning_info = { "device_name": prouter_name, "obj_dict_payload": obj_dict_payload, "warning_message": str(exc) } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) job_log_msg = "There was a problem while updating the" \ " device" warning_info = { "device_name": prouter_name, "obj_dict_payload": obj_dict_payload, "warning_message": str(ex) } return { "warning_info": warning_info, "job_log_msg": job_log_msg }
def topology_discovery(self, job_ctx, prouter_fqname, lldp_neighbors_payload): """Topology discovery. :param job_ctx: Dictionary example: { "auth_token": "EB9ABC546F98", "job_input": { "fabric_fq_name": [ "default-global-system-config", "fab01" ], "device_auth": [{ "username": "******", "password": "******" }], "management_subnets": [ { "cidr": "10.87.69.0/25", "gateway": "10.87.69.1" } ], "overlay_ibgp_asn": 64512, "node_profiles": [ { "node_profile_name": "juniper-qfx5k" } ] } } :param prouter_fqname: List example: [ "default-global-system-config", "5c3-qfx2" ] :param lldp_neighbors_payload: Dictionary example: { "neighbor_info_list": [ { "local_physical_interface_name": "xe-0/0/0", "remote_device_name": "5b5-qfx11", "remote_physical_interface_port_id": "536" } ] } :return: Dictionary if success, returns { 'status': 'success', 'topology_discovery_log': <String: topology_discovery_log>, 'topology_discovery_resp': <Dictionary: topology_discovery_resp> } if failure, returns { 'status': 'failure', 'error_msg': <String: exception message>, 'topology_discovery_log': <String: topology_discovery_log>, 'topology_discovery_resp': <Dictionary: topology_discovery_resp> } :param topology_discovery_resp: Dictionary example: { "lldp_neighbors_success_names": <List: <String: lldp_neighbors_success_pair_string>>, "lldp_neighbors_failed_info": <List: <Dictionary: lldp_neighbor_failed_obj> > } :param lldp_neighbors_success_names: List example: ["bng-contrail-qfx51-15 : ge-0/0/36 --> dhawan : ge-2/3/1"] :param lldp_neighbors_failed_info: List example: [ { "lldp_neighbor": "bng-contrail-qfx51-15 : em0 --> sw174 : ge-1/0/46", "warning_message": "Unknown physical interface ng-contrail-qfx51-15:em0" } ] """ self._instantiate_filter_log_instance(prouter_fqname[-1]) _task_log("Starting Topology Discovery") try: _task_log("Creating neighboring links") topology_discovery_resp = self._create_neighbor_links( job_ctx, lldp_neighbors_payload, prouter_fqname) _task_done() return { 'status': 'success', 'topology_discovery_log': FilterLog.instance().dump(), 'topology_discovery_resp': topology_discovery_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return { 'status': 'failure', 'error_msg': str(ex), 'topology_discovery_log': FilterLog.instance().dump() }
def cli_sync(self, job_ctx, prouter_name, pr_uuid, devices_cli, device_mgmt_ip): # find the appropriate device info try: vnc_lib = JobVncApi.vnc_init(job_ctx) partial_accepted_config = "" action_to_be_performed = "" pr_commit_processed_list = [] pr_cli_obj_raw = "" pr_commit_diff_list = [] for dict_item in devices_cli: if dict_item["device_uuid"] == pr_uuid: # Read the referenced cli object from PR device_cli_objects = dict_item['cli_objects'] device_cli_objects = sorted(device_cli_objects, key = lambda i: i['time']) cli_obj_name = prouter_name + "_" + "cli_config" cli_fq_name = [ 'default-global-system-config', prouter_name, cli_obj_name] pr_cli_obj_raw = vnc_lib.cli_config_read( fq_name=cli_fq_name) pr_cli_obj = vnc_lib.obj_to_dict(pr_cli_obj_raw) pr_commit_diff_list = \ pr_cli_obj["commit_diff_list"]["commit_diff_info"] # Process each of the items, delete items from cli object # if processed successfully. for pr_commit_item in pr_commit_diff_list: for cli_item in device_cli_objects: if cli_item.get('time') == pr_commit_item.get( 'time'): pr_commit_processed_list.append(pr_commit_item) action_to_be_performed = cli_item.get('status') if action_to_be_performed == "accept": partial_accepted_config += \ self._accept_routine(pr_commit_item, device_mgmt_ip) elif action_to_be_performed == "reject": self._reject_routine(pr_commit_item, device_mgmt_ip) else: self._ignore_routine(pr_commit_item, device_mgmt_ip) # Process file one last time for any delete commands for accept # case file_path = PLAYBOOK_BASE + "/manual_config" "/" + \ device_mgmt_ip + "/approve_config.conf" if action_to_be_performed == "accept" and os.path.exists(file_path): complete_accepted_config = self._process_file_for_delete_commands( partial_accepted_config, device_mgmt_ip) original_acc_config = pr_cli_obj_raw.get_accepted_cli_config() if original_acc_config is None: original_acc_config = "" updated_acc_config = original_acc_config + complete_accepted_config pr_cli_obj_raw.set_accepted_cli_config(updated_acc_config) vnc_lib.cli_config_update(pr_cli_obj_raw) data_dict = { "pr_commit_diff_list": pr_commit_diff_list, "pr_commit_item": pr_commit_processed_list, "cli_fq_name": cli_fq_name } self.merge_files(device_mgmt_ip) return data_dict except Exception as ex: errmsg = "Unexpected error: %s\n%s" % ( str(ex), traceback.format_exc() ) _task_error_log(errmsg) return { 'status': 'failure', 'error_msg': errmsg, }
def update_physical_router(self, job_ctx, prouter_name, obj_dict_payload, prouter_vendor): """ :param job_ctx: Dictionary example: { "auth_token": "EB9ABC546F98", "job_input": { "fabric_fq_name": [ "default-global-system-config", "fab01" ], "device_auth": [{ "username": "******", "password": "******" }] } } :param prouter_name: String example: "5c3-qfx8" :param obj_dict_payload: Dictionary example: { "physical_router_dataplane_ip": "10.0.0.2", "physical_router_loopback_ip": "10.0.0.2", "fq_name": ["default-global-system-config","5c3-qfx8"], "physical_router_os_version": "srx-20.65", "additional_properties": { 'Some Key that needs to be tapped': 'Some random annotations spec. to this vendor' } } :param prouter_vendor: String example: "juniper" :return: Dictionary if success, returns { 'status': 'success', 'upd_pr_log': <String: upd_pr_log>, 'physical_router_upd_resp': <Dictionary: physical_router_upd_resp> } if failure, returns { 'status': 'failure', 'error_msg': <String: exception message>, 'upd_pr_log': <String: upd_pr_log> } :param physical_router_upd_resp: Dictionary example: { "job_log_msg": <String: job log message>, "warning_info": <Dictionary: warning_info> } """ FilterLog.instance("UpdatePhysicalRouterFilter", prouter_name) _task_log("Starting Device Update") try: _task_log("Creating vnc handle") self.vnc_lib = JobVncApi.vnc_init(job_ctx) _task_log("Parsing additional physical router properties") FilterModule._parse_additional_prop_and_upd_payload( obj_dict_payload, prouter_vendor) _task_log("Updating the physical router") physical_router_upd_resp = \ self._update_physical_router_object( obj_dict_payload, prouter_name ) _task_done() return { 'status': 'success', 'upd_pr_log': FilterLog.instance().dump(), 'physical_router_upd_resp': physical_router_upd_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return { 'status': 'failure', 'error_msg': str(ex), 'upd_pr_log': FilterLog.instance().dump() }
def import_hardware_inventory_info(self, job_ctx, prouter_name, pr_product_name, prouter_vendor, hardware_inventory_payload): r"""Import Hardware Inventory. :param job_ctx: Dictionary # example: # { # "auth_token": "EB9ABC546F98", # "job_input": { # "fabric_fq_name": [ # "default-global-system-config", # "fab01" # ], # "device_auth": [{ # "username": "******", # "password": "******" # }], # "management_subnets": [ # { # "cidr": "10.87.69.0/25", # "gateway": "10.87.69.1" # } # ], # "overlay_ibgp_asn": 64512, # "node_profiles": [ # { # "node_profile_name": "juniper-qfx5k" # } # ] # } # } :param prouter_name: String example: "5c3-qfx8" :param pr_product_name: String example: "qfx5110-48s-4c" :param prouter_vendor: String example: "Juniper" :param hardware_inventory_payload: Dictionary # example: # { # "inventory_info": "\n[{'description': u'QFX5110-48S-4C', # 'parent': '', 'model_number': None, 'module': u'Chassis', # 'version': None, 'serial_number': u'WS3718350232', # 'model': None}, # {'description': None, 'parent': u'Chassis', 'model_number': None, # 'module': u'Pseudo CB 0', 'version': None, 'serial_number': None, # 'model': None}, {'description': u'RE-QFX5110-48S-4C', # 'parent': u'Chassis', # 'model_number': u'QFX5110-48S-AFI', # 'module': u'Routing Engine 0', # 'version': None, 'serial_number': u'BUILTIN', 'model': None}, # {'description': u'QFX5110-48S-4C', 'parent': u'Chassis', # 'model_number': u'QFX5110-48S-AFI', 'module': u'FPC 0', # 'version': u'REV 26', ' # serial_number': u'WS3718350232', 'model': None}, # {'description': u'FPC CPU', 'parent': u'FPC 0', 'model_number': # None, 'module': u'CPU', # 'version': None, 'serial_number': u'BUILTIN', 'model': None}, # {'description': u'48x10G-4x100G', 'parent': u'FPC 0', # 'model_number': u'QFX5110-48S-AFI', 'module': u'PIC 0', # 'version': None, 'serial_number': u'BUILTIN', 'model': None}, # {'description': u'SFP+-10G-CU2M', 'parent': u'PIC 0', # 'model_number': None, 'module': u'Xcvr 0', 'version': None, # 'serial_number': u'APF164800484VC', 'model': None}, # {'description': u'SFP+-10G-CU2M', 'parent': u'PIC 0', # 'model_number': None, 'module': u'Xcvr 45', 'version': None, # 'serial_number': u'APF164900493E7', 'model': None}, # {'description': u'SFP+-10G-CU2M', 'parent': u'PIC 0', # 'model_number': None, 'module': u'Xcvr 46', 'version': None, # 'serial_number': u'APF18220040FVH', 'model': None} # } :return: Dictionary # if success, returns # { # 'status': 'success', # 'hardware_inventory_import_log': # <String: hardware_inventory_import_log>, # 'hardware_inventory_import_resp': <Dictionary: # hardware_inventory_import_resp> # } # if failure, returns # { # 'status': 'failure', # 'error_msg': <String: exception message>, # 'hardware_inventory_import_log': # <String: hardware_inventory_import_log>, # 'hardware_inventory_import_resp': # <Dictionary: hardware_inventory_import_resp> # } """ self._instantiate_filter_log_instance(prouter_name) _task_log("Starting Hardware Inventory Import") try: _task_log("Creating hardware inventory object") hardware_inventory_import_resp = \ self._create_hardware_inventory( job_ctx, hardware_inventory_payload, prouter_name, pr_product_name, prouter_vendor ) _task_done() return { 'status': 'success', 'hardware_inventory_import_log': FilterLog.instance().dump(), 'hardware_inventory_import_resp': hardware_inventory_import_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return { 'status': 'failure', 'error_msg': str(ex), 'hardware_inventory_import_log': FilterLog.instance().dump()}
def update_physical_router(self, job_ctx, prouter_name, obj_dict_payload, prouter_vendor): """ :param job_ctx: Dictionary example: { "auth_token": "EB9ABC546F98", "job_input": { "fabric_fq_name": [ "default-global-system-config", "fab01" ], "device_auth": [{ "username": "******", "password": "******" }] } } :param prouter_name: String example: "5c3-qfx8" :param obj_dict_payload: Dictionary example: { "physical_router_dataplane_ip": "10.0.0.2", "physical_router_loopback_ip": "10.0.0.2", "fq_name": ["default-global-system-config","5c3-qfx8"], "physical_router_os_version": "srx-20.65", "additional_properties": { 'Some Key that needs to be tapped': 'Some random annotations spec. to this vendor' } } :param prouter_vendor: String example: "juniper" :return: Dictionary if success, returns { 'status': 'success', 'upd_pr_log': <String: upd_pr_log>, 'physical_router_upd_resp': <Dictionary: physical_router_upd_resp> } if failure, returns { 'status': 'failure', 'error_msg': <String: exception message>, 'upd_pr_log': <String: upd_pr_log> } :param physical_router_upd_resp: Dictionary example: { "job_log_msg": <String: job log message>, "warning_info": <Dictionary: warning_info> } """ FilterLog.instance("UpdatePhysicalRouterFilter", prouter_name) _task_log("Starting Device Update") try: _task_log("Creating vnc handle") self.vnc_lib = JobVncApi.vnc_init(job_ctx) _task_log("Parsing additional physical router properties") FilterModule._parse_additional_prop_and_upd_payload( obj_dict_payload, prouter_vendor) _task_log("Updating the physical router") physical_router_upd_resp = \ self._update_physical_router_object( obj_dict_payload, prouter_name ) _task_done() return { 'status': 'success', 'upd_pr_log': FilterLog.instance().dump(), 'physical_router_upd_resp': physical_router_upd_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return {'status': 'failure', 'error_msg': str(ex), 'upd_pr_log': FilterLog.instance().dump() }
def device_import(self, job_ctx, prouter_name, interfaces_payload): """ :param job_ctx: Dictionary. example: { "auth_token": "EB9ABC546F98", "job_input": { "fabric_fq_name": [ "default-global-system-config", "fab01" ], "device_auth": [{ "username": "******", "password": "******" }], "management_subnets": [ { "cidr": "10.87.69.0/25", "gateway": "10.87.69.1" } ], "overlay_ibgp_asn": 64512, "node_profiles": [ { "node_profile_name": "juniper-qfx5k" } ] } } :param prouter_name: String example: "5c3-qfx8" :param interfaces_payload: Dictionary example: { "physical_interfaces_list": [ { "physical_interface_port_id": "526", "physical_interface_mac_address": "00:11:22:33:44:55", "physical_interface_name": "xe-0/0/1:0" } ], "logical_interfaces_list": [ { "logical_interface_name": "xe-0/0/1:0.236", "logical_interface_type": "l3", "logical_interface_vlan_tag": "1213" } ] } :return: Dictionary if success, returns { 'status': 'success', 'device_import_log': <String: device_import_log>, 'device_import_resp': <Dictionary: device_import_resp> } if failure, returns { 'status': 'failure', 'error_msg': <String: exception message>, 'device_import_log': <String: device_import_log>, 'device_import_resp': <Dictionary: device_import_resp> } :param device_import_resp: Dictionary example: { "phy_intfs_success_names": <List: <String: phy_intfs_success_name> >, "log_intfs_success_names": <List: <String: log_intfs_success_name> >, "phy_intf_failed_info": <List: <Dictionary: phy_intf_failed_object> >, "log_intf_failed_info": <List: <Dictionary: log_intf_failed_object> > } """ self._instantiate_filter_log_instance(prouter_name) _task_log("Starting Device Import") device_import_resp = {} try: _task_log("Creating interfaces") device_import_resp = \ self._create_interfaces( job_ctx, interfaces_payload, prouter_name ) _task_done() if device_import_resp.get('phy_intf_failed_info') or \ device_import_resp.get('log_intf_failed_info'): raise Exception( "Create or Update physical or logical interfaces failed") return { 'status': 'success', 'device_import_log': FilterLog.instance().dump(), 'device_import_resp': device_import_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return {'status': 'failure', 'error_msg': str(ex), 'device_import_log': FilterLog.instance().dump(), 'device_import_resp': device_import_resp}
def import_lldp_info(self, job_ctx, prouter_fqname, prouter_vendor, lldp_neighbors_payload): """Topology discovery. :param job_ctx: Dictionary # example: # { # "auth_token": "EB9ABC546F98", # "job_input": { # "fabric_fq_name": [ # "default-global-system-config", # "fab01" # ], # "device_auth": [{ # "username": "******", # "password": "******" # }], # "management_subnets": [ # { # "cidr": "10.87.69.0/25", # "gateway": "10.87.69.1" # } # ], # "overlay_ibgp_asn": 64512, # "node_profiles": [ # { # "node_profile_name": "juniper-qfx5k" # } # ] # } # } :param prouter_fqname: List example: # [ # "default-global-system-config", # "5c3-qfx2" # ] :param prouter_vendor: String example: "juniper" :param lldp_neighbors_payload: Dictionary # example: # { # "neighbor_info_list": # [ # { # "local_physical_interface_name": "xe-0/0/0", # "remote_device_name": "5b5-qfx11", # "remote_physical_interface_port_id": "536" # }, # { # "local_physical_interface_name": "xe-0/0/2", # "remote_device_chassis_id": "00:1a:53:46:7b:9e", # "remote_physical_interface_port_id": "538" # } # ] # } :return: Dictionary # if success, returns # { # 'status': 'success', # 'topology_discovery_log': # <String: topology_discovery_log>, # 'topology_discovery_resp': # <Dictionary: topology_discovery_resp> # } # if failure, returns # { # 'status': 'failure', # 'error_msg': <String: exception message>, # 'topology_discovery_log': # <String: topology_discovery_log>, # 'topology_discovery_resp': # <Dictionary: topology_discovery_resp> # } :param topology_discovery_resp: Dictionary # example: # { # "lldp_neighbors_success_names": # <List: <String: lldp_neighbors_success_pair_string>>, # "lldp_neighbors_failed_info": # <List: <Dictionary: lldp_neighbor_failed_obj> > # } # :param lldp_neighbors_success_names: List # example: # ["bng-contrail-qfx51-15 : ge-0/0/36 --> dhawan : ge-2/3/1"] # :param lldp_neighbors_failed_info: List # example: # [ # { # "lldp_neighbor": # "bng-contrail-qfx51-15 : em0 --> sw174 : ge-1/0/46", # "warning_message": # "Unknown physical interface ng-contrail-qfx51-15:em0" # } # ] """ self._instantiate_filter_log_instance(prouter_fqname[-1]) _task_log("Starting Topology Discovery") try: _task_log("Creating neighboring links") topology_discovery_resp = self._create_neighbor_links( job_ctx, lldp_neighbors_payload, prouter_fqname, prouter_vendor) _task_done() return { 'status': 'success', 'topology_discovery_log': FilterLog.instance().dump(), 'topology_discovery_resp': topology_discovery_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return { 'status': 'failure', 'error_msg': str(ex), 'topology_discovery_log': FilterLog.instance().dump() }
def import_chassis_info(self, job_ctx, prouter_name, chassis_payload, prouter_vendor): """Import chassis Mac. :param job_ctx: Dictionary # example: # { # "auth_token": "EB9ABC546F98", # "job_input": { # "fabric_fq_name": [ # "default-global-system-config", # "fab01" # ], # "device_auth": [{ # "username": "******", # "password": "******" # }], # "management_subnets": [ # { # "cidr": "10.87.69.0/25", # "gateway": "10.87.69.1" # } # ], # "overlay_ibgp_asn": 64512, # "node_profiles": [ # { # "node_profile_name": "juniper-qfx5k" # } # ] # } # } :param prouter_name: String example: "5c3-qfx8" :param prouter_vendor: String example: "juniper" :param chassis_payload: Dictionary # example: # { # "device_chassis_id_info": [ # { # "device_chassis_id": "00:11:22:33:44:55", # "chassis_id_type": "private" # } # ] # } :return: Dictionary # if success, returns # { # 'status': 'success', # 'chassis_import_log': <String: chassis_import_log>, # 'chassis_import_resp': <Dictionary: chassis_import_resp> # } # if failure, returns # { # 'status': 'failure', # 'error_msg': <String: exception message>, # 'chassis_import_log': <String: chassis_import_log> # } :param chassis_import_resp: Dictionary # example: # { # "chassis_mac_ids": # <List: <String: chassis_mac_id> >, # "warning_info": <List: warn_info> # } """ self._instantiate_filter_log_instance(prouter_name) _task_log("Starting Chassis Info Import") try: chassis_vnc_payloads = self.get_vnc_chassis_payloads( chassis_payload.get('device_chassis_id_info'), prouter_vendor ) chassis_import_resp = self._import_chassis_info( job_ctx, chassis_vnc_payloads, prouter_name, prouter_vendor ) _task_done() return { 'status': 'success', 'chassis_import_log': FilterLog.instance().dump(), 'chassis_import_resp': chassis_import_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return {'status': 'failure', 'error_msg': str(ex), 'chassis_import_log': FilterLog.instance().dump()}
def _import_chassis_info(self, job_ctx, chassis_payload, prouter_name, prouter_vendor): warning_info = [] chassis_mac_ids = [] chassis_mac_fqnames = [] object_type = "device_chassis" vnc_lib = JobVncApi.vnc_init(job_ctx) # try to create device_chassis objects from chassis_payload for chassis_info in chassis_payload: chassis_mac_fqname = chassis_info.get('fq_name') chassis_mac_id = chassis_mac_fqname[-1].split( prouter_vendor + '_')[1].replace('_', ':') try: try: cls = JobVncApi.get_vnc_cls(object_type) chassis_obj = cls.from_dict(**chassis_info) existing_obj = vnc_lib.device_chassis_read( fq_name=chassis_mac_fqname) existing_obj_dict = vnc_lib.obj_to_dict(existing_obj) for key in chassis_info: to_be_upd_value = chassis_info[key] existing_value = existing_obj_dict.get(key) if to_be_upd_value != existing_value: vnc_lib.device_chassis_update( chassis_obj) break chassis_mac_fqnames.append( chassis_mac_fqname) chassis_mac_ids.append( chassis_mac_id ) except NoIdError: vnc_lib.device_chassis_create(chassis_obj) chassis_mac_fqnames.append( chassis_mac_fqname) chassis_mac_ids.append( chassis_mac_id ) except Exception as exc: _task_error_log(str(exc)) _task_error_log(traceback.format_exc()) warn_info = dict() warn_info['failed_operation'] = 'Device Chassis Creation' warn_info['failure_message'] = 'Error while creating' \ 'chassis_id(' + \ chassis_mac_id + \ ') for ' + prouter_vendor + \ ' device: ' + str(exc) warning_info.append(warn_info) # Now try to link all the created chassis objects as references # to this prouter object_type = "physical_router" device_chassis_ref_list = [] for chassis_fqname in chassis_mac_fqnames: device_chassis_ref_list.append( {'to': chassis_fqname} ) try: pr_dict = { 'fq_name': ['default-global-system-config', prouter_name] } cls = JobVncApi.get_vnc_cls(object_type) physical_router_obj = cls.from_dict(**pr_dict) physical_router_obj.set_device_chassis_list( device_chassis_ref_list) vnc_lib.physical_router_update(physical_router_obj) except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) warn_info = dict() warn_info['failed_operation'] = 'Physical Router Updation' warn_info['failure_message'] = 'Error while updating' \ 'chassis_ids refs for ' + \ prouter_vendor + ' device ' + \ prouter_name + ': ' + str(ex) warning_info.append(warn_info) return \ { 'chassis_mac_ids': chassis_mac_ids, 'warning_info': warning_info }
def discover_role(self, job_ctx, prouter_name, prouter_uuid, prouter_vendor_name, prouter_product_name): node_profile_refs = [] try: FilterLog.instance("DiscoverRoleFilter", prouter_name) FilterModule._validate_job_ctx(job_ctx) fabric_fqname = job_ctx.get('fabric_fqname') vnc_lib = JobVncApi.vnc_init(job_ctx) # form the hardware fqname from prouter_vendor_name and # prouter_product_name hw_fq_name = [ (prouter_vendor_name + '-' + prouter_product_name).lower() ] # read the hardware object with this fq_name _task_log("Reading the hardware object") try: hw_obj = vnc_lib.hardware_read(fq_name=hw_fq_name) except NoIdError as no_id_exc: _task_log("\nHardware Object not present in " "database: " + str(no_id_exc)) traceback.print_exc(file=sys.stdout) _task_log("Completing role discovery for device") _task_done() return { 'status': 'success', 'fabric_fqname': fabric_fqname, 'np_refs': node_profile_refs, 'device_name': prouter_name, 'role_discovery_log': FilterLog.instance().dump() } _task_done() # get all the node-profile back-refs for this hardware object _task_log("Getting all the node-profile back refs" \ " for the hardware: %s" % hw_fq_name[-1]) np_back_refs = hw_obj.get_node_profile_back_refs() or [] _task_done() # get the fabric object fq_name to check if the node-profile # is in the same fabric _task_log("Fetching the fabric fq_name") fab_fq_name = fabric_fqname.split(":") _task_done() # read the fabric_object to get a list of node-profiles under # this fabric_object _task_log("Reading the fabric object") fabric_obj = vnc_lib.fabric_read(fq_name=fab_fq_name) _task_done() # get the list of node profile_uuids under the given fabric _task_log("Getting the list of node-profile-uuids" \ " under this fabric object .... ") node_profiles_list = fabric_obj.get_node_profile_refs() or [] node_profile_obj_uuid_list = self._get_object_uuid_list( node_profiles_list) _task_done() # check to see which of the node-profile back refs are in the # present fabric. Assumption: at present there is only a single # node-profile that can match a hardware under the current # given fabric _task_log("Checking to see if any node-profile" \ " is under given fabric .... \n") upd_resp, node_profile_refs = self._do_role_discovery( np_back_refs, prouter_name, vnc_lib, prouter_uuid, node_profile_obj_uuid_list) _task_log(upd_resp + "\n") _task_done() return { 'status': 'success', 'np_refs': node_profile_refs, 'fabric_fqname': fabric_fqname, 'device_name': prouter_name, 'role_discovery_log': FilterLog.instance().dump() } except NoIdError as no_id_exc: _task_error_log("Object not present in database: " + str(no_id_exc)) traceback.print_exc(file=sys.stdout) return { 'status': 'failure', 'error_msg': str(no_id_exc), 'role_discovery_log': FilterLog.instance().dump() } except Exception as ex: _task_error_log(str(ex)) traceback.print_exc(file=sys.stdout) return { 'status': 'failure', 'error_msg': str(ex), 'role_discovery_log': FilterLog.instance().dump() }
def discover_role(self, job_ctx, prouter_name, prouter_uuid, prouter_vendor_name, prouter_product_name): node_profile_refs = [] try: FilterLog.instance("DiscoverRoleFilter", prouter_name) FilterModule._validate_job_ctx(job_ctx) fabric_fqname = job_ctx.get('fabric_fqname') vnc_lib = JobVncApi.vnc_init(job_ctx) # form the hardware fqname from prouter_vendor_name and # prouter_product_name hw_fq_name = [(prouter_vendor_name + '-' + prouter_product_name ).lower()] # read the hardware object with this fq_name _task_log("Reading the hardware object") try: hw_obj = vnc_lib.hardware_read(fq_name=hw_fq_name) except NoIdError as no_id_exc: _task_log("\nHardware Object not present in " "database: " + str(no_id_exc)) traceback.print_exc(file=sys.stdout) _task_log("Completing role discovery for device") _task_done() return { 'status': 'success', 'fabric_fqname': fabric_fqname, 'np_refs': node_profile_refs, 'device_name': prouter_name, 'role_discovery_log': FilterLog.instance().dump() } _task_done() # get all the node-profile back-refs for this hardware object _task_log("Getting all the node-profile back refs" \ " for the hardware: %s" % hw_fq_name[-1]) np_back_refs = hw_obj.get_node_profile_back_refs() or [] _task_done() # get the fabric object fq_name to check if the node-profile # is in the same fabric _task_log("Fetching the fabric fq_name") fab_fq_name = fabric_fqname.split(":") _task_done() # read the fabric_object to get a list of node-profiles under # this fabric_object _task_log("Reading the fabric object") fabric_obj = vnc_lib.fabric_read(fq_name=fab_fq_name) _task_done() # get the list of node profile_uuids under the given fabric _task_log("Getting the list of node-profile-uuids" \ " under this fabric object .... ") node_profiles_list = fabric_obj.get_node_profile_refs() or [] node_profile_obj_uuid_list = self._get_object_uuid_list( node_profiles_list) _task_done() # check to see which of the node-profile back refs are in the # present fabric. Assumption: at present there is only a single # node-profile that can match a hardware under the current # given fabric _task_log("Checking to see if any node-profile" \ " is under given fabric .... \n") upd_resp, node_profile_refs = self._do_role_discovery( np_back_refs, prouter_name, vnc_lib, prouter_uuid, node_profile_obj_uuid_list) _task_log(upd_resp + "\n") _task_done() return { 'status': 'success', 'np_refs': node_profile_refs, 'fabric_fqname': fabric_fqname, 'device_name': prouter_name, 'role_discovery_log': FilterLog.instance().dump() } except NoIdError as no_id_exc: _task_error_log("Object not present in database: " + str(no_id_exc)) traceback.print_exc(file=sys.stdout) return { 'status': 'failure', 'error_msg': str(no_id_exc), 'role_discovery_log': FilterLog.instance().dump() } except Exception as ex: _task_error_log(str(ex)) traceback.print_exc(file=sys.stdout) return { 'status': 'failure', 'error_msg': str(ex), 'role_discovery_log': FilterLog.instance().dump() }
def device_import(self, job_ctx, prouter_name, interfaces_payload): """ :param job_ctx: Dictionary example: { "auth_token": "EB9ABC546F98", "job_input": { "fabric_fq_name": [ "default-global-system-config", "fab01" ], "device_auth": [{ "username": "******", "password": "******" }], "management_subnets": [ { "cidr": "10.87.69.0/25", "gateway": "10.87.69.1" } ], "overlay_ibgp_asn": 64512, "node_profiles": [ { "node_profile_name": "juniper-qfx5k" } ] } } :param prouter_name: String example: "5c3-qfx8" :param interfaces_payload: Dictionary example: { "physical_interfaces_list": [ { "physical_interface_port_id": "526", "physical_interface_mac_address": "00:11:22:33:44:55", "physical_interface_name": "xe-0/0/1:0" } ], "logical_interfaces_list": [ { "logical_interface_name": "xe-0/0/1:0.236", "logical_interface_type": "l3", "logical_interface_vlan_tag": "1213" } ], "dataplane_ip": "10.0.0.2" } :return: Dictionary if success, returns { 'status': 'success', 'device_import_log': <String: device_import_log>, 'device_import_resp': <Dictionary: device_import_resp> } if failure, returns { 'status': 'failure', 'error_msg': <String: exception message>, 'device_import_log': <String: device_import_log>, 'device_import_resp': <Dictionary: device_import_resp> } :param device_import_resp: Dictionary example: { "phy_intfs_success_names": <List: <String: phy_intfs_success_name> >, "log_intfs_success_names": <List: <String: log_intfs_success_name> >, "phy_intf_failed_info": <List: <Dictionary: phy_intf_failed_object> >, "log_intf_failed_info": <List: <Dictionary: log_intf_failed_object> >, "dataplane_ip": <String: dataplane_ip>, "dataplane_ip_upd_resp": <String: dataplane_ip_upd_resp>, "warning_info": <Dictionary: warning_info> } """ self._instantiate_filter_log_instance(prouter_name) _task_log("Starting Device Import") device_import_resp = {} try: _task_log("Creating interfaces") device_import_resp = \ self._create_interfaces_and_update_dataplane_ip( job_ctx, interfaces_payload, prouter_name ) _task_done() if device_import_resp.get('phy_intf_failed_info') or \ device_import_resp.get('log_intf_failed_info'): raise Exception( "Create or Update physical or logical interfaces failed") return { 'status': 'success', 'device_import_log': FilterLog.instance().dump(), 'device_import_resp': device_import_resp } except Exception as ex: _task_error_log(str(ex)) _task_error_log(traceback.format_exc()) return {'status': 'failure', 'error_msg': str(ex), 'device_import_log': FilterLog.instance().dump(), 'device_import_resp': device_import_resp }