def update_asynchronous_task_details(details: str): """ Update Asynchronous Task details. Print task details during Process execution. Parameters ---------- detail: String The message to display in msa-ui Returns ------- object: Orchestration """ context = Variables.task_call() process_instance_id = context['PROCESSINSTANCEID'] task_id = context['TASKID'] exec_number = context['EXECNUMBER'] orch = Orchestration(None) orch.update_asynchronous_task_details(process_instance_id, task_id, exec_number, details) return orch
#Variables to finish the task properlly fail_comment = str() success_comment = str() fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create IPAM order object IpamOrderObject = Order(ipam_device_id) IpamOrderObject.command_synchronize(300) Orchestration.update_asynchronous_task_details( *async_update_list, 'Retrieve information about CE device on the site... ') objects_list = IpamOrderObject.command_objects_instances(ms_ipam_device) #Retrieve information about CE device what is located on the site counter = 0 ce_device_id = None ce_device_name = None #Find CE device name first while ce_device_name is None or counter < len(objects_list): device_object = IpamOrderObject.command_objects_instances_by_id( ms_ipam_device, objects_list[counter])[ms_ipam_device][objects_list[counter]] if device_object['role'] == 'CE' and device_object['site'] == site: ce_device_name = device_object['object_id']
async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create IPAM order object IpamOrderObject = Order(ipam_device_id) IpamOrderObject.command_synchronize(300) objects_list = IpamOrderObject.command_objects_instances(ms_ipam_device) #Retrieve information about CE device what is located on the site counter = 0 ce_device_id = None ce_device_name = None #Find CE device name Orchestration.update_asynchronous_task_details( *async_update_list, 'Retrieve information about CE device on the site... ') while ce_device_name is None or counter < len(objects_list): util.log_to_process_file( process_id, 'DEBUG: {}'.format( IpamOrderObject.command_objects_instances_by_id( ms_ipam_device, objects_list[counter]))) device_object = IpamOrderObject.command_objects_instances_by_id( ms_ipam_device, objects_list[counter])[ms_ipam_device][objects_list[counter]] if device_object['role'] == 'CE' and device_object['site'] == site: ce_device_name = device_object['object_id'] counter += 1 #Find device ID value MsaLookup = lookup.Lookup() MsaLookup.look_list_device_ids()
fail_comment = str() success_comment = str() fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create order object IpamOrderObject = Order(ipam_device_id) IpamOrderObject.command_synchronize(300) #Retrieve info about tenants Orchestration.update_asynchronous_task_details(*async_update_list, 'Retrieving information about customer... ') objects_list = IpamOrderObject.command_objects_instances(ms_ipam_tenant) #Check if customer exists in IPAM system does_tenant_exists = False counter = 0 while not does_tenant_exists and counter < len(objects_list): tenant_object = IpamOrderObject.command_objects_instances_by_id(ms_ipam_tenant, objects_list[counter])[ms_ipam_tenant][objects_list[counter]] if tenant_object['object_id'] == customer_name: does_tenant_exists = True customer_id = tenant_object['id'] counter += 1 #If the customer does not exist in IPAM system, finish the task as fail if not does_tenant_exists:
print(ret) exit() # (1) prepare data for k8s_pre_requirements microservice k8s_pre_requirements_data = {"object_id": "123"} k8s_pre_requirements_ms = { "k8s_pre_requirements": { "123": k8s_pre_requirements_data } } device_list = context['vm_id_list_new'] # deploy required packages for me in device_list: Orchestration.update_asynchronous_task_details( *async_update_list, f'k8s software installation: \ {Device(device_id=me).name}' ) try: order = Order(me) order.command_execute('CREATE', k8s_pre_requirements_ms, timeout=300) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret) ret = MSA_API.process_content('ENDED', f'K8S software installed on {device_list}.', context, True) print(ret)
customer_id=re.match('^\D+?(\d+?)$', context['UBIQUBEID']).group(1), name='{}[{}]'.format(context['hostname'], context['ip_address']), device_external=re.sub(r'[\.\[\]-]', "_", context['hostname']), manufacturer_id=nec_ipasolink_manufacture_id, password_admin=nec_ipasolink_default_password, model_id=nec_ipasolink_model_id, login=nec_ipasolink_default_username, password=nec_ipasolink_default_password, management_address=context['ip_address'], management_port='22') StationDeviceObject.create() pretty_formatted_bar = list('-' * 12) Orchestration.update_asynchronous_task_details( *async_update_list, 'Creating managed entity for the station... [{}]'.format( ''.join(pretty_formatted_bar))) #Provision device StationDeviceObject.initial_provisioning() #Create station device order object context['station_device_id'] = StationDeviceObject.device_id StationOrderObject = Order(context['station_device_id']) #Wait until provisioning is done while StationDeviceObject.provision_status()['status'] != 'OK': pretty_formatted_bar.insert(0, '*') Orchestration.update_asynchronous_task_details( *async_update_list, 'Creating managed entity for the station... [{}]'.format(
def info_message(text, timeout=1): Orchestration.update_asynchronous_task_details(*async_update_list, text) time.sleep(timeout)
for me in device_list: if me['name'] == context['vm_name'] + '-1': master_id = me['id'] elif me['name'] == context['vm_name'] + '-2': backup_id = me['id'] # (1) kubeadm init on master first # stub here - actually k8s master nodes should be selected according to the user input k8s_kubeadm_init_data = { "object_id": "123", "lb_ip": list(context['vms'][2].values())[0]['internal'], "lb_port": "6443", } k8s_kubeadm_init_ms = {"k8s_kubeadm_init": {"123": k8s_kubeadm_init_data}} Orchestration.update_asynchronous_task_details(*async_update_list, f'k8s-node-1: Provisioning') try: order = Order(str(master_id)) order.command_execute('CREATE', k8s_kubeadm_init_ms, timeout=400) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret) Orchestration.update_asynchronous_task_details( *async_update_list, f'Master Initiated: k8s-node-1') # (2) get params from master first # k8s_get_token k8s_get_token = {'k8s_get_token': {'': {'object_id': 'kubeamd'}}} try:
fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create order object IpamOrderObject = Order(ipam_device_id) #Find site ID objects_list = IpamOrderObject.command_objects_instances(ms_ipam_site) #Looking for CE device in STAGED state on the site Orchestration.update_asynchronous_task_details(*async_update_list, 'Looking for CE device on site {} in "staged" state... '.format(site)) #Collect cusromer sites object_id for future use for site in objects_list: site_object = IpamOrderObject.command_objects_instances_by_id(ms_ipam_site, site)[ms_ipam_site][site] if site_object['object_id'] == site: context['site_id'] = site_object['id'] #Find all devices on the site site_device_list = list() for device in context['customer_details']['devices_list']: device_object = IpamOrderObject.command_objects_instances_by_id(ms_ipam_device, device)[ms_ipam_device][device] try: if device_object['site'] == context['site']:
from msa_sdk.order import Order from msa_sdk.msa_api import MSA_API dev_var = Variables() context = Variables.task_call() Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) device_id = context['k8s_api'][3:] k8_pods_list = {'k8_pods_list': {'': {'object_id': ''}}} try: Orchestration.update_asynchronous_task_details(*async_update_list, f'Sync in progress...') order = Order(str(device_id)) order.command_synchronize(timeout=60) Orchestration.update_asynchronous_task_details(*async_update_list, f'Syncronized.') time.sleep(2) Orchestration.update_asynchronous_task_details(*async_update_list, f'Check in progress...') order.command_execute('IMPORT', k8_pods_list) data = json.loads(order.content) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret) if 'message' in data.keys(): container_list = json.loads(data['message'])['k8_pods_list'].keys()
fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) IpamOrderObject = Order(ipam_device_id) #Create CE device order object CeOrderObject = Order(ce_device_id) response = CeOrderObject.command_synchronize(300) pe_order_list = list() Orchestration.update_asynchronous_task_details(*async_update_list, 'Configuring CE device... ') for interface, connection in ce_connections.items(): Orchestration.update_asynchronous_task_details( *async_update_list, 'Configuring CE device... IP address on link toward {}... '.format( connection['neighbour']['device'])) #Create oreder object for PE pe_order_list.append(Order(connection['neighbour']['device_id'])) response = pe_order_list[-1].command_synchronize(300) #Configure IP address on CE link ms_dict = { ms_router_interface: { interface: { 'object_id': interface,
for me in device_list: if me['name'] == context['vm_name'] + '-1': master_prim = me['id'] for item in range(start, stop): if me['name'] == context['vm_name'] + '-' + str(item): msa_rm_vm.append(me['id']) # (1) drain and remove node from k8s cluster # primary master hardcoded try: for item in range(start, stop): node_name = context['vm_name'] + '-' + str(item) Orchestration.update_asynchronous_task_details( *async_update_list, f'Removing {node_name} from k8s cluster...') del_worker_me(str(master_prim), node_name) Orchestration.update_asynchronous_task_details( *async_update_list, f'{node_name} removed from k8s cluster.') except Exception as e: ret = MSA_API.process_content('WARNING', f'ERROR: {str(e)}', context, True) print(ret) # (2) remove from Azure try: one = AZDelete(client_id=context['client_id'],
'Station Ethernet port VLAN configuration'] ms_hostname = context['ms_aliases']['Station hostname'] ms_port_settings = context['ms_aliases']['Station Ethernet port settings'] #Variables to finish the task properlly fail_comment = str() success_comment = str() fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) Orchestration.update_asynchronous_task_details( *async_update_list, 'Import current configuration... ') #Create Station device order object StationOrderObject = Order(context['station_device_id']) response = StationOrderObject.command_synchronize(300) Orchestration.update_asynchronous_task_details( *async_update_list, 'Import current configuration... OK') time.sleep(3) #Check VLAN IDs Orchestration.update_asynchronous_task_details(*async_update_list, 'Verifying VLANs... ') objects_list = StationOrderObject.command_objects_instances(ms_vlan) do_vlans_exist = list() for number, vlan in context['vlan_list'].items(): Orchestration.update_asynchronous_task_details(
#Variables to finish the task properlly fail_comment = str() success_comment = str() fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create VLAN list if IPAM is used if context['use_ipam'] == 'yes': Orchestration.update_asynchronous_task_details( *async_update_list, 'IPAM integration is used. Retrive VLAN info from IPAM... ') context['ipam_device'] = re.match('^\D+?(\d+?)$', context['ipam_device']).group(1) #Retrive information about VLANs IpamOrderObject = Order(context['ipam_device']) IpamOrderObject.command_synchronize(300) objects_list = IpamOrderObject.command_objects_instances(ms_ipam_vlan) vlan_string = str() counter = 0 context['vlan_list'] = dict() for vlan_name in objects_list: vlan_object = IpamOrderObject.command_objects_instances_by_id( ms_ipam_vlan, vlan_name)[ms_ipam_vlan][vlan_name]
manufacturer_id="20060101", model_id="20060101", login="******", password="******", password_admin="admin", management_address=k8s_api_ip) entity.create() except Exception as e: ret = MSA_API.process_content('WARNING', f'Can\'t call device {me_id} : {str(e)}', context, True) print(ret) exit() Orchestration.update_asynchronous_task_details(*async_update_list, f'K8S API ME CREATED...') time.sleep(2) # set k8s specific parameters try: three.set_params(str(entity.device_id), 'KUBE_TOKEN', k8s_token) three.set_params(str(entity.device_id), 'KUBE_AUTH_METHOD', 'KUBERNETES') three.set_params(str(entity.device_id), 'KUBE_HTTP_PROTOCOL', 'https') three.set_params(str(entity.device_id), 'KUBE_PORT', '6443') except Exception as e: ret = MSA_API.process_content('WARNING', f'Can\'t set custom params {me_id} : {str(e)}', context, True) print(ret) exit()
} # stub here - actually k8s master nodes should be selected according to the user input k8s_ha_proxy_data = { "object_id": "123", "k8s_m_1_ip": list(context['vms'][0].values())[0]['internal'], "k8s_m_2_ip": list(context['vms'][1].values())[0]['internal'], } k8s_ha_proxy_ms = {"k8s_ha_proxy": {"123": k8s_ha_proxy_data}} # (2) get short ME id me_id = context['proxy_host'][3:] # (3) install package on certain me Orchestration.update_asynchronous_task_details( *async_update_list, f'haproxy installation: {Device(device_id=me_id).name}') try: order = Order(me_id) order.command_execute('CREATE', k8s_package_management_ms, timeout=300) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret) time.sleep(10) # (4) configure and start proxy try: order = Order(me_id) order.command_execute('CREATE', k8s_ha_proxy_ms) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret)
fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #IPAM order object IpamOrderObject = Order(ipam_device_id) #Create CE device object CeDeviceObject = Device(device_id = ce_device_id, device_external = ce_device_external_reference) pretty_formatted_bar = list('------------------------') Orchestration.update_asynchronous_task_details(*async_update_list, 'Provisioning of CE device... [{}]'.format(''.join(pretty_formatted_bar))) #If the device mgmt interface is REST-based, add required configuration variables if 'rest' in ce_local_context['interface'].lower(): for variable, value in ce_local_context['msa_specific']['rest_headers'].items(): CeDeviceObject.create_configuration_variable(name = variable, value = value) #Provision device CeDeviceObject.initial_provisioning() #Wait until provisioning is done while CeDeviceObject.provision_status()['status'] != 'OK': pretty_formatted_bar.insert(0,'*') Orchestration.update_asynchronous_task_details(*async_update_list, 'Provisioning of CE device... [{}]'.format(''.join(pretty_formatted_bar))) time.sleep(10)
success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) IpamOrderObject = Order(ipam_device_id) #Create CE device order object CeOrderObject = Order(ce_device_id) response = CeOrderObject.command_synchronize(300) pe_order_list = list() #Remove IP addresses from CE-PE links Orchestration.update_asynchronous_task_details(*async_update_list, 'Configuring CE device... ') for interface, connection in ce_connections.items(): #Create oreder object for PE pe_order_list.append(Order(connection['neighbour']['device_id'])) response = pe_order_list[-1].command_synchronize(300) Orchestration.update_asynchronous_task_details( *async_update_list, 'Configuring CE device... Clean up IP address on link toward {}... '. format(connection['neighbour']['device'])) #Clean up IP address on CE link ms_dict = {ms_router_interface: {interface: {'object_id': interface}}} CeOrderObject.command_execute('UPDATE', ms_dict) Orchestration.update_asynchronous_task_details( *async_update_list,
manufacturer_id="14020601", model_id="19112020", login=context['vm_username'], password=context['vm_secret'], password_admin=context['vm_secret'], management_address=list(vm.values())[0]['external']) entity.create() time.sleep(2) vm_id_list.append(str(entity.device_id)) # assign deployment setting entity.profile_switch(context['dpl_linux'], context['dpl_linux']) time.sleep(2) entity.activate() Orchestration.update_asynchronous_task_details(*async_update_list, f'MEs created - Activating...') # check if ME is ready to be configured by veryfing asset counter = 0 try: two = MSAConnect(context['msa_fqdn'], context['msa_user'], context['msa_pass']) while len(vm_id_list) > 0: for me in vm_id_list: if len(two.get_device_asset(me)['serialNb']) > 1: vm_id_list.remove(me) Orchestration.update_asynchronous_task_details(*async_update_list, f'ME id:{Device(device_id=me).name} = Ready') time.sleep(3)
search = Lookup() search.look_list_device_by_customer_ref(cust_ref) device_list = search.content device_list = json.loads(device_list) worker_id_list = [] master = context['vm_name'] + '-1' backup = context['vm_name'] + '-2' # add all vms that are not k8s masters to the list for me in device_list: if me['name'] != (master and backup): worker_id_list.append(me['id']) # (4) kubeadm loop on workers Orchestration.update_asynchronous_task_details(*async_update_list, f'Worker nodes processing...') for me in worker_id_list: try: order = Order(str(me)) order.command_execute('CREATE', context['k8s_join_worker'], timeout=300) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret) Orchestration.update_asynchronous_task_details(*async_update_list, f'Worker Initiated: {me}') ret = MSA_API.process_content('ENDED', 'K8S cluster ready - Enjoy!', context, True)
if me['name'] == context['vm_name'] + '-1': master_id = me['id'] elif me['name'] == context['vm_name'] + '-2': backup_id = me['id'] elif me['name'] == context['vm_name'] + '-3': lb_id = me['id'] # (1) kubeadm init on master first # stub here - actually k8s master nodes should be selected according to the user input k8s_kubeadm_init_data = { "object_id": "123", "lb_ip": Device(device_id=str(lb_id)).management_address, "lb_port": "6443", } k8s_kubeadm_init_ms = {"k8s_kubeadm_init": {"123": k8s_kubeadm_init_data}} Orchestration.update_asynchronous_task_details(*async_update_list, f'k8s-node-1: Provisioning') ''' # open when master selection option available try: order = Order(str(master_id)) order.command_execute('CREATE', k8s_kubeadm_init_ms, timeout=400) except Exception as e: ret = MSA_API.process_content('FAILED', f'ERROR: {str(e)}', context, True) print(ret) Orchestration.update_asynchronous_task_details(*async_update_list, f'Master Initiated: k8s-node-1') '''
context, True) print(ret) exit() except HTTPError: ret = MSA_API.process_content( 'WARNING', f'AZConnection.vm_create - HTTP Error - Check API', context, True) print(ret) exit() except Exception as e: ret = MSA_API.process_content('FAILED', f'{vm}', context, True) print(ret) exit() Orchestration.update_asynchronous_task_details( *async_update_list, f'VMs have just been STARTED, waiting...') counter = 0 try: while len(vm_id_list) > 0: for id in vm_id_list: status = one.get_resource_status(id, '2020-06-01') if status == 'Succeeded': vm_id_list.remove(id) Orchestration.update_asynchronous_task_details( *async_update_list, f'{id[-10:]} = {status}') time.sleep(4) counter = counter + 4 if counter >= 300: break
fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create CE device order object CeOrderObject = Order(ce_device_id) response = CeOrderObject.command_synchronize(300) #Create IPAM order object IpamOrderObject = Order(ipam_device_id) response = IpamOrderObject.command_synchronize(300) Orchestration.update_asynchronous_task_details(*async_update_list, 'Configuring IP address on CE device internal link... ') #Configure IP address on CE internal interface ms_dict = {ms_router_interface: {ce_internal_interface_name: {'object_id': ce_internal_interface_name, 'ip_addr': ce_internal_interface_ip.split('/')[0], 'ip_prefix': ce_internal_interface_ip.split('/')[1] } } } CeOrderObject.command_execute('UPDATE', ms_dict) Orchestration.update_asynchronous_task_details(*async_update_list, 'Configuring IP address on CE device internal link... OK') CeOrderObject.command_synchronize(300) #Configure route filter Orchestration.update_asynchronous_task_details(*async_update_list, 'Configuring route filter for internal prefix... ')
subnet_id = item['id'] return subnet_id if __name__ == "__main__": try: one = AZGetVMs(client_id=context['client_id'], client_secret=context['client_secret'], subscription_id=context['subscription_id'], tenant_id=context['tenant_id'], resource_group=context['resource_group'], location=context['location']) Orchestration.update_asynchronous_task_details( *async_update_list, f'Retrieving last index...') vms = one.get_virtual_machines(context['subscription_id'], context['resource_group']) Orchestration.update_asynchronous_task_details( *async_update_list, f'Retrieving security groups...') sec_group_id = one.get_sec_group(context['subscription_id'], context['resource_group']) Orchestration.update_asynchronous_task_details( *async_update_list, f'Retrieving subnets...') subnet_id = one.get_subnet(context['subscription_id'], context['resource_group'])
tenant_id=context['tenant_id'], resource_group=context['resource_group'], location=context['location']) start = int(context['vm_index']) + 1 stop = start + int(context['scale_lvl']) for i in range(start, stop): ip_name = context['public_ip_name'] + '-' + str(i) + '-ip' fqdn = context['vm_label'] + '-' + str(i) public_ip = one.public_ip_create(public_ip_name=ip_name, vm_label=fqdn) pub_ip_id = public_ip['id'] one.get_status_loop(pub_ip_id, '2020-05-01') status = one.get_resource_status(pub_ip_id, '2020-05-01') Orchestration.update_asynchronous_task_details( *async_update_list, f'{ip_name} = {status}') except ConnectionError: ret = MSA_API.process_content('WARNING', f'Connection Error - Check Internet', context, True) print(ret) exit() except HTTPError: ret = MSA_API.process_content('WARNING', f'HTTP Error - Check API', context, True) print(ret) exit() # need only prefix from any ip address context['pub_ip_id_new'] = pub_ip_id
success_comment = str() fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) #Create IPAM order object IpamOrderObject = Order(ipam_device_id) IpamOrderObject.command_synchronize(300) #Identify ASN for the site and save to context Orchestration.update_asynchronous_task_details(*async_update_list, 'Retrieve AS number for the site... ') site_object = IpamOrderObject.command_objects_instances_by_id(ms_ipam_site, site)[ms_ipam_site][site] context['site_asn'] = site_object['asn'] Orchestration.update_asynchronous_task_details(*async_update_list, 'Retrieve AS number for the site... OK') time.sleep(3) #Identify IPv4 subnets for the site and save to context Orchestration.update_asynchronous_task_details(*async_update_list, 'Find out a IPv4 block for the site... ') context['site_prefixes_list'] = list() objects_list = IpamOrderObject.command_objects_instances(ms_ipam_prefix) for object in objects_list: prefix_object = IpamOrderObject.command_objects_instances_by_id(ms_ipam_prefix,
success_comment = str() fail_string = f'{{"wo_status": "FAIL", "wo_comment": "{fail_comment}"}}' success_string = f'{{"wo_status": "ENDED", "wo_comment": "{success_comment}"}}' #Create Orchestration object to update GUI dynamically Orchestration = Orchestration(context['UBIQUBEID']) async_update_list = (context['PROCESSINSTANCEID'], context['TASKID'], context['EXECNUMBER']) IpamOrderObject = Order(ipam_device_id) IpamOrderObject.command_synchronize(300) #Remove site prefixes for prefix in context['site_prefixes_list']: Orchestration.update_asynchronous_task_details(*async_update_list, 'Remove site {} prefix {} from IPAM... '.format(site, prefix['object_id'])) ms_dict = {ms_ipam_prefix: {prefix['object_id'].replace('.', '_'): {'object_id': prefix['object_id']} } } IpamOrderObject.command_execute('DELETE', ms_dict) Orchestration.update_asynchronous_task_details(*async_update_list, 'Remove site {} prefix {} from IPAM... OK'.format(site, prefix['object_id'])) time.sleep(3) IpamOrderObject.command_synchronize(300) #Remove site IP addresses for ip_address in context['site_address_list']: Orchestration.update_asynchronous_task_details(*async_update_list, 'Remove site {} address {} from IPAM... '.format(site, ip_address['object_id'])) ms_dict = {ms_ipam_address: {ip_address['object_id'].replace('.', '_'): {'object_id': ip_address['object_id']}