def allocate_vdu_task(ks_path, event_id, cloud_account, request_msg): response_xpath = ks_path.to_xpath( RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VDUEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) try: response_info = yield from self._parent.allocate_virtual_compute( event_id, cloud_account, request_msg, ) except Exception as e: self._log.error( "Encountered exception : %s while creating virtual compute", str(e)) response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'failed' yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: if response_info.resource_state == 'failed' or response_info.resource_state == 'active': self._log.info( "Virtual compute create task completed. Publishing VDU info: %s at path: %s", response_info, response_xpath) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: asyncio.ensure_future(monitor_vdu_state( response_xpath, pathentry), loop=self._loop)
def on_link_request_prepare(self, xact_info, action, ks_path, request_msg): if not self._registered: self._log.error("Got a prepare callback when not registered!") xact_info.respond_xpath(rwdts.XactRspCode.NA) return self._log.debug("Received virtual-link on_prepare callback (self: %s, xact_info: %s, action: %s): %s", self, xact_info, action, request_msg) response_info = None response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VirtualLinkEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: response_info = self._allocate_virtual_network( pathentry.key00.event_id, request_msg.request_info, ) elif action == rwdts.QueryAction.DELETE: self._release_virtual_network(pathentry.key00.event_id) elif action == rwdts.QueryAction.READ: response_info = self._read_virtual_network( pathentry.key00.event_id ) else: raise ValueError("Only read/create/delete actions available. Received action: %s" %(action)) self._log.debug("Responding with VirtualLinkInfo at xpath %s: %s.", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def create_cloudsim_resource_template(): ### Resource to be reuqested for 'cloudsim' resource_requests = {'compute': {}, 'network': {}} ###### mycompute-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = "1" msg.vm_flavor.vcpu_count = 4 msg.vm_flavor.memory_mb = 8192 msg.vm_flavor.storage_gb = 40 resource_requests['compute']['mycompute-0'] = msg ###### mycompute-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = "1" msg.vm_flavor.vcpu_count = 2 msg.vm_flavor.memory_mb = 8192 msg.vm_flavor.storage_gb = 20 resource_requests['compute']['mycompute-1'] = msg ####### mynet-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() resource_requests['network']['mynet-0'] = msg ####### mynet-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() resource_requests['network']['mynet-1'] = msg return resource_requests
def create_openstack_static_template(): ### Resource to be reuqested for 'openstack_static' resource_requests = {'compute': {}, 'network': {}} ###### mycompute-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = openstack_info['image_id'] msg.vm_flavor.vcpu_count = 4 msg.vm_flavor.memory_mb = 8192 msg.vm_flavor.storage_gb = 80 resource_requests['compute']['mycompute-0'] = msg ###### mycompute-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = openstack_info['image_id'] msg.vm_flavor.vcpu_count = 2 msg.vm_flavor.memory_mb = 4096 msg.vm_flavor.storage_gb = 40 resource_requests['compute']['mycompute-1'] = msg ####### mynet-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() msg.provider_network.physical_network = 'PHYSNET1' msg.provider_network.overlay_type = 'VLAN' msg.provider_network.segmentation_id = 17 resource_requests['network']['mynet-0'] = msg ####### mynet-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() msg.provider_network.physical_network = 'PHYSNET1' msg.provider_network.overlay_type = 'VLAN' msg.provider_network.segmentation_id = 18 resource_requests['network']['mynet-1'] = msg return resource_requests
def create_mock_resource_temaplate(): ### Resource to be reuqested for 'mock' resource_requests = {'compute': {}, 'network': {}} ###### mycompute-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-0')) msg.vm_flavor.vcpu_count = 4 msg.vm_flavor.memory_mb = 8192 msg.vm_flavor.storage_gb = 40 resource_requests['compute']['mycompute-0'] = msg ###### mycompute-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = str(uuid.uuid3(uuid.NAMESPACE_DNS, 'image-1')) msg.vm_flavor.vcpu_count = 2 msg.vm_flavor.memory_mb = 8192 msg.vm_flavor.storage_gb = 20 resource_requests['compute']['mycompute-1'] = msg ####### mynet-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() resource_requests['network']['mynet-0'] = msg ####### mynet-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() resource_requests['network']['mynet-1'] = msg return resource_requests
def allocate_vdu_task(ks_path, event_id, cloud_account, request_msg): response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" response_xpath = self._add_config_flag(response_xpath) schema = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) try: response_info = yield from self._parent.allocate_virtual_compute(event_id, cloud_account, request_msg,) except Exception as e: self._log.error("Encountered exception : %s while creating virtual compute", str(e)) response_info = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_ResourceInfo() response_info.resource_state = 'failed' response_info.resource_errors = str(e) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: cloud_account = self._parent.get_cloud_account_detail(cloud_account) #RIFT-17719 - Set the resource state to active if no floating ip pool specified and is waiting for public ip. if response_info.resource_state == 'pending' and cloud_account.has_field('openstack') \ and not (cloud_account.openstack.has_field('floating_ip_pool')) : if (request_msg.has_field('allocate_public_address')) and (request_msg.allocate_public_address == True): if not response_info.has_field('public_ip'): response_info.resource_state = 'active' if response_info.resource_state == 'failed' or response_info.resource_state == 'active' : self._log.debug("Virtual compute create task completed. Publishing VDU info: %s at path: %s", response_info, response_xpath) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: asyncio.ensure_future(monitor_vdu_state(response_xpath, pathentry.key00.event_id, cloud_account.vdu_instance_timeout), loop = self._loop)
def on_link_request_prepare(xact_info, action, ks_path, request_msg): self._log.debug("Received virtual-link on_prepare callback (xact_info: %s, action: %s): %s", xact_info, action, request_msg) response_info = None response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VirtualLinkEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: response_info = yield from self._parent.allocate_virtual_network(pathentry.key00.event_id, request_msg.cloud_account, request_msg.request_info) request_msg.resource_info = response_info self.create_record_dts(self._link_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema()), request_msg) elif action == rwdts.QueryAction.DELETE: yield from self._parent.release_virtual_network(pathentry.key00.event_id) self.delete_record_dts(self._link_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema())) elif action == rwdts.QueryAction.READ: response_info = yield from self._parent.read_virtual_network_info(pathentry.key00.event_id) else: raise ValueError("Only read/create/delete actions available. Received action: %s" %(action)) self._log.debug("Responding with VirtualLinkInfo at xpath %s: %s.", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def on_prepare(xact_info, action, ks_path, msg): self._log.debug("ResourceMgr providing resource-pool information") msg = RwResourceMgrYang.YangData_RwProject_Project_ResourcePoolRecords( ) cloud_accounts = self._parent.get_cloud_account_names() for cloud_account_name in cloud_accounts: pools = self._parent.get_pool_list(cloud_account_name) self._log.debug( "Publishing information about cloud account %s %d resource pools", cloud_account_name, len(pools)) cloud_account_msg = msg.cloud_account.add() cloud_account_msg.name = cloud_account_name for pool in pools: pool_info = self._parent.get_pool_info( cloud_account_name, pool.name) cloud_account_msg.records.append(pool_info) xact_info.respond_xpath( rwdts.XactRspCode.ACK, self._project.add_project( ResourceMgrConfig.XPATH_POOL_OPER_DATA), msg=msg, )
def allocate_vdu_task(ks_path, event_id, cloud_account, request_msg): response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VDUEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) try: response_info = yield from self._parent.allocate_virtual_compute(event_id, cloud_account, request_msg,) except Exception as e: self._log.error("Encountered exception : %s while creating virtual compute", str(e)) response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'failed' yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: if response_info.resource_state == 'failed' or response_info.resource_state == 'active' : self._log.info("Virtual compute create task completed. Publishing VDU info: %s at path: %s", response_info, response_xpath) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: asyncio.ensure_future(monitor_vdu_state(response_xpath, pathentry), loop = self._loop)
def resmgr_msg(self): """ VLR message for this VLR """ msg = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData( ) msg.event_id = self.event_id msg.cloud_account = self.datacenter msg.request_info.name = self.name msg.request_info.vim_network_name = self._vlr_msg.vim_network_name msg.request_info.provider_network.from_dict( self._vlr_msg.provider_network.as_dict()) if self._vlr_msg.has_field('ip_profile_params'): msg.request_info.ip_profile_params.from_dict( self._vlr_msg.ip_profile_params.as_dict()) for cp in self._vlr_msg.virtual_connection_points: vcp = msg.request_info.virtual_cps.add() vcp.from_dict({ k: v for k, v in cp.as_dict().items() if k in ['name', 'port_security_enabled', 'type_yang'] }) if (self._vlr_msg.has_field('ip_profile_params')) and ( self._vlr_msg.ip_profile_params.has_field('security_group') ): vcp.security_group = self._vlr_msg.ip_profile_params.security_group return msg
def get_compute_pool_msg(self, name, pool_type, cloud_type): pool_config = rmgryang.ResourcePools() pool = pool_config.pools.add() pool.name = name pool.resource_type = "compute" if pool_type == "static": pool.pool_type = 'static' acct = get_cal_account(cloud_type) rwcal = create_cal_plugin(acct, self.tinfo.get_rwlog_ctx()) rc, rsp = rwcal.get_vdu_list(acct) assert rc == RwStatus.SUCCESS if cloud_type == 'openstack_static': for vdu in rsp.vdu_info_list: if vdu.name in openstack_info['vms']: self.log.info("Adding the static compute resource: %s to compute pool", vdu.name) r = pool.resources.add() r.resource_id = vdu.vdu_id else: # 'mock', 'cloudsim' 'openstack_dynamic' etc for vdu in rsp.vdu_info_list: self.log.info("Adding the static compute resource: %s to compute pool", vdu.name) r = pool.resources.add() r.resource_id = vdu.vdu_id else: pool.pool_type = 'dynamic' pool.max_size = 10 return pool_config
def get_network_pool_msg(self, name, pool_type, cloud_type): pool_config = rmgryang.YangData_RwProject_Project_ResourceMgrConfig_ResourcePools() pool = pool_config.pools.add() pool.name = name pool.resource_type = "network" if pool_type == "static": pool.pool_type = 'static' acct = get_cal_account(cloud_type) rwcal = create_cal_plugin(acct, self.tinfo.get_rwlog_ctx()) rc, rsp = rwcal.get_virtual_link_list(acct) assert rc == RwStatus.SUCCESS if cloud_type == 'openstack_static': for vlink in rsp.virtual_link_info_list: if vlink.name in openstack_info['networks']: self.log.info("Adding the static network resource: %s to network pool", vlink.name) r = pool.resources.add() r.resource_id = vlink.virtual_link_id else: # 'mock', 'cloudsim', 'openstack_dynamic' etc for vlink in rsp.virtual_link_info_list: self.log.info("Adding the static network resource: %s to network pool", vlink.name) r = pool.resources.add() r.resource_id = vlink.virtual_link_id else: pool.pool_type = 'dynamic' pool.max_size = 4 return pool_config
def monitor_vdu_state(response_xpath, event_id, vdu_timeout): self._log.info("Initiating VDU state monitoring for xpath: %s ", response_xpath) sleep_time = 2 loop_cnt = int(vdu_timeout/sleep_time) for i in range(loop_cnt): self._log.debug( "VDU state monitoring for xpath: %s. Sleeping for 2 second", response_xpath) yield from asyncio.sleep(2, loop = self._loop) try: response_info = yield from self._parent.read_virtual_compute_info(event_id) except Exception as e: self._log.info( "VDU state monitoring: Received exception %s in VDU state monitoring for %s. Aborting monitoring", str(e),response_xpath) response_info = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_ResourceInfo() response_info.resource_state = 'failed' response_info.resource_errors = str(e) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: if response_info.resource_state == 'active' or response_info.resource_state == 'failed': self._log.info("VDU state monitoring: VDU reached terminal state. " + "Publishing VDU info: %s at path: %s", response_info, response_xpath) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return else: ### End of loop. This is only possible if VDU did not reach active state err_msg = ("VDU state monitoring: VDU at xpath :{} did not reached active " + "state in {} seconds. Aborting monitoring". format(response_xpath, time_to_wait)) self._log.info(err_msg) response_info = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_ResourceInfo() response_info.resource_state = 'failed' response_info.resource_errors = err_msg yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return
def create_openstack_dynamic_template(): ### Resource to be reuqested for 'openstack_dynamic' resource_requests = {'compute': {}, 'network': {}} ###### mycompute-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = openstack_info['image_id'] msg.vm_flavor.vcpu_count = 2 msg.vm_flavor.memory_mb = 4096 msg.vm_flavor.storage_gb = 40 msg.guest_epa.mempage_size = 'LARGE' msg.guest_epa.cpu_pinning_policy = 'DEDICATED' msg.allocate_public_address = True resource_requests['compute']['mycompute-0'] = msg ###### mycompute-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData_RequestInfo() msg.image_id = openstack_info['image_id'] msg.vm_flavor.vcpu_count = 4 msg.vm_flavor.memory_mb = 8192 msg.vm_flavor.storage_gb = 40 msg.guest_epa.mempage_size = 'LARGE' msg.guest_epa.cpu_pinning_policy = 'DEDICATED' msg.allocate_public_address = True resource_requests['compute']['mycompute-1'] = msg ####### mynet-0 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() #msg.provider_network.overlay_type = 'VXLAN' #msg.provider_network.segmentation_id = 71 resource_requests['network']['mynet-0'] = msg ####### mynet-1 msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_RequestInfo() #msg.provider_network.overlay_type = 'VXLAN' #msg.provider_network.segmentation_id = 73 resource_requests['network']['mynet-1'] = msg return resource_requests
def monitor_vdu_state(response_xpath, pathentry): self._log.info("Initiating VDU state monitoring for xpath: %s ", response_xpath) loop_cnt = 180 for i in range(loop_cnt): self._log.debug( "VDU state monitoring for xpath: %s. Sleeping for 1 second", response_xpath) yield from asyncio.sleep(1, loop=self._loop) try: response_info = yield from self._parent.read_virtual_compute_info( pathentry.key00.event_id) except Exception as e: self._log.info( "VDU state monitoring: Received exception %s in VDU state monitoring for %s. Aborting monitoring", str(e), response_xpath) response_info = RwResourceMgrYang.VDUEventData_ResourceInfo( ) response_info.resource_state = 'failed' yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: if response_info.resource_state == 'active' or response_info.resource_state == 'failed': self._log.info( "VDU state monitoring: VDU reached terminal state. Publishing VDU info: %s at path: %s", response_info, response_xpath) yield from self._dts.query_update( response_xpath, rwdts.XactFlag.ADVISE, response_info) return else: ### End of loop. This is only possible if VDU did not reach active state self._log.info( "VDU state monitoring: VDU at xpath :{} did not reached active state in {} seconds. Aborting monitoring" .format(response_xpath, loop_cnt)) response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'failed' yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return
def start(self): super(ResMgrTasklet, self).start() self.log.debug("Starting ResMgrTasklet") self.log.debug("Registering with dts") self._dts = rift.tasklets.DTS(self.tasklet_info, RwResourceMgrYang.get_schema(), self.loop, self.on_dts_state_change) self.log.debug("Created DTS Api GI Object: %s", self._dts)
def on_vdu_request_prepare(xact_info, action, ks_path, request_msg): self._log.debug( "Received vdu on_prepare callback (xact_info: %s, action: %s): %s", xact_info, action, request_msg) response_xpath = ks_path.to_xpath( RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VDUEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'pending' request_msg.resource_info = response_info self.create_record_dts( self._vdu_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema()), request_msg) asyncio.ensure_future(allocate_vdu_task( ks_path, pathentry.key00.event_id, request_msg.cloud_account, request_msg.request_info), loop=self._loop) elif action == rwdts.QueryAction.DELETE: response_info = None yield from self._parent.release_virtual_compute( pathentry.key00.event_id) self.delete_record_dts( self._vdu_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema())) elif action == rwdts.QueryAction.READ: response_info = yield from self._parent.read_virtual_compute_info( pathentry.key00.event_id) else: raise ValueError( "Only create/delete actions available. Received action: %s" % (action)) self._log.debug("Responding with VDUInfo at xpath %s: %s", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def start(self): super(ResMgrTasklet, self).start() self.log.info("Starting ResMgrTasklet") self.log.debug("Registering with dts") self._dts = rift.tasklets.DTS(self.tasklet_info, RwResourceMgrYang.get_schema(), self.loop, self.on_dts_state_change) self.log.debug("Created DTS Api GI Object: %s", self._dts)
def allocate_vlink_task(ks_path, event_id, cloud_account, request_info): response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) try: response_info = yield from self._parent.allocate_virtual_network(pathentry.key00.event_id, cloud_account, request_info) except Exception as e: self._log.error("Encountered exception: %s while creating virtual network", str(e)) self._log.exception(e) response_info = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_ResourceInfo() response_info.resource_state = 'failed' response_info.resource_errors = str(e) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) else: yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info)
def on_link_request_prepare(xact_info, action, ks_path, request_msg): self._log.debug( "Received virtual-link on_prepare callback (xact_info: %s, action: %s): %s", xact_info, action, request_msg) response_info = None response_xpath = ks_path.to_xpath( RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VirtualLinkEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: response_info = yield from self._parent.allocate_virtual_network( pathentry.key00.event_id, request_msg.cloud_account, request_msg.request_info) request_msg.resource_info = response_info self.create_record_dts( self._link_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema()), request_msg) elif action == rwdts.QueryAction.DELETE: yield from self._parent.release_virtual_network( pathentry.key00.event_id) self.delete_record_dts( self._link_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema())) elif action == rwdts.QueryAction.READ: response_info = yield from self._parent.read_virtual_network_info( pathentry.key00.event_id) else: raise ValueError( "Only read/create/delete actions available. Received action: %s" % (action)) self._log.debug("Responding with VirtualLinkInfo at xpath %s: %s.", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def get_network_reserve_msg(self, name, cloud_type, xpath): event_id = str(uuid.uuid4()) msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData() msg.event_id = event_id msg.request_info.name = name attributes = ['physical_network', 'name', 'overlay_type', 'segmentation_id'] for attr in attributes: if resource_requests[cloud_type]['network'][name].has_field('provider_network'): if resource_requests[cloud_type]['network'][name].provider_network.has_field(attr): setattr(msg.request_info.provider_network, attr, getattr(resource_requests[cloud_type]['network'][name].provider_network ,attr)) return msg, xpath.format(quoted_key(event_id))
def on_vdu_request_prepare(xact_info, action, ks_path, request_msg): self._log.debug("Received vdu on_prepare callback (xact_info: %s, action: %s): %s", xact_info, action, request_msg) response_info = None response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VDUEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'pending' request_msg.resource_info = response_info self.create_record_dts(self._vdu_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema()), request_msg) asyncio.ensure_future(allocate_vdu_task(ks_path, pathentry.key00.event_id, request_msg.cloud_account, request_msg.request_info), loop = self._loop) elif action == rwdts.QueryAction.DELETE: yield from self._parent.release_virtual_compute(pathentry.key00.event_id) self.delete_record_dts(self._vdu_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema())) elif action == rwdts.QueryAction.READ: response_info = yield from self._parent.read_virtual_compute_info(pathentry.key00.event_id) else: raise ValueError("Only create/delete actions available. Received action: %s" %(action)) self._log.debug("Responding with VDUInfo at xpath %s: %s", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def on_link_request_prepare(xact_info, action, ks_path, request_msg): self._log.debug( "Received virtual-link on_prepare callback (xact_info: %s, action: %s): %s", xact_info, action, request_msg) response_info = None response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: try: response_info = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_ResourceInfo() response_info.resource_state = 'pending' request_msg.resource_info = response_info self.create_record_dts(self._link_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema()), request_msg) asyncio.ensure_future(allocate_vlink_task(ks_path, pathentry.key00.event_id, request_msg.cloud_account, request_msg.request_info), loop = self._loop) except Exception as e: self._log.error( "Encountered exception: %s while creating virtual network", str(e)) self._log.exception(e) response_info = RwResourceMgrYang.YangData_RwProject_Project_ResourceMgmt_VlinkEvent_VlinkEventData_ResourceInfo() response_info.resource_state = 'failed' response_info.resource_errors = str(e) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) elif action == rwdts.QueryAction.DELETE: yield from self._parent.release_virtual_network(pathentry.key00.event_id) self.delete_record_dts(self._link_reg, None, ks_path.to_xpath(RwResourceMgrYang.get_schema())) elif action == rwdts.QueryAction.READ: # TODO: Check why we are getting null event id request if pathentry.key00.event_id: response_info = yield from self._parent.read_virtual_network_info(pathentry.key00.event_id) else: xact_info.respond_xpath(rwdts.XactRspCode.NA) return else: raise ValueError( "Only read/create/delete actions available. Received action: %s" %(action)) self._log.info("Responding with VirtualLinkInfo at xpath %s: %s.", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def __init__(self, log, loop, launchpad, vm_pool_mgr, network_pool_mgr): self._log = log self._loop = loop self._launchpad = launchpad self._vm_pool_mgr = vm_pool_mgr self._network_pool_mgr = network_pool_mgr self._manager = None self._model = RwYang.Model.create_libncx() self._model.load_schema_ypbc(RwCloudYang.get_schema()) self._model.load_schema_ypbc(RwBaseYang.get_schema()) self._model.load_schema_ypbc(RwResourceMgrYang.get_schema()) self._model.load_schema_ypbc(RwNsmYang.get_schema()) self._model.load_schema_ypbc(RwConmanYang.get_schema()) self._model.load_schema_ypbc(RwLaunchpadYang.get_schema()) self._cloud_account = None
def on_prepare(xact_info, query_action, ks_path, msg): """ prepare callback on Virtual Link Events """ try: self._log.debug( "Got on prepare for Virtual Link Event id (ks_path: %s) (msg: %s)", ks_path.to_xpath(RwResourceMgrYang.get_schema()), msg) event_id = self.event_id_from_keyspec(ks_path) if event_id: if query_action == rwdts.QueryAction.CREATE or query_action == rwdts.QueryAction.UPDATE: yield from self._vnsm.update_virual_link_event( event_id, msg) elif query_action == rwdts.QueryAction.DELETE: self._vnsm.delete_virual_link_event(event_id) except Exception as e: self._log.exception( "Caught execption in Virtual Link Event handler", e) xact_info.respond_xpath(rwdts.XactRspCode.ACK)
def monitor_vdu_state(response_xpath, pathentry): self._log.info("Initiating VDU state monitoring for xpath: %s ", response_xpath) loop_cnt = 120 while loop_cnt > 0: self._log.debug("VDU state monitoring: Sleeping for 1 second ") yield from asyncio.sleep(1, loop = self._loop) try: response_info = self._read_virtual_compute( pathentry.key00.event_id ) except Exception as e: self._log.error( "VDU state monitoring: Received exception %s " "in VDU state monitoring for %s. Aborting monitoring", str(e), response_xpath ) raise if response_info.resource_state == 'active' or response_info.resource_state == 'failed': self._log.info( "VDU state monitoring: VDU reached terminal state." "Publishing VDU info: %s at path: %s", response_info, response_xpath ) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return else: loop_cnt -= 1 ### End of while loop. This is only possible if VDU did not reach active state self._log.info("VDU state monitoring: VDU at xpath :%s did not reached active state in 120 seconds. Aborting monitoring", response_xpath) response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'failed' yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return
def get_compute_reserve_msg(self, name, cloud_type, xpath, vlinks): event_id = str(uuid.uuid4()) msg = rmgryang.YangData_RwProject_Project_ResourceMgmt_VduEvent_VduEventData() msg.event_id = event_id msg.request_info.name = name msg.request_info.image_id = resource_requests[cloud_type]['compute'][name].image_id attributes = ['image_id', 'vcpu_count', 'memory_mb', 'storage_gb'] if resource_requests[cloud_type]['compute'][name].has_field('vm_flavor'): for attr in attributes: if resource_requests[cloud_type]['compute'][name].vm_flavor.has_field(attr): setattr(msg.request_info.vm_flavor, attr, getattr(resource_requests[cloud_type]['compute'][name].vm_flavor , attr)) attributes = ['mempage_size', 'cpu_pinning_policy'] if resource_requests[cloud_type]['compute'][name].has_field('guest_epa'): for attr in attributes: if resource_requests[cloud_type]['compute'][name].guest_epa.has_field(attr): setattr(msg.request_info.guest_epa, attr, getattr(resource_requests[cloud_type]['compute'][name].guest_epa , attr)) if resource_requests[cloud_type]['compute'][name].has_field('allocate_public_address'): msg.request_info.allocate_public_address = resource_requests[cloud_type]['compute'][name].allocate_public_address cnt = 0 for link in vlinks: c1 = msg.request_info.connection_points.add() c1.name = name+"-port-"+str(cnt) cnt += 1 c1.virtual_link_id = link self.log.info("Sending message :%s", msg) return msg, xpath.format(quoted_key(event_id))
def configure_schema(cls): return rmgryang.get_schema()
def on_vdu_request_prepare(self, xact_info, action, ks_path, request_msg): if not self._registered: self._log.error("Got a prepare callback when not registered!") xact_info.respond_xpath(rwdts.XactRspCode.NA) return @asyncio.coroutine def monitor_vdu_state(response_xpath, pathentry): self._log.info("Initiating VDU state monitoring for xpath: %s ", response_xpath) loop_cnt = 120 while loop_cnt > 0: self._log.debug("VDU state monitoring: Sleeping for 1 second ") yield from asyncio.sleep(1, loop = self._loop) try: response_info = self._read_virtual_compute( pathentry.key00.event_id ) except Exception as e: self._log.error( "VDU state monitoring: Received exception %s " "in VDU state monitoring for %s. Aborting monitoring", str(e), response_xpath ) raise if response_info.resource_state == 'active' or response_info.resource_state == 'failed': self._log.info( "VDU state monitoring: VDU reached terminal state." "Publishing VDU info: %s at path: %s", response_info, response_xpath ) yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return else: loop_cnt -= 1 ### End of while loop. This is only possible if VDU did not reach active state self._log.info("VDU state monitoring: VDU at xpath :%s did not reached active state in 120 seconds. Aborting monitoring", response_xpath) response_info = RwResourceMgrYang.VDUEventData_ResourceInfo() response_info.resource_state = 'failed' yield from self._dts.query_update(response_xpath, rwdts.XactFlag.ADVISE, response_info) return self._log.debug("Received vdu on_prepare callback (xact_info: %s, action: %s): %s", xact_info, action, request_msg) response_info = None response_xpath = ks_path.to_xpath(RwResourceMgrYang.get_schema()) + "/resource-info" schema = RwResourceMgrYang.VDUEventData().schema() pathentry = schema.keyspec_to_entry(ks_path) if action == rwdts.QueryAction.CREATE: response_info = self._allocate_virtual_compute( pathentry.key00.event_id, request_msg.request_info, ) if response_info.resource_state == 'pending': asyncio.ensure_future(monitor_vdu_state(response_xpath, pathentry), loop = self._loop) elif action == rwdts.QueryAction.DELETE: self._release_virtual_compute( pathentry.key00.event_id ) elif action == rwdts.QueryAction.READ: response_info = self._read_virtual_compute( pathentry.key00.event_id ) else: raise ValueError("Only create/delete actions available. Received action: %s" %(action)) self._log.debug("Responding with VDUInfo at xpath %s: %s", response_xpath, response_info) xact_info.respond_xpath(rwdts.XactRspCode.ACK, response_xpath, response_info)
def configure_schema(cls): return rmgryang.get_schema()