def process_resource_quota(self, quota, prefix, extra_specs):
"""
:param prefix:
- :param extra_specs:
+ :param extra_specs:
:return:
"""
if 'limit' in quota:
ksExceptions.ClientException, neExceptions.NeutronException,
ConnectionError) as e:
self._format_exception(e)
+
+
+ def refresh_sfps_status(self, sfp_list):
+ '''Get the status of the service function path
+ Params: the list of sfp identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this service function path
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
+ '''
+ sfp_dict={}
+ self.logger.debug("refresh_sfps status: Getting tenant SFP information from VIM")
+ for sfp_id in sfp_list:
+ sfp={}
+ try:
+ sfp_vim = self.get_sfp(sfp_id)
+ if sfp_vim['spi']:
+ sfp['status'] = vmStatus2manoFormat[ 'ACTIVE' ]
+ else:
+ sfp['status'] = "OTHER"
+ sfp['error_msg'] = "VIM status reported " + vm_vim['status']
+
+ sfp['vim_info'] = self.serialize(sfp_vim)
+
+ if sfp_vim.get('fault'):
+ sfp['error_msg'] = str(sfp_vim['fault'])
+
+ except vimconn.vimconnNotFoundException as e:
+ self.logger.error("Exception getting sfp status: %s", str(e))
+ sfp['status'] = "DELETED"
+ sfp['error_msg'] = str(e)
+ except vimconn.vimconnException as e:
+ self.logger.error("Exception getting sfp status: %s", str(e))
+ sfp['status'] = "VIM_ERROR"
+ sfp['error_msg'] = str(e)
+ sfp_dict[sfp_id] = sfp
+ return sfp_dict
+
+
+ def refresh_sfis_status(self, sfi_list):
+ '''Get the status of the service function instances
+ Params: the list of sfi identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this service function instance
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
+ '''
+ sfi_dict={}
+ self.logger.debug("refresh_sfis status: Getting tenant sfi information from VIM")
+ for sfi_id in sfi_list:
+ sfi={}
+ try:
+ sfi_vim = self.get_sfi(sfi_id)
+ if sfi_vim:
+ sfi['status'] = vmStatus2manoFormat[ 'ACTIVE' ]
+ else:
+ sfi['status'] = "OTHER"
+ sfi['error_msg'] = "VIM status reported " + vm_vim['status']
+
+ sfi['vim_info'] = self.serialize(sfi_vim)
+
+ if sfi_vim.get('fault'):
+ sfi['error_msg'] = str(sfi_vim['fault'])
+
+ except vimconn.vimconnNotFoundException as e:
+ self.logger.error("Exception getting sfi status: %s", str(e))
+ sfi['status'] = "DELETED"
+ sfi['error_msg'] = str(e)
+ except vimconn.vimconnException as e:
+ self.logger.error("Exception getting sfi status: %s", str(e))
+ sfi['status'] = "VIM_ERROR"
+ sfi['error_msg'] = str(e)
+ sfi_dict[sfi_id] = sfi
+ return sfi_dict
+
+
+ def refresh_sfs_status(self, sf_list):
+ '''Get the status of the service functions
+ Params: the list of sf identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this service function
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
+ '''
+ sf_dict={}
+ self.logger.debug("refresh_sfs status: Getting tenant sf information from VIM")
+ for sf_id in sf_list:
+ sf={}
+ try:
+ sf_vim = self.get_sf(sf_id)
+ if sf_vim:
+ sf['status'] = vmStatus2manoFormat[ 'ACTIVE' ]
+ else:
+ sf['status'] = "OTHER"
+ sf['error_msg'] = "VIM status reported " + vm_vim['status']
+
+ sf['vim_info'] = self.serialize(sf_vim)
+
+ if sf_vim.get('fault'):
+ sf['error_msg'] = str(sf_vim['fault'])
+
+ except vimconn.vimconnNotFoundException as e:
+ self.logger.error("Exception getting sf status: %s", str(e))
+ sf['status'] = "DELETED"
+ sf['error_msg'] = str(e)
+ except vimconn.vimconnException as e:
+ self.logger.error("Exception getting sf status: %s", str(e))
+ sf['status'] = "VIM_ERROR"
+ sf['error_msg'] = str(e)
+ sf_dict[sf_id] = sf
+ return sf_dict
+
+
+
+ def refresh_classifications_status(self, classification_list):
+ '''Get the status of the classifications
+ Params: the list of classification identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this classifier
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
+ '''
+ classification_dict={}
+ self.logger.debug("refresh_classifications status: Getting tenant classification information from VIM")
+ for classification_id in classification_list:
+ classification={}
+ try:
+ classification_vim = self.get_classification(classification_id)
+ if classification_vim:
+ classification['status'] = vmStatus2manoFormat[ 'ACTIVE' ]
+ else:
+ classification['status'] = "OTHER"
+ classification['error_msg'] = "VIM status reported " + vm_vim['status']
+
+ classification['vim_info'] = self.serialize(classification_vim)
+
+ if classification_vim.get('fault'):
+ classification['error_msg'] = str(classification_vim['fault'])
+
+ except vimconn.vimconnNotFoundException as e:
+ self.logger.error("Exception getting classification status: %s", str(e))
+ classification['status'] = "DELETED"
+ classification['error_msg'] = str(e)
+ except vimconn.vimconnException as e:
+ self.logger.error("Exception getting classification status: %s", str(e))
+ classification['status'] = "VIM_ERROR"
+ classification['error_msg'] = str(e)
+ classification_dict[classification_id] = classification
+ return classification_dict
elif vld.get("vim-network-name"):
db_sce_net["vim_network_name"] = get_str(vld, "vim-network-name", 255)
-
# table sce_interfaces (vld:vnfd-connection-point-ref)
for iface in vld.get("vnfd-connection-point-ref").values():
# Check if there are VDUs in the descriptor
"'nsd':'constituent-vnfd'".format(
str(nsd["id"]), str(vld["id"]), str(iface["member-vnf-index-ref"])),
httperrors.Bad_Request)
-
+
existing_ifaces = mydb.get_rows(SELECT=('i.uuid as uuid', 'i.type as iface_type'),
FROM="interfaces as i join vms on i.vm_id=vms.uuid",
WHERE={'vnf_id': vnf_index2vnf_uuid[vnf_index],
"sce_net_id": sce_net_uuid,
"interface_id": interface_uuid,
"ip_address": iface_ip_address,
- }
+ }
db_sce_interfaces.append(db_sce_interface)
if not db_sce_net["type"]:
db_sce_net["type"] = "bridge"
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfis':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_sfis(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_sfi(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfs':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_sfs(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_sf(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_classifications':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_classifications(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_classification(task)
elif task["action"] == "DELETE":
else:
raise vimconn.vimconnException(self.name + "unknown task action {}".format(task["action"]))
elif task["item"] == 'instance_sfps':
- if task["action"] == "CREATE":
+ if task["status"] in ('BUILD', 'DONE') and task["action"] in ("FIND", "CREATE"):
+ database_update = self._refres_sfps(task)
+ create_or_find = True
+ elif task["action"] == "CREATE":
create_or_find = True
database_update = self.new_sfp(task)
elif task["action"] == "DELETE":
if database_update:
where_filter = {"related": task["related"]}
if task["item"] == "instance_nets" and task["datacenter_vim_id"]:
- where_filter["datacenter_tenant_id"] = task["datacenter_vim_id"]
+ where_filter["datacenter_tenant_id"] = task["datacenter_vim_id"]
self.db.update_rows(table=task["item"],
UPDATE=database_update,
WHERE=where_filter)
except Exception as e:
if isinstance(e, SdnConnectorError) and e.http_error == HTTPStatus.NOT_FOUND.value:
pass
- else:
+ else:
self._proccess_sdn_exception(e)
params = task["params"]
last_update = time.time()
connected_ports = new_connected_ports
elif wimconn_net_id:
- try:
+ try:
wim_status_dict = self.sdnconnector.get_connectivity_service_status(wimconn_net_id,
conn_info=created_items)
sdn_status = wim_status_dict["sdn_status"]
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_sfi_id
instance_element_update = {"status": "ACTIVE", "vim_sfi_id": vim_sfi_id, "error_msg": None}
return instance_element_update
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_sf_id
instance_element_update = {"status": "ACTIVE", "vim_sf_id": vim_sf_id, "error_msg": None}
return instance_element_update
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_classification_id
instance_element_update = {"status": "ACTIVE", "vim_classification_id": vim_classification_id,
"error_msg": None}
task["extra"]["created"] = True
task["extra"]["vim_status"] = "ACTIVE"
task["error_msg"] = None
- task["status"] = "FINISHED" # with FINISHED instead of DONE it will not be refreshing
+ task["status"] = "DONE"
task["vim_id"] = vim_sfp_id
instance_element_update = {"status": "ACTIVE", "vim_sfp_id": vim_sfp_id, "error_msg": None}
return instance_element_update
return None
task["status"] = "FAILED"
return None
+
+ def _refres_sfps(self, task):
+ """Call VIM to get SFPs status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ sfp_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_sfps_status(sfp_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-sfp: vimconnException when trying to refresh sfps {}".format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-sfp: vim_sfp_id={} result={}".format(task_id, task["vim_id"], vim_info))
+ #TODO: Revise this part
+ vim_info_error_msg = None
+ if vim_info.get("error_msg"):
+ vim_info_error_msg = self._format_vim_error_msg(vim_info["error_msg"])
+ task_vim_info = task["extra"].get("vim_info")
+ task_error_msg = task.get("error_msg")
+ task_vim_status = task["extra"].get("vim_status")
+ if task_vim_status != vim_info["status"] or task_error_msg != vim_info_error_msg or \
+ (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["vim_info"] = vim_info["vim_info"]
+
+ task["extra"]["vim_status"] = vim_info["status"]
+ task["error_msg"] = vim_info_error_msg
+ if vim_info.get("vim_info"):
+ task["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
+
+ def _refres_sfis(self, task):
+ """Call VIM to get sfis status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ sfi_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_sfis_status(sfi_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-sfi: vimconnException when trying to refresh sfis {}".format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-sfi: vim_sfi_id={} result={}".format(task_id, task["vim_id"], vim_info))
+ #TODO: Revise this part
+ vim_info_error_msg = None
+ if vim_info.get("error_msg"):
+ vim_info_error_msg = self._format_vim_error_msg(vim_info["error_msg"])
+ task_vim_info = task["extra"].get("vim_info")
+ task_error_msg = task.get("error_msg")
+ task_vim_status = task["extra"].get("vim_status")
+ if task_vim_status != vim_info["status"] or task_error_msg != vim_info_error_msg or \
+ (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["vim_info"] = vim_info["vim_info"]
+
+ task["extra"]["vim_status"] = vim_info["status"]
+ task["error_msg"] = vim_info_error_msg
+ if vim_info.get("vim_info"):
+ task["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
+
+ def _refres_sfs(self, task):
+ """Call VIM to get sfs status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ sf_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_sfs_status(sf_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-sf: vimconnException when trying to refresh sfs {}".format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-sf: vim_sf_id={} result={}".format(task_id, task["vim_id"], vim_info))
+ #TODO: Revise this part
+ vim_info_error_msg = None
+ if vim_info.get("error_msg"):
+ vim_info_error_msg = self._format_vim_error_msg(vim_info["error_msg"])
+ task_vim_info = task["extra"].get("vim_info")
+ task_error_msg = task.get("error_msg")
+ task_vim_status = task["extra"].get("vim_status")
+ if task_vim_status != vim_info["status"] or task_error_msg != vim_info_error_msg or \
+ (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["vim_info"] = vim_info["vim_info"]
+
+ task["extra"]["vim_status"] = vim_info["status"]
+ task["error_msg"] = vim_info_error_msg
+ if vim_info.get("vim_info"):
+ task["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
+
+ def _refres_classifications(self, task):
+ """Call VIM to get classifications status"""
+ database_update = None
+
+ vim_id = task["vim_id"]
+ classification_to_refresh_list = [vim_id]
+ task_id = task["instance_action_id"] + "." + str(task["task_index"])
+ try:
+ vim_dict = self.vim.refresh_classifications_status(classification_to_refresh_list)
+ vim_info = vim_dict[vim_id]
+ except vimconn.vimconnException as e:
+ # Mark all tasks at VIM_ERROR status
+ self.logger.error("task={} get-classification: vimconnException when trying to refresh classifications {}"
+ .format(task_id, e))
+ vim_info = {"status": "VIM_ERROR", "error_msg": str(e)}
+
+ self.logger.debug("task={} get-classification: vim_classification_id={} result={}".format(task_id,
+ task["vim_id"], vim_info))
+ #TODO: Revise this part
+ vim_info_error_msg = None
+ if vim_info.get("error_msg"):
+ vim_info_error_msg = self._format_vim_error_msg(vim_info["error_msg"])
+ task_vim_info = task["extra"].get("vim_info")
+ task_error_msg = task.get("error_msg")
+ task_vim_status = task["extra"].get("vim_status")
+ if task_vim_status != vim_info["status"] or task_error_msg != vim_info_error_msg or \
+ (vim_info.get("vim_info") and task_vim_info != vim_info["vim_info"]):
+ database_update = {"status": vim_info["status"], "error_msg": vim_info_error_msg}
+ if vim_info.get("vim_info"):
+ database_update["vim_info"] = vim_info["vim_info"]
+
+ task["extra"]["vim_status"] = vim_info["status"]
+ task["error_msg"] = vim_info_error_msg
+ if vim_info.get("vim_info"):
+ task["extra"]["vim_info"] = vim_info["vim_info"]
+
+ return database_update
__author__ = "Alfonso Tierno, Igor D.C."
__date__ = "$14-aug-2017 23:59:59$"
-#Error variables
+#Error variables
HTTP_Bad_Request = 400
-HTTP_Unauthorized = 401
-HTTP_Not_Found = 404
-HTTP_Method_Not_Allowed = 405
+HTTP_Unauthorized = 401
+HTTP_Not_Found = 404
+HTTP_Method_Not_Allowed = 405
HTTP_Request_Timeout = 408
HTTP_Conflict = 409
HTTP_Not_Implemented = 501
-HTTP_Service_Unavailable = 503
-HTTP_Internal_Server_Error = 500
+HTTP_Service_Unavailable = 503
+HTTP_Internal_Server_Error = 500
class vimconnException(Exception):
class vimconnector():
"""Abstract base class for all the VIM connector plugins
- These plugins must implement a vimconnector class derived from this
+ These plugins must implement a vimconnector class derived from this
and all these privated methods
- """
+ """
def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None,
config={}, persitent_info={}):
"""
self.logger.setLevel(getattr(logging, log_level))
if not self.url_admin: # try to use normal url
self.url_admin = self.url
-
+
def __getitem__(self, index):
if index == 'tenant_id':
return self.tenant_id
return self.config
else:
raise KeyError("Invalid key '{}'".format(index))
-
+
def __setitem__(self, index, value):
if index == 'tenant_id':
self.tenant_id = value
- name: interface name
dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
bandwidth: X Gbps; requested guarantee bandwidth
- vpci: requested virtual PCI address
+ vpci: requested virtual PCI address
disk: disk size
is_public:
#TODO to concrete
Returns the image_id or raises a vimconnNotFoundException
"""
raise vimconnNotImplemented("Should have implemented this")
-
+
def get_image_list(self, filter_dict={}):
"""Obtain tenant images from VIM
Filter_dict can be:
as not present.
"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
def get_vminstance(self,vm_id):
"""Returns the VM instance information from VIM"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
def delete_vminstance(self, vm_id, created_items=None):
"""
Removes a VM instance from VIM and its associated elements
vm_id: #VIM id of this Virtual Machine
status: #Mandatory. Text with one of:
# DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
# OTHER (Vim reported other status not understood)
# ERROR (VIM indicates an ERROR status)
- # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
+ # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
# BUILD (on building process), ERROR
# ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
#
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
interfaces: list with interface info. Each item a dictionary with:
vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
vlan: #physical VLAN used for VF
"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
def action_vminstance(self, vm_id, action_dict, created_items={}):
"""
Send and action over a VM instance. Returns created_items if the action was successfully sent to the VIM.
:return: None, or a console dict
"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
def get_vminstance_console(self, vm_id, console_type="vnc"):
"""
Get a console for the virtual machine
Params:
vm_id: uuid of the VM
console_type, can be:
- "novnc" (by default), "xvpvnc" for VNC types,
+ "novnc" (by default), "xvpvnc" for VNC types,
"rdp-html5" for RDP types, "spice-html5" for SPICE types
Returns dict with the console parameters:
protocol: ssh, ftp, http, https, ...
- server: usually ip address
- port: the http, ssh, ... port
- suffix: extra text, e.g. the http path and query string
+ server: usually ip address
+ port: the http, ssh, ... port
+ suffix: extra text, e.g. the http path and query string
"""
raise vimconnNotImplemented( "Should have implemented this" )
"""
raise vimconnNotImplemented( "SFC support not implemented" )
+ def refresh_classifications_status(self, classification_list):
+ '''Get the status of the classifications
+ Params: the list of classification identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this classifier
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
+ '''
+ raise vimconnNotImplemented("Should have implemented this")
+
def delete_classification(self, classification_id):
"""Deletes a classification from the VIM
Returns the classification ID (classification_id) or raises an exception upon error or when classification is not found
"""
raise vimconnNotImplemented( "SFC support not implemented" )
+ def refresh_sfis_status(self, sfi_list):
+ '''Get the status of the service function instances
+ Params: the list of sfi identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this service function instance
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
+ '''
+ raise vimconnNotImplemented("Should have implemented this")
+
def new_sf(self, name, sfis, sfc_encap=True):
"""Creates (an abstract) service function in the VIM
Params:
"""
raise vimconnNotImplemented( "SFC support not implemented" )
+ def refresh_sfs_status(self, sf_list):
+ '''Get the status of the service functions
+ Params: the list of sf identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this service function
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
+ '''
+ raise vimconnNotImplemented("Should have implemented this")
+
def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
"""Creates a service function path
Params:
"""
raise vimconnNotImplemented( "SFC support not implemented" )
+ def refresh_sfps_status(self, sfp_list):
+ '''Get the status of the service function path
+ Params: the list of sfp identifiers
+ Returns a dictionary with:
+ vm_id: #VIM id of this service function path
+ status: #Mandatory. Text with one of:
+ # DELETED (not found at vim)
+ # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+ # OTHER (Vim reported other status not understood)
+ # ERROR (VIM indicates an ERROR status)
+ # ACTIVE,
+ # CREATING (on building process)
+ error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
+ vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
+ '''
+ raise vimconnNotImplemented("Should have implemented this")
+
def delete_sfp(self, sfp_id):
"""Deletes a service function path from the VIM
Returns the sfp ID (sfp_id) or raises an exception upon error or when sf is not found
def get_processor_rankings(self):
"""Get the processor rankings in the VIM database"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
@deprecated
def new_host(self, host_data):
"""Adds a new host to VIM"""
"""Returns status code of the VIM response"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
@deprecated
def new_external_port(self, port_data):
"""Adds a external port to VIM"""
"""Returns the port identifier"""
raise vimconnNotImplemented( "Should have implemented this" )
-
+
@deprecated
def new_external_network(self,net_name,net_type):
"""Adds a external network to VIM (shared)"""
"""Adds a VM instance to VIM"""
"""Returns the instance identifier"""
raise vimconnNotImplemented( "Should have implemented this" )
-
projects / osm / RO.git / commitdiff