1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
5 # This file is part of openmano
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact with: nfvlabs@tid.es
25 vimconn implement an Abstract class for the vim connector plugins
26 with the definition of the method to be implemented.
28 __author__
="Alfonso Tierno, Igor D.C."
29 __date__
="$14-aug-2017 23:59:59$"
34 HTTP_Bad_Request
= 400
35 HTTP_Unauthorized
= 401
37 HTTP_Method_Not_Allowed
= 405
38 HTTP_Request_Timeout
= 408
40 HTTP_Not_Implemented
= 501
41 HTTP_Service_Unavailable
= 503
42 HTTP_Internal_Server_Error
= 500
44 class vimconnException(Exception):
45 """Common and base class Exception for all vimconnector exceptions"""
46 def __init__(self
, message
, http_code
=HTTP_Bad_Request
):
47 Exception.__init
__(self
, message
)
48 self
.http_code
= http_code
50 class vimconnConnectionException(vimconnException
):
51 """Connectivity error with the VIM"""
52 def __init__(self
, message
, http_code
=HTTP_Service_Unavailable
):
53 vimconnException
.__init
__(self
, message
, http_code
)
55 class vimconnUnexpectedResponse(vimconnException
):
56 """Get an wrong response from VIM"""
57 def __init__(self
, message
, http_code
=HTTP_Service_Unavailable
):
58 vimconnException
.__init
__(self
, message
, http_code
)
60 class vimconnAuthException(vimconnException
):
61 """Invalid credentials or authorization to perform this action over the VIM"""
62 def __init__(self
, message
, http_code
=HTTP_Unauthorized
):
63 vimconnException
.__init
__(self
, message
, http_code
)
65 class vimconnNotFoundException(vimconnException
):
66 """The item is not found at VIM"""
67 def __init__(self
, message
, http_code
=HTTP_Not_Found
):
68 vimconnException
.__init
__(self
, message
, http_code
)
70 class vimconnConflictException(vimconnException
):
71 """There is a conflict, e.g. more item found than one"""
72 def __init__(self
, message
, http_code
=HTTP_Conflict
):
73 vimconnException
.__init
__(self
, message
, http_code
)
75 class vimconnNotSupportedException(vimconnException
):
76 """The request is not supported by connector"""
77 def __init__(self
, message
, http_code
=HTTP_Service_Unavailable
):
78 vimconnException
.__init
__(self
, message
, http_code
)
80 class vimconnNotImplemented(vimconnException
):
81 """The method is not implemented by the connected"""
82 def __init__(self
, message
, http_code
=HTTP_Not_Implemented
):
83 vimconnException
.__init
__(self
, message
, http_code
)
87 """Abstract base class for all the VIM connector plugins
88 These plugins must implement a vimconnector class derived from this
89 and all these privated methods
91 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None, log_level
=None,
92 config
={}, persitent_info
={}):
95 'uuid': id asigned to this VIM
96 'name': name assigned to this VIM, can be used for logging
97 'tenant_id', 'tenant_name': (only one of them is mandatory) VIM tenant to be used
98 'url_admin': (optional), url used for administrative tasks
99 'user', 'passwd': credentials of the VIM user
100 'log_level': provider if it should use a different log_level than the general one
101 'config': dictionary with extra VIM information. This contains a consolidate version of general VIM config
102 at creation and particular VIM config at teh attachment
103 'persistent_info': dict where the class can store information that will be available among class
104 destroy/creation cycles. This info is unique per VIM/credential. At first call it will contain an
105 empty dict. Useful to store login/tokens information for speed up communication
107 Returns: Raise an exception is some needed parameter is missing, but it must not do any connectivity
108 check against the VIM
113 self
.url_admin
= url_admin
114 self
.tenant_id
= tenant_id
115 self
.tenant_name
= tenant_name
119 self
.availability_zone
= None
120 self
.logger
= logging
.getLogger('openmano.vim')
122 self
.logger
.setLevel( getattr(logging
, log_level
) )
123 if not self
.url_admin
: #try to use normal url
124 self
.url_admin
= self
.url
126 def __getitem__(self
,index
):
127 if index
=='tenant_id':
128 return self
.tenant_id
129 if index
=='tenant_name':
130 return self
.tenant_name
137 elif index
=='passwd':
141 elif index
=='url_admin':
142 return self
.url_admin
143 elif index
=="config":
146 raise KeyError("Invalid key '%s'" %str
(index
))
148 def __setitem__(self
,index
, value
):
149 if index
=='tenant_id':
150 self
.tenant_id
= value
151 if index
=='tenant_name':
152 self
.tenant_name
= value
159 elif index
=='passwd':
163 elif index
=='url_admin':
164 self
.url_admin
= value
166 raise KeyError("Invalid key '%s'" %str
(index
))
168 def check_vim_connectivity(self
):
169 """Checks VIM can be reached and user credentials are ok.
170 Returns None if success or raised vimconnConnectionException, vimconnAuthException, ...
172 raise vimconnNotImplemented( "Should have implemented this" )
174 def new_tenant(self
,tenant_name
,tenant_description
):
175 """Adds a new tenant to VIM with this name and description, this is done using admin_url if provided
176 "tenant_name": string max lenght 64
177 "tenant_description": string max length 256
178 returns the tenant identifier or raise exception
180 raise vimconnNotImplemented( "Should have implemented this" )
182 def delete_tenant(self
,tenant_id
,):
183 """Delete a tenant from VIM
184 tenant_id: returned VIM tenant_id on "new_tenant"
185 Returns None on success. Raises and exception of failure. If tenant is not found raises vimconnNotFoundException
187 raise vimconnNotImplemented( "Should have implemented this" )
189 def get_tenant_list(self
, filter_dict
={}):
190 """Obtain tenants of VIM
191 filter_dict dictionary that can contain the following keys:
192 name: filter by tenant name
193 id: filter by tenant uuid/id
195 Returns the tenant list of dictionaries, and empty list if no tenant match all the filers:
196 [{'name':'<name>, 'id':'<id>, ...}, ...]
198 raise vimconnNotImplemented( "Should have implemented this" )
200 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
201 """Adds a tenant network to VIM
203 'net_name': name of the network
205 'bridge': overlay isolated network
206 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
207 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
208 'ip_profile': is a dict containing the IP parameters of the network (Currently only IPv4 is implemented)
209 'ip-version': can be one of ["IPv4","IPv6"]
210 'subnet-address': ip_prefix_schema, that is X.X.X.X/Y
211 'gateway-address': (Optional) ip_schema, that is X.X.X.X
212 'dns-address': (Optional) ip_schema,
213 'dhcp': (Optional) dict containing
214 'enabled': {"type": "boolean"},
215 'start-address': ip_schema, first IP to grant
216 'count': number of IPs to grant.
217 'shared': if this network can be seen/use by other tenants/organization
218 'vlan': in case of a data or ptp net_type, the intended vlan tag to be used for the network
219 Returns the network identifier on success or raises and exception on failure
221 raise vimconnNotImplemented( "Should have implemented this" )
223 def get_network_list(self
, filter_dict
={}):
224 """Obtain tenant networks of VIM
226 'filter_dict' (optional) contains entries to return only networks that matches ALL entries:
227 name: string => returns only networks with this name
228 id: string => returns networks with this VIM id, this imply returns one network at most
229 shared: boolean >= returns only networks that are (or are not) shared
230 tenant_id: sting => returns only networks that belong to this tenant/project
231 ,#(not used yet) admin_state_up: boolean => returns only networks that are (or are not) in admin state active
232 #(not used yet) status: 'ACTIVE','ERROR',... => filter networks that are on this status
233 Returns the network list of dictionaries. each dictionary contains:
234 'id': (mandatory) VIM network id
235 'name': (mandatory) VIM network name
236 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
237 'network_type': (optional) can be 'vxlan', 'vlan' or 'flat'
238 'segmentation_id': (optional) in case network_type is vlan or vxlan this field contains the segmentation id
239 'error_msg': (optional) text that explains the ERROR status
240 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
241 List can be empty if no network map the filter_dict. Raise an exception only upon VIM connectivity,
242 authorization, or some other unspecific error
244 raise vimconnNotImplemented( "Should have implemented this" )
246 def get_network(self
, net_id
):
247 """Obtain network details from the 'net_id' VIM network
248 Return a dict that contains:
249 'id': (mandatory) VIM network id, that is, net_id
250 'name': (mandatory) VIM network name
251 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
252 'error_msg': (optional) text that explains the ERROR status
253 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
254 Raises an exception upon error or when network is not found
256 raise vimconnNotImplemented( "Should have implemented this" )
258 def delete_network(self
, net_id
):
259 """Deletes a tenant network from VIM
260 Returns the network identifier or raises an exception upon error or when network is not found
262 raise vimconnNotImplemented( "Should have implemented this" )
264 def refresh_nets_status(self
, net_list
):
265 """Get the status of the networks
267 'net_list': a list with the VIM network id to be get the status
268 Returns a dictionary with:
269 'net_id': #VIM id of this network
270 status: #Mandatory. Text with one of:
271 # DELETED (not found at vim)
272 # VIM_ERROR (Cannot connect to VIM, authentication problems, VIM response error, ...)
273 # OTHER (Vim reported other status not understood)
274 # ERROR (VIM indicates an ERROR status)
275 # ACTIVE, INACTIVE, DOWN (admin down),
276 # BUILD (on building process)
277 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
278 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
281 raise vimconnNotImplemented( "Should have implemented this" )
283 def get_flavor(self
, flavor_id
):
284 """Obtain flavor details from the VIM
285 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific }
286 Raises an exception upon error or if not found
288 raise vimconnNotImplemented( "Should have implemented this" )
290 def get_flavor_id_from_data(self
, flavor_dict
):
291 """Obtain flavor id that match the flavor description
293 'flavor_dict': dictionary that contains:
294 'disk': main hard disk in GB
296 'vcpus': number of virtual cpus
297 #TODO: complete parameters for EPA
298 Returns the flavor_id or raises a vimconnNotFoundException
300 raise vimconnNotImplemented( "Should have implemented this" )
302 def new_flavor(self
, flavor_data
):
303 """Adds a tenant flavor to VIM
304 flavor_data contains a dictionary with information, keys:
306 ram: memory (cloud type) in MBytes
307 vpcus: cpus (cloud type)
308 extended: EPA parameters
309 - numas: #items requested in same NUMA
310 memory: number of 1G huge pages memory
311 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
312 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
313 - name: interface name
314 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
315 bandwidth: X Gbps; requested guarantee bandwidth
316 vpci: requested virtual PCI address
320 Returns the flavor identifier"""
321 raise vimconnNotImplemented( "Should have implemented this" )
323 def delete_flavor(self
, flavor_id
):
324 """Deletes a tenant flavor from VIM identify by its id
325 Returns the used id or raise an exception"""
326 raise vimconnNotImplemented( "Should have implemented this" )
328 def new_image(self
, image_dict
):
329 """ Adds a tenant image to VIM
330 Returns the image id or raises an exception if failed
332 raise vimconnNotImplemented( "Should have implemented this" )
334 def delete_image(self
, image_id
):
335 """Deletes a tenant image from VIM
336 Returns the image_id if image is deleted or raises an exception on error"""
337 raise vimconnNotImplemented( "Should have implemented this" )
339 def get_image_id_from_path(self
, path
):
340 """Get the image id from image path in the VIM database.
341 Returns the image_id or raises a vimconnNotFoundException
343 raise vimconnNotImplemented( "Should have implemented this" )
345 def get_image_list(self
, filter_dict
={}):
346 """Obtain tenant images from VIM
350 checksum: image checksum
352 Returns the image list of dictionaries:
353 [{<the fields at Filter_dict plus some VIM specific>}, ...]
356 raise vimconnNotImplemented( "Should have implemented this" )
358 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
359 availability_zone_index
=None, availability_zone_list
=None):
360 """Adds a VM instance to VIM
362 'start': (boolean) indicates if VM must start or created in pause mode.
363 'image_id','flavor_id': image and flavor VIM id to use for the VM
364 'net_list': list of interfaces, each one is a dictionary with:
365 'name': (optional) name for the interface.
366 'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
367 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
368 'model': (optional and only have sense for type==virtual) interface model: virtio, e2000, ...
369 'mac_address': (optional) mac address to assign to this interface
370 #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
371 the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
372 'type': (mandatory) can be one of:
373 'virtual', in this case always connected to a network of type 'net_type=bridge'
374 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
375 can created unconnected
376 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
377 'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
378 are allocated on the same physical NIC
379 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS
380 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing
381 or True, it must apply the default VIM behaviour
382 After execution the method will add the key:
383 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this
384 interface. 'net_list' is modified
385 'cloud_config': (optional) dictionary with:
386 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
387 'users': (optional) list of users to be inserted, each item is a dict with:
388 'name': (mandatory) user name,
389 'key-pairs': (optional) list of strings with the public key to be inserted to the user
390 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
391 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
392 'config-files': (optional). List of files to be transferred. Each item is a dict with:
393 'dest': (mandatory) string with the destination absolute path
394 'encoding': (optional, by default text). Can be one of:
395 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
396 'content' (mandatory): string with the content of the file
397 'permissions': (optional) string with file permissions, typically octal notation '0644'
398 'owner': (optional) file owner, string with the format 'owner:group'
399 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
400 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
401 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
402 'size': (mandatory) string with the size of the disk in GB
403 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
404 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
405 availability_zone_index is None
406 Returns the instance identifier or raises an exception on error
408 raise vimconnNotImplemented( "Should have implemented this" )
410 def get_vminstance(self
,vm_id
):
411 """Returns the VM instance information from VIM"""
412 raise vimconnNotImplemented( "Should have implemented this" )
414 def delete_vminstance(self
, vm_id
):
415 """Removes a VM instance from VIM
416 Returns the instance identifier"""
417 raise vimconnNotImplemented( "Should have implemented this" )
419 def refresh_vms_status(self
, vm_list
):
420 """Get the status of the virtual machines and their interfaces/ports
421 Params: the list of VM identifiers
422 Returns a dictionary with:
423 vm_id: #VIM id of this Virtual Machine
424 status: #Mandatory. Text with one of:
425 # DELETED (not found at vim)
426 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
427 # OTHER (Vim reported other status not understood)
428 # ERROR (VIM indicates an ERROR status)
429 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
430 # BUILD (on building process), ERROR
431 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
433 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
434 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
435 interfaces: list with interface info. Each item a dictionary with:
436 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
437 mac_address: #Text format XX:XX:XX:XX:XX:XX
438 vim_net_id: #network id where this interface is connected, if provided at creation
439 vim_interface_id: #interface/port VIM id
440 ip_address: #null, or text with IPv4, IPv6 address
441 compute_node: #identification of compute node where PF,VF interface is allocated
442 pci: #PCI address of the NIC that hosts the PF,VF
443 vlan: #physical VLAN used for VF
445 raise vimconnNotImplemented( "Should have implemented this" )
447 def action_vminstance(self
, vm_id
, action_dict
):
448 """Send and action over a VM instance from VIM
449 Returns the vm_id if the action was successfully sent to the VIM"""
450 raise vimconnNotImplemented( "Should have implemented this" )
452 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
454 Get a console for the virtual machine
456 vm_id: uuid of the VM
457 console_type, can be:
458 "novnc" (by default), "xvpvnc" for VNC types,
459 "rdp-html5" for RDP types, "spice-html5" for SPICE types
460 Returns dict with the console parameters:
461 protocol: ssh, ftp, http, https, ...
462 server: usually ip address
463 port: the http, ssh, ... port
464 suffix: extra text, e.g. the http path and query string
466 raise vimconnNotImplemented( "Should have implemented this" )
468 def new_classification(self
, name
, ctype
, definition
):
469 """Creates a traffic classification in the VIM
471 'name': name of this classification
472 'ctype': type of this classification
473 'definition': definition of this classification (type-dependent free-form text)
474 Returns the VIM's classification ID on success or raises an exception on failure
476 raise vimconnNotImplemented( "SFC support not implemented" )
478 def get_classification(self
, classification_id
):
479 """Obtain classification details of the VIM's classification with ID='classification_id'
480 Return a dict that contains:
481 'id': VIM's classification ID (same as classification_id)
482 'name': VIM's classification name
483 'type': type of this classification
484 'definition': definition of the classification
485 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
486 'error_msg': (optional) text that explains the ERROR status
487 other VIM specific fields: (optional) whenever possible
488 Raises an exception upon error or when classification is not found
490 raise vimconnNotImplemented( "SFC support not implemented" )
492 def get_classification_list(self
, filter_dict
={}):
493 """Obtain classifications from the VIM
495 'filter_dict' (optional): contains the entries to filter the classifications on and only return those that match ALL:
496 id: string => returns classifications with this VIM's classification ID, which implies a return of one classification at most
497 name: string => returns only classifications with this name
498 type: string => returns classifications of this type
499 definition: string => returns classifications that have this definition
500 tenant_id: string => returns only classifications that belong to this tenant/project
501 Returns a list of classification dictionaries, each dictionary contains:
502 'id': (mandatory) VIM's classification ID
503 'name': (mandatory) VIM's classification name
504 'type': type of this classification
505 'definition': definition of the classification
506 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
507 List can be empty if no classification matches the filter_dict. Raise an exception only upon VIM connectivity,
508 authorization, or some other unspecific error
510 raise vimconnNotImplemented( "SFC support not implemented" )
512 def delete_classification(self
, classification_id
):
513 """Deletes a classification from the VIM
514 Returns the classification ID (classification_id) or raises an exception upon error or when classification is not found
516 raise vimconnNotImplemented( "SFC support not implemented" )
518 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
519 """Creates a service function instance in the VIM
521 'name': name of this service function instance
522 'ingress_ports': set of ingress ports (VIM's port IDs)
523 'egress_ports': set of egress ports (VIM's port IDs)
524 'sfc_encap': boolean stating whether this specific instance supports IETF SFC Encapsulation
525 Returns the VIM's service function instance ID on success or raises an exception on failure
527 raise vimconnNotImplemented( "SFC support not implemented" )
529 def get_sfi(self
, sfi_id
):
530 """Obtain service function instance details of the VIM's service function instance with ID='sfi_id'
531 Return a dict that contains:
532 'id': VIM's sfi ID (same as sfi_id)
533 'name': VIM's sfi name
534 'ingress_ports': set of ingress ports (VIM's port IDs)
535 'egress_ports': set of egress ports (VIM's port IDs)
536 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
537 'error_msg': (optional) text that explains the ERROR status
538 other VIM specific fields: (optional) whenever possible
539 Raises an exception upon error or when service function instance is not found
541 raise vimconnNotImplemented( "SFC support not implemented" )
543 def get_sfi_list(self
, filter_dict
={}):
544 """Obtain service function instances from the VIM
546 'filter_dict' (optional): contains the entries to filter the sfis on and only return those that match ALL:
547 id: string => returns sfis with this VIM's sfi ID, which implies a return of one sfi at most
548 name: string => returns only service function instances with this name
549 tenant_id: string => returns only service function instances that belong to this tenant/project
550 Returns a list of service function instance dictionaries, each dictionary contains:
551 'id': (mandatory) VIM's sfi ID
552 'name': (mandatory) VIM's sfi name
553 'ingress_ports': set of ingress ports (VIM's port IDs)
554 'egress_ports': set of egress ports (VIM's port IDs)
555 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
556 List can be empty if no sfi matches the filter_dict. Raise an exception only upon VIM connectivity,
557 authorization, or some other unspecific error
559 raise vimconnNotImplemented( "SFC support not implemented" )
561 def delete_sfi(self
, sfi_id
):
562 """Deletes a service function instance from the VIM
563 Returns the service function instance ID (sfi_id) or raises an exception upon error or when sfi is not found
565 raise vimconnNotImplemented( "SFC support not implemented" )
567 def new_sf(self
, name
, sfis
, sfc_encap
=True):
568 """Creates (an abstract) service function in the VIM
570 'name': name of this service function
571 'sfis': set of service function instances of this (abstract) service function
572 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
573 Returns the VIM's service function ID on success or raises an exception on failure
575 raise vimconnNotImplemented( "SFC support not implemented" )
577 def get_sf(self
, sf_id
):
578 """Obtain service function details of the VIM's service function with ID='sf_id'
579 Return a dict that contains:
580 'id': VIM's sf ID (same as sf_id)
581 'name': VIM's sf name
582 'sfis': VIM's sf's set of VIM's service function instance IDs
583 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
584 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
585 'error_msg': (optional) text that explains the ERROR status
586 other VIM specific fields: (optional) whenever possible
587 Raises an exception upon error or when sf is not found
590 def get_sf_list(self
, filter_dict
={}):
591 """Obtain service functions from the VIM
593 'filter_dict' (optional): contains the entries to filter the sfs on and only return those that match ALL:
594 id: string => returns sfs with this VIM's sf ID, which implies a return of one sf at most
595 name: string => returns only service functions with this name
596 tenant_id: string => returns only service functions that belong to this tenant/project
597 Returns a list of service function dictionaries, each dictionary contains:
598 'id': (mandatory) VIM's sf ID
599 'name': (mandatory) VIM's sf name
600 'sfis': VIM's sf's set of VIM's service function instance IDs
601 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
602 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
603 List can be empty if no sf matches the filter_dict. Raise an exception only upon VIM connectivity,
604 authorization, or some other unspecific error
606 raise vimconnNotImplemented( "SFC support not implemented" )
608 def delete_sf(self
, sf_id
):
609 """Deletes (an abstract) service function from the VIM
610 Returns the service function ID (sf_id) or raises an exception upon error or when sf is not found
612 raise vimconnNotImplemented( "SFC support not implemented" )
615 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
616 """Creates a service function path
618 'name': name of this service function path
619 'classifications': set of traffic classifications that should be matched on to get into this sfp
620 'sfs': list of every service function that constitutes this path , from first to last
621 'sfc_encap': whether this is an SFC-Encapsulated chain (i.e using NSH), True by default
622 'spi': (optional) the Service Function Path identifier (SPI: Service Path Identifier) for this path
623 Returns the VIM's sfp ID on success or raises an exception on failure
625 raise vimconnNotImplemented( "SFC support not implemented" )
627 def get_sfp(self
, sfp_id
):
628 """Obtain service function path details of the VIM's sfp with ID='sfp_id'
629 Return a dict that contains:
630 'id': VIM's sfp ID (same as sfp_id)
631 'name': VIM's sfp name
632 'classifications': VIM's sfp's list of VIM's classification IDs
633 'sfs': VIM's sfp's list of VIM's service function IDs
634 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
635 'error_msg': (optional) text that explains the ERROR status
636 other VIM specific fields: (optional) whenever possible
637 Raises an exception upon error or when sfp is not found
639 raise vimconnNotImplemented( "SFC support not implemented" )
641 def get_sfp_list(self
, filter_dict
={}):
642 """Obtain service function paths from VIM
644 'filter_dict' (optional): contains the entries to filter the sfps on, and only return those that match ALL:
645 id: string => returns sfps with this VIM's sfp ID , which implies a return of one sfp at most
646 name: string => returns only sfps with this name
647 tenant_id: string => returns only sfps that belong to this tenant/project
648 Returns a list of service function path dictionaries, each dictionary contains:
649 'id': (mandatory) VIM's sfp ID
650 'name': (mandatory) VIM's sfp name
651 'classifications': VIM's sfp's list of VIM's classification IDs
652 'sfs': VIM's sfp's list of VIM's service function IDs
653 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
654 List can be empty if no sfp matches the filter_dict. Raise an exception only upon VIM connectivity,
655 authorization, or some other unspecific error
657 raise vimconnNotImplemented( "SFC support not implemented" )
659 def delete_sfp(self
, sfp_id
):
660 """Deletes a service function path from the VIM
661 Returns the sfp ID (sfp_id) or raises an exception upon error or when sf is not found
663 raise vimconnNotImplemented( "SFC support not implemented" )
665 #NOT USED METHODS in current version
667 def host_vim2gui(self
, host
, server_dict
):
668 """Transform host dictionary from VIM format to GUI format,
669 and append to the server_dict
671 raise vimconnNotImplemented( "Should have implemented this" )
673 def get_hosts_info(self
):
674 """Get the information of deployed hosts
675 Returns the hosts content"""
676 raise vimconnNotImplemented( "Should have implemented this" )
678 def get_hosts(self
, vim_tenant
):
679 """Get the hosts and deployed instances
680 Returns the hosts content"""
681 raise vimconnNotImplemented( "Should have implemented this" )
683 def get_processor_rankings(self
):
684 """Get the processor rankings in the VIM database"""
685 raise vimconnNotImplemented( "Should have implemented this" )
687 def new_host(self
, host_data
):
688 """Adds a new host to VIM"""
689 """Returns status code of the VIM response"""
690 raise vimconnNotImplemented( "Should have implemented this" )
692 def new_external_port(self
, port_data
):
693 """Adds a external port to VIM"""
694 """Returns the port identifier"""
695 raise vimconnNotImplemented( "Should have implemented this" )
697 def new_external_network(self
,net_name
,net_type
):
698 """Adds a external network to VIM (shared)"""
699 """Returns the network identifier"""
700 raise vimconnNotImplemented( "Should have implemented this" )
702 def connect_port_network(self
, port_id
, network_id
, admin
=False):
703 """Connects a external port to a network"""
704 """Returns status code of the VIM response"""
705 raise vimconnNotImplemented( "Should have implemented this" )
707 def new_vminstancefromJSON(self
, vm_data
):
708 """Adds a VM instance to VIM"""
709 """Returns the instance identifier"""
710 raise vimconnNotImplemented( "Should have implemented this" )