def __init__(self):
self.name = 'fake-slm'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Starting SLM Test:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.name)
self.path_descriptors = "/home/hadi/son-mano-framework/plugins/son-mano-service-lifecycle-management/test/test_descriptors/"
self.test_records = "/home/hadi/son-mano-framework/plugins/son-mano-service-lifecycle-management/test/test_records/"
self.nsd_descriptor = open(self.path_descriptors + 'sonata-demo.yml',
'r')
self.vnfd1_descriptor = open(
self.path_descriptors + 'firewall-vnfd.yml', 'r')
self.vnfd2_descriptor = open(self.path_descriptors + 'iperf-vnfd.yml',
'r')
self.vnfd3_descriptor = open(
self.path_descriptors + 'tcpdump-vnfd.yml', 'r')
self.end = False
self.manoconn.register_async_endpoint(
self.check1, 'infrastructure.management.compute.list')
self.manoconn.register_async_endpoint(self.check2,
'infrastructure.service.deploy')
self.publish_nsd()
time.sleep(50)
self.update()
self.run()
def setUp(self):
current_dir = os.getcwd()
self.slm_proc = Process(target=fakeflm)
self.smr_proc = Process(target=fake_smr.main)
os.chdir('../vpn-config')
self.con_proc = Process(
target=vpn_css.vpn_css.main,
kwargs={'working_dir': os.path.realpath('../vpn-config')})
os.chdir('../firewall-config')
self.fw_proc = Process(
target=firewall.firewall.main,
kwargs={'working_dir': os.path.realpath('../firewall-config')})
self.cache_proc = Process(
target=sonfsmvprxsquidconfiguration1.sonfsmvprxsquidconfiguration1.
main,
kwargs={'working_dir': os.path.realpath('../cache-config')})
os.chdir(current_dir)
self.slm_proc.daemon = True
self.smr_proc.daemon = True
# self.con_proc.daemon = True
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
'ConfTest')
self.wait_for_reg_event = threading.Event()
self.wait_for_reg_event.clear()
self.wait_for_res_event = threading.Event()
self.wait_for_res_event.clear()
def __init__(self,
specific_manager_type=None,
service_name=None,
function_name=None,
specific_manager_name=None,
id_number=None,
update_version='false',
version=None,
description=None):
"""
:param specific_manager_type: specifies the type of specific manager that could be either fsm or ssm.
:param service_name: the name of the service that this specific manager belongs to.
:param function_name: the name of the function that this specific manager belongs to, will be null in SSM case
:param specific_manager_name: the actual name of specific manager (e.g., scaling, placement)
:param id_number: the specific manager id number which is used to distinguish between multiple SSM/FSM
that are created for the same objective (e.g., scaling with algorithm 1 and 2)
:param updated_version: specifies whether this SM is developed to update a current version or not,should be
filled either by 'true' or 'false'
:param version: version
:param description: description
"""
#checks if the chosen name by develeopr is correct format
self.name_validation(specific_manager_type, service_name,
function_name, specific_manager_name, id_number)
#Populating SSM-FSM fileds
self.specific_manager_type = specific_manager_type
self.service_name = service_name
self.function_name = function_name
self.specific_manager_name = specific_manager_name
self.id_number = id_number
if self.specific_manager_type == 'fsm':
self.specific_manager_id = "son{0}{1}{2}{3}{4}".\
format(specific_manager_type, service_name, function_name, specific_manager_name, id_number)
else:
self.specific_manager_id = "son{0}{1}{2}{3}".\
format(specific_manager_type, service_name, specific_manager_name, id_number)
self.version = version
self.description = description
self.update_version = update_version
self.uuid = None
self.sfuuid = None
self.private_key = None
LOG.info("Starting {0} ...".format(self.specific_manager_id))
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.specific_manager_id)
self.wait_for_event = threading.Event()
self.wait_for_event.clear()
self.registration()
self.infinity_loop()
def __init__(self):
self.name = 'fake-smr'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Start SMR:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(self.name)
self.declare_subscriptions()
def on_placement_request(self, ch, method, properties, payload):
if properties.app_id != self.name:
message = yaml.load(payload)
LOG.info('Placement request received')
#topic = 'placement.ssm.{0}'.format(message['uuid'])
topic = 'placement.ssm.' + message['uuid']
LOG.info(topic)
req = yaml.dump(message)
url = "{0}/ssm-{1}".format(self.sm_broker_host, message['uuid'])
connection = messaging.ManoBrokerRequestResponseConnection(app_id=self.name, url=url)
connection.call_async(self.on_placement_result, topic=topic, msg=req, correlation_id= properties.correlation_id)
LOG.info("Placement request forwarded to SSM on topic: {0}".format(topic))
def __init__(self,
name="son-plugin",
version=None,
description=None,
auto_register=True,
wait_for_registration=True,
start_running=True,
auto_heartbeat_rate=0.5):
"""
Performs plugin initialization steps, e.g., connection setup
:param name: Plugin name prefix
:param version: Plugin version
:param description: A description string
:param auto_register: Automatically register on init
:param wait_for_registration: Wait for registration before returning from init
:param auto_heartbeat_rate: rate of automatic heartbeat notifications 1/n seconds. 0=deactivated
:return:
"""
self.name = "%s.%s" % (name, self.__class__.__name__)
self.version = version
self.description = description
self.uuid = None # uuid given by plugin manager on registration
self.state = None # the state of this plugin READY/RUNNING/PAUSED/FAILED
LOG.info(
"Starting MANO Plugin: %r ..." % self.name)
# create and initialize broker connection
while True:
try:
self.manoconn = messaging.ManoBrokerRequestResponseConnection(self.name)
break
except:
time.sleep(1)
# register subscriptions
LOG.info("Plugin connected to broker.")
self.declare_subscriptions()
# register to plugin manager
if auto_register:
while self.uuid is None:
self.register()
if wait_for_registration:
self._wait_for_registration()
# kick-off automatic heartbeat mechanism
self._auto_heartbeat(auto_heartbeat_rate)
# jump to run
if start_running:
LOG.info("Plugin running...")
self.run()
def on_scaling_request(self, ch, method, properties, payload):
if properties.app_id != self.name:
LOG.info('Scaling request received')
message = yaml.load(payload)
req = yaml.dump(message)
topic = 'scaling.fsm.{0}'.format(message['uuid'])
url = "{0}/fsm-{1}".format(self.sm_broker_host, message['uuid'])
connection = messaging.ManoBrokerRequestResponseConnection(
app_id=self.name, url=url)
connection.call_async(self.on_scaling_result,
topic=topic,
msg=req,
correlation_id=properties.correlation_id)
LOG.info(
"Scaling request forwarded to FSM on topic: {0}".format(topic))
def __init__(self):
self.name = 'fake-slm'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Starting SLM1:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(self.name)
self.end = False
self.publish_sid()
self.run()
def __init__(self):
self.name = 'fake-slm'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Starting SLM1:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.name)
self.publish_nsd()
#self.manoconn.subscribe(self.publish_nsd, "specific.manager.registry.ssm.instantiate")
self.end = False
self.run()
def setUp(self):
self.slm_proc = Process(target= fakeflm)
self.smr_proc = Process(target= fakesmr)
self.con_proc = Process(target= faceFSM)
self.slm_proc.daemon = True
self.smr_proc.daemon = True
self.con_proc.daemon = True
self.manoconn = messaging.ManoBrokerRequestResponseConnection('ConfTest')
self.wait_for_reg_event = threading.Event()
self.wait_for_reg_event.clear()
self.wait_for_res_event = threading.Event()
self.wait_for_res_event.clear()
def __init__(self):
self.name = 'fake-alert'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Starting alert:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(self.name)
self.path_descriptors = 'test/test_descriptors/'
self.end = False
self.publish_nsd()
self.run()
def __init__(self):
self.name = 'placement-trigger'
self.version = '0.1'
self.description = 'description'
LOG.info("Starting triggering placement SSM:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.name)
self.path_descriptors = 'test/test_descriptors/'
self.end = False
self.publish_nsd()
self.run()
def __init__(self):
self.name = 'fake-flm'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Start sending VNFR:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(self.name)
self.manoconn.subscribe(self._on_publish,'son.configuration')
self.end = False
self.publish_nsd()
self.run()
def __init__(self):
self.name = 'fake-slm'
self.version = '0.1-dev'
self.description = 'description'
LOG.info("Starting SLM1:...")
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.name)
self.path_descriptors = '/home/hadi/son-mano-framework/son-mano-specificmanager/son-mano-specific-manager-registry/test/test_descriptors/'
self.end = False
self.publish_sid()
self.run()
def __init__(self,
sm_id=None,
sm_version=None,
description=None,
connect_to_broker=True,
register=True):
"""
:param specific_manager_type: specifies the type of specific manager that could be either fsm or ssm.
:param service_name: the name of the service that this specific manager belongs to.
:param function_name: the name of the function that this specific manager belongs to, will be null in SSM case
:param specific_manager_name: the actual name of specific manager (e.g., scaling, placement)
:param id_number: the specific manager id number which is used to distinguish between multiple SSM/FSM
that are created for the same objective (e.g., scaling with algorithm 1 and 2)
:param updated_version: specifies whether this SM is developed to update a current version or not,should be
filled either by 'true' or 'false'
:param version: version
:param description: description
"""
#Populating SSM-FSM fields
self.sm_id = sm_id
self.sm_version = sm_version
self.description = description
self.sfuuid = ''
if 'sf_uuid' in os.environ:
self.sfuuid = os.environ['sf_uuid']
LOG.info("Starting specific manager with name: " + self.sm_id)
LOG.info("Starting specific manager with sfuuid: " + self.sfuuid)
# create and initialize broker connection
if connect_to_broker:
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.sm_id + '-' + str(self.sfuuid))
LOG.info("Specific manager connected to broker.")
# register only of there is a broker connection
if connect_to_broker and register:
self.wait_for_event = threading.Event()
self.wait_for_event.clear()
self.registration()
def __init__(self,
smtype=None,
name=None,
id=None,
version=None,
description=None):
"""
# FSM/SSM name consists of son,smtype(either ssm or fsm), name (a-z), and an id (0-9)
:param smtype: specific management type: either fsm or ssm
:param name: the name of the FSM/SSM
:param id: the Id of the FSM/SSM
:param version: version
:param description: a description on what does FSM/SSM do
"""
#checks if the chosen name by develeopr is correct
self.name_checker(self.smtype, self.name, self.id)
self.smtype = smtype
self.id = id
self.name = "son{0}{1}{2}".format(smtype, name, id)
self.version = version
self.description = description
self.uuid = None
LOG.info("Starting {0} ...".format(self.name))
# create and initialize broker connection
self.manoconn = messaging.ManoBrokerRequestResponseConnection(
self.name)
self.tLock = threading.Lock()
t1 = threading.Thread(target=self.registeration)
t2 = threading.Thread(target=self.run)
# register to Specific Manager Registry
t1.start()
# locks the registration thread
self.tLock.acquire()
# jump to run
t2.start()
def resp_instant(self, ch, method, prop, payload):
"""
This method handles responses to a request to onboard the fsms
of a new function.
"""
# Retrieve the function uuid
func_id = tools.funcid_from_corrid(self.functions, prop.correlation_id)
msg = ": Instantiating response received from SMR."
LOG.info("Function " + func_id + msg)
LOG.debug(payload)
message = yaml.load(payload)
for fsm_type in self.functions[func_id]['fsm'].keys():
fsm = self.functions[func_id]['fsm'][fsm_type]
response = message[fsm['id']]
fsm['instantiated'] = False
if response['error'] == 'None':
LOG.info("Function " + func_id + ": FSM instantiated correct.")
fsm['instantiated'] = True
else:
msg = ": FSM instantiation failed: " + response['error']
LOG.info("Function " + func_id + msg)
self.flm_error(func_id, error=response['error'])
fsm['uuid'] = response['uuid']
# Setup broker connection with the SSMs of this service.
url = self.fsm_url_base + 'fsm-' + func_id
fsm_conn = messaging.ManoBrokerRequestResponseConnection(self.name,
url=url)
self.fsm_connections[func_id] = fsm_conn
# Continue with the scheduled tasks
self.start_next_task(func_id)
def recreate_ledger(self, payload, corr_id, func_id, topic):
"""
This method adds already existing functions with their specifics
back to the ledger, so other methods can use this information.
:param payload: the payload of the received message
:param corr_id: the correlation id of the received message
:param func_id: the instance uuid of the function defined by SLM.
"""
# Add the function to the ledger and add instance ids
self.functions[func_id] = {}
self.functions[func_id]['act_corr_id'] = None
self.functions[func_id]['error'] = None
# Get VNFR
get_vnfr = tools.getRestData(t.vnfr_path + '/', func_id)
if get_vnfr['error'] is not None:
error = get_vnfr['error'] + ': ' + get_vnfr['content']
self.functions[func_id]['error'] = error
return False
self.functions[func_id]['vnfr'] = get_vnfr['content']
self.functions[func_id]['vnfr']['id'] = func_id
del self.functions[func_id]['vnfr']['created_at']
del self.functions[func_id]['vnfr']['updated_at']
del self.functions[func_id]['vnfr']['uuid']
# GET VNFD
vnfd_id = self.functions[func_id]['vnfr']['descriptor_reference']
LOG.info(str(t.vnfd_path + '/' + vnfd_id))
head = {"Content-type": "application/json"}
get_vnfd = tools.getRestData(t.vnfd_path + '/', vnfd_id, head=head)
if get_vnfd['error'] is not None:
error = str(get_vnfd['error']) + ': ' + str(get_vnfd['content'])
LOG.info(str(error))
self.functions[func_id]['error'] = error
return False
self.functions[func_id]['vnfd'] = get_vnfd['content']['vnfd']
LOG.info(str(self.functions[func_id]['vnfd']))
self.functions[func_id]['id'] = func_id
# Add the topic of the call
self.functions[func_id]['topic'] = topic
# Add to correlation id to the ledger
self.functions[func_id]['orig_corr_id'] = corr_id
# Add payload to the ledger
self.functions[func_id]['payload'] = payload
# Add the service uuid that this function belongs to
self.functions[func_id]['serv_id'] = payload['serv_id']
# Add the VIM uuid
if 'vim_id' in payload.keys():
self.functions[func_id]['vim_uuid'] = payload['vim_id']
else:
vdus = self.functions[func_id]['vnfr']['virtual_deployment_units']
vim_id = vdus[0]['vnfc_instance'][0]['vim_id']
self.functions[func_id]['vim_uuid'] = vim_id
# Create the function schedule
self.functions[func_id]['schedule'] = []
# Create the FSM dict if FSMs are defined in VNFD
fsm_dict = tools.get_fsm_from_vnfd(self.functions[func_id]['vnfd'])
LOG.info(str(fsm_dict))
self.functions[func_id]['fsm'] = fsm_dict
# Setup broker connection with the SSMs of this service.
if bool(fsm_dict) and func_id not in self.fsm_connections.keys():
url = self.fsm_url_base + 'fsm-' + func_id
fsm_conn = messaging.ManoBrokerRequestResponseConnection(self.name,
url=url)
self.fsm_connections[func_id] = fsm_conn
# Create the chain pause and kill flag
self.functions[func_id]['pause_chain'] = False
self.functions[func_id]['kill_chain'] = False
# Create payload fields for FSMs
self.functions[func_id]['start'] = None
self.functions[func_id]['stop'] = None
self.functions[func_id]['configure'] = None
self.functions[func_id]['message'] = None
return True
def update(self, message):
descriptor = None
manager = None
result_dict = {}
sm_type = 'ssm'
v_host_error = False
if 'NSD' in message:
descriptor = 'NSD'
manager = 'service_specific_managers'
elif 'VNFD' in message:
descriptor = 'VNFD'
manager = 'function_specific_managers'
sm_type = 'fsm'
# Create virtual host for the service/function to be used by SSM/FSM
response = self.smrengine.create_vh(sm_type=sm_type,
uuid=message['UUID'])
if response == (201, 201) or (0, 0):
url = "{0}/{1}-{2}".format(self.smrengine.sm_broker_host, sm_type,
message['UUID'])
connection = messaging.ManoBrokerRequestResponseConnection(
app_id=self.name, url=url)
connection.register_async_endpoint(self.on_ssm_register,
topic.SSM_REGISTRATION)
time.sleep(1)
if (201, 201):
LOG.info('Virtual Host: {0}-{1} has been created!'.format(
sm_type, message['UUID']))
else:
LOG.info('Virtual Host already exists')
else:
v_host_error = True
for i in range(len(message[descriptor][manager])):
if not v_host_error:
# retrieve current id and image
op_list = message[descriptor][manager][i]['options']
c_id = None
c_image = None
for j in range(len(op_list)):
if op_list[j]['key'] == 'currentId':
c_id = op_list[j]['value']
break
for k in range(len(op_list)):
if op_list[k]['key'] == 'currentImage':
c_image = op_list[k]['value']
break
if c_id and c_image is not None:
LOG.info('Updating request received for: {0}'.format(c_id))
m_id = message[descriptor][manager][i]['id']
m_image = message[descriptor][manager][i]['image']
sm_repo_name = "{0}{1}".format(m_id, message['UUID'])
# onboard the new SM
LOG.info('On-boarding started for : {0}'.format(m_id))
try:
result = self.smrengine.pull(image=m_image)
except BaseException as error:
result_dict.update(
{m_id: {
'status': 'Failed',
'error': str(error)
}})
LOG.error('On-boarding failed for: {0}'.format(m_id))
else:
result = yaml.load(result.split("\n")[1])
if 'error' in result.keys():
LOG.error(
'On-boarding failed for: {0}'.format(m_id))
result_dict.update({
m_id: {
'status': 'Failed',
'error': result['error']
}
})
else:
LOG.info(
'On-boarding succeeded for: {0}'.format(m_id))
if c_id == m_id and self.ssm_repo[sm_repo_name][
'sfuuid'] == message['UUID']:
# instantiate the new SM
LOG.info(
'Instantiation started for: {0}'.format(
m_id))
if 'private_key' in message:
p_key = message['private_key']
else:
p_key = None
try:
random_id = self.id_generator()
self.smrengine.start(id=random_id,
image=m_image,
sm_type=sm_type,
uuid=message['UUID'],
p_key=p_key)
except BaseException as error:
LOG.error(
'Instantiation failed for: {0}, Error: {1}'
.format(m_id, error))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': str(error)
}
})
else:
# Check if update is successfully done.
update = threading.Thread(
target=self._wait_for_update,
args=[sm_repo_name])
update.daemon = True
update.start()
update.join()
if self.ssm_repo[sm_repo_name][
'status'] == 'registered':
LOG.debug(
'Registration & instantiation succeeded for: {0}'
.format(m_id))
self.ssm_repo[sm_repo_name][
'status'] = 'running'
result_dict.update({
m_id: {
'status':
'Updated',
'uuid':
self.ssm_repo[sm_repo_name]
['uuid'],
'error':
'None'
}
})
# terminate the current SM
try:
self.smrengine.rm(
id=c_id,
image=c_image,
uuid=message['UUID'])
except BaseException as error:
LOG.error(
"Termination failed for: {0} , Error: {1}"
.format(c_id, error))
self.smrengine.rm(
id=random_id,
image=m_image,
uuid=message['UUID'])
result_dict.update({
m_id: {
'status': 'Failed',
'error': str(error)
}
})
else:
try:
self.smrengine.rename(
"{0}{1}".format(
random_id,
message['UUID']),
"{0}{1}".format(
m_id, message['UUID']))
except BaseException as error:
LOG.error(
"Rename failed for: {0} , Error: {1}"
.format(c_id, error))
self.smrengine.rm(
id=random_id,
image=m_image,
uuid=message['UUID'])
result_dict.update({
m_id: {
'status': 'Failed',
'error': str(error)
}
})
else:
self.ssm_repo[sm_repo_name][
'status'] = 'updated'
LOG.debug(
"Termination succeeded for: {0} (old version)"
.format(c_id))
LOG.debug(
'{0} updating succeeded'.
format(m_id))
else:
LOG.error(
"Instantiation failed for: {0}, "
"Error: Registration failed".
format(m_id))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': 'Registration failed'
}
})
self.smrengine.rm(id=m_id,
image=m_image,
uuid=message['UUID'])
else:
# instantiate the new SM
LOG.info(
'Instantiation started for: {0}'.format(
m_id))
if 'private_key' in message:
p_key = message['private_key']
else:
p_key = None
try:
self.smrengine.start(id=m_id,
image=m_image,
sm_type=sm_type,
uuid=message['UUID'],
p_key=p_key)
except BaseException as error:
LOG.error(
'Instantiation failed for: {0}, Error: {1}'
.format(m_id, error))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': str(error)
}
})
else:
# Check if the registration is successfully done
registration = threading.Thread(
target=self._wait_for_sm_registration,
args=[sm_repo_name, m_id])
registration.daemon = True
registration.start()
registration.join()
if sm_repo_name in self.ssm_repo.keys():
LOG.debug(
'Registration & instantiation succeeded for: {0}'
.format(m_id))
self.ssm_repo[sm_repo_name][
'status'] = 'running'
result_dict.update({
m_id: {
'status':
'Updated',
'uuid':
self.ssm_repo[sm_repo_name]
['uuid'],
'error':
'None'
}
})
# terminate the current SM
try:
self.smrengine.rm(
id=c_id,
image=c_image,
uuid=message['UUID'])
except BaseException as error:
LOG.error(
"Termination failed for: {0} , Error: {1}"
.format(c_id, error))
self.smrengine.rm(
id=m_id,
image=m_image,
uuid=message['UUID'])
del self.ssm_repo[sm_repo_name]
result_dict.update({
m_id: {
'status': 'Failed',
'error': str(error)
}
})
else:
LOG.debug(
"Termination succeeded for: {0} (old version)"
.format(c_id))
self.ssm_repo[sm_repo_name][
'status'] = 'terminated'
LOG.debug(
'Updating succeeded, {0} has replaced by {1}'
.format(c_id, m_id))
else:
LOG.error(
"Instantiation failed for: {0}, Error: Registration failed"
.format(m_id))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': 'Registration failed'
}
})
self.smrengine.rm(id=m_id,
image=m_image,
uuid=message['UUID'])
else:
LOG.error(
'Instantiation failed for: {0}, Error: RabbitMQ virtual host creation failed'
.format(m_id))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': 'RabbitMQ virtual host creation failed'
}
})
return result_dict
def instantiate(self, message):
descriptor = None
manager = None
result_dict = {}
v_host_error = False
if 'NSD' in message:
descriptor = 'NSD'
manager = 'service_specific_managers'
sm_type = 'ssm'
elif 'VNFD' in message:
descriptor = 'VNFD'
manager = 'function_specific_managers'
sm_type = 'fsm'
# Create virtual host for the service/function to be used by SSM/FSM
response = self.smrengine.create_vh(sm_type=sm_type,
uuid=message['UUID'])
if response == (201, 201) or (0, 0):
url = "{0}/{1}-{2}".format(self.smrengine.sm_broker_host, sm_type,
message['UUID'])
connection = messaging.ManoBrokerRequestResponseConnection(
app_id=self.name, url=url)
connection.register_async_endpoint(self.on_ssm_register,
topic.SSM_REGISTRATION)
time.sleep(1)
if response == (201, 201):
LOG.info('Virtual Host: {0}-{1} has been created!'.format(
sm_type, message['UUID']))
else:
LOG.info('Virtual Host already exists')
else:
v_host_error = True
for i in range(len(message[descriptor][manager])):
if not v_host_error:
m_id = message[descriptor][manager][i]['id']
m_image = message[descriptor][manager][i]['image']
if 'private_key' in message:
p_key = message['private_key']
else:
p_key = None
LOG.info(
'Instantiation request received for: {0}'.format(m_id))
sf_uuid = message['UUID']
try:
self.smrengine.start(id=m_id,
image=m_image,
sm_type=sm_type,
uuid=message['UUID'],
p_key=p_key)
except BaseException as error:
LOG.error(
'Instantiation failed for: {0}, Error: {1}'.format(
m_id, error))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': str(error)
}
})
else:
registration = threading.Thread(
target=self._wait_for_sm_registration,
args=[sf_uuid, m_id])
registration.daemon = True
registration.start()
registration.join()
if sf_uuid in self.ssm_repo.keys():
LOG.debug(
'Registration & instantiation succeeded for: {0}'.
format(m_id))
self.ssm_repo[sf_uuid]['status'] = 'running'
result_dict.update({
m_id: {
'status': 'Instantiated',
'uuid': sf_uuid,
'error': 'None'
}
})
else:
LOG.error(
'Instantiation failed:SSM name {0} not found!'.
format(m_id))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': 'Registration failed'
}
})
self.smrengine.rm(id=m_id,
image=m_image,
uuid=message['UUID'])
else:
LOG.error(
'Instantiation failed for: {0}, Error: RabbitMQ virtual host creation failed'
.format(m_id))
result_dict.update({
m_id: {
'status': 'Failed',
'uuid': 'None',
'error': 'RabbitMQ virtual host creation failed'
}
})
return result_dict
