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
}
