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$"
37 HTTP_Bad_Request
= 400
38 HTTP_Unauthorized
= 401
40 HTTP_Method_Not_Allowed
= 405
41 HTTP_Request_Timeout
= 408
43 HTTP_Not_Implemented
= 501
44 HTTP_Service_Unavailable
= 503
45 HTTP_Internal_Server_Error
= 500
47 class vimconnException(Exception):
48 """Common and base class Exception for all vimconnector exceptions"""
49 def __init__(self
, message
, http_code
=HTTP_Bad_Request
):
50 Exception.__init
__(self
, message
)
51 self
.http_code
= http_code
53 class vimconnConnectionException(vimconnException
):
54 """Connectivity error with the VIM"""
55 def __init__(self
, message
, http_code
=HTTP_Service_Unavailable
):
56 vimconnException
.__init
__(self
, message
, http_code
)
58 class vimconnUnexpectedResponse(vimconnException
):
59 """Get an wrong response from VIM"""
60 def __init__(self
, message
, http_code
=HTTP_Service_Unavailable
):
61 vimconnException
.__init
__(self
, message
, http_code
)
63 class vimconnAuthException(vimconnException
):
64 """Invalid credentials or authorization to perform this action over the VIM"""
65 def __init__(self
, message
, http_code
=HTTP_Unauthorized
):
66 vimconnException
.__init
__(self
, message
, http_code
)
68 class vimconnNotFoundException(vimconnException
):
69 """The item is not found at VIM"""
70 def __init__(self
, message
, http_code
=HTTP_Not_Found
):
71 vimconnException
.__init
__(self
, message
, http_code
)
73 class vimconnConflictException(vimconnException
):
74 """There is a conflict, e.g. more item found than one"""
75 def __init__(self
, message
, http_code
=HTTP_Conflict
):
76 vimconnException
.__init
__(self
, message
, http_code
)
78 class vimconnNotSupportedException(vimconnException
):
79 """The request is not supported by connector"""
80 def __init__(self
, message
, http_code
=HTTP_Service_Unavailable
):
81 vimconnException
.__init
__(self
, message
, http_code
)
83 class vimconnNotImplemented(vimconnException
):
84 """The method is not implemented by the connected"""
85 def __init__(self
, message
, http_code
=HTTP_Not_Implemented
):
86 vimconnException
.__init
__(self
, message
, http_code
)
90 """Abstract base class for all the VIM connector plugins
91 These plugins must implement a vimconnector class derived from this
92 and all these privated methods
94 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None, log_level
=None,
95 config
={}, persitent_info
={}):
98 'uuid': id asigned to this VIM
99 'name': name assigned to this VIM, can be used for logging
100 'tenant_id', 'tenant_name': (only one of them is mandatory) VIM tenant to be used
101 'url_admin': (optional), url used for administrative tasks
102 'user', 'passwd': credentials of the VIM user
103 'log_level': provider if it should use a different log_level than the general one
104 'config': dictionary with extra VIM information. This contains a consolidate version of general VIM config
105 at creation and particular VIM config at teh attachment
106 'persistent_info': dict where the class can store information that will be available among class
107 destroy/creation cycles. This info is unique per VIM/credential. At first call it will contain an
108 empty dict. Useful to store login/tokens information for speed up communication
110 Returns: Raise an exception is some needed parameter is missing, but it must not do any connectivity
111 check against the VIM
116 self
.url_admin
= url_admin
117 self
.tenant_id
= tenant_id
118 self
.tenant_name
= tenant_name
122 self
.availability_zone
= None
123 self
.logger
= logging
.getLogger('openmano.vim')
125 self
.logger
.setLevel( getattr(logging
, log_level
) )
126 if not self
.url_admin
: #try to use normal url
127 self
.url_admin
= self
.url
129 def __getitem__(self
,index
):
130 if index
=='tenant_id':
131 return self
.tenant_id
132 if index
=='tenant_name':
133 return self
.tenant_name
140 elif index
=='passwd':
144 elif index
=='url_admin':
145 return self
.url_admin
146 elif index
=="config":
149 raise KeyError("Invalid key '%s'" %str
(index
))
151 def __setitem__(self
,index
, value
):
152 if index
=='tenant_id':
153 self
.tenant_id
= value
154 if index
=='tenant_name':
155 self
.tenant_name
= value
162 elif index
=='passwd':
166 elif index
=='url_admin':
167 self
.url_admin
= value
169 raise KeyError("Invalid key '%s'" %str
(index
))
171 def check_vim_connectivity(self
):
172 """Checks VIM can be reached and user credentials are ok.
173 Returns None if success or raised vimconnConnectionException, vimconnAuthException, ...
175 raise vimconnNotImplemented( "Should have implemented this" )
177 def new_tenant(self
,tenant_name
,tenant_description
):
178 """Adds a new tenant to VIM with this name and description, this is done using admin_url if provided
179 "tenant_name": string max lenght 64
180 "tenant_description": string max length 256
181 returns the tenant identifier or raise exception
183 raise vimconnNotImplemented( "Should have implemented this" )
185 def delete_tenant(self
,tenant_id
,):
186 """Delete a tenant from VIM
187 tenant_id: returned VIM tenant_id on "new_tenant"
188 Returns None on success. Raises and exception of failure. If tenant is not found raises vimconnNotFoundException
190 raise vimconnNotImplemented( "Should have implemented this" )
192 def get_tenant_list(self
, filter_dict
={}):
193 """Obtain tenants of VIM
194 filter_dict dictionary that can contain the following keys:
195 name: filter by tenant name
196 id: filter by tenant uuid/id
198 Returns the tenant list of dictionaries, and empty list if no tenant match all the filers:
199 [{'name':'<name>, 'id':'<id>, ...}, ...]
201 raise vimconnNotImplemented( "Should have implemented this" )
203 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
204 """Adds a tenant network to VIM
206 'net_name': name of the network
208 'bridge': overlay isolated network
209 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
210 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
211 'ip_profile': is a dict containing the IP parameters of the network (Currently only IPv4 is implemented)
212 'ip-version': can be one of ["IPv4","IPv6"]
213 'subnet-address': ip_prefix_schema, that is X.X.X.X/Y
214 'gateway-address': (Optional) ip_schema, that is X.X.X.X
215 'dns-address': (Optional) ip_schema,
216 'dhcp': (Optional) dict containing
217 'enabled': {"type": "boolean"},
218 'start-address': ip_schema, first IP to grant
219 'count': number of IPs to grant.
220 'shared': if this network can be seen/use by other tenants/organization
221 'vlan': in case of a data or ptp net_type, the intended vlan tag to be used for the network
222 Returns the network identifier on success or raises and exception on failure
224 raise vimconnNotImplemented( "Should have implemented this" )
226 def get_network_list(self
, filter_dict
={}):
227 """Obtain tenant networks of VIM
229 'filter_dict' (optional) contains entries to return only networks that matches ALL entries:
230 name: string => returns only networks with this name
231 id: string => returns networks with this VIM id, this imply returns one network at most
232 shared: boolean >= returns only networks that are (or are not) shared
233 tenant_id: sting => returns only networks that belong to this tenant/project
234 ,#(not used yet) admin_state_up: boolean => returns only networks that are (or are not) in admin state active
235 #(not used yet) status: 'ACTIVE','ERROR',... => filter networks that are on this status
236 Returns the network list of dictionaries. each dictionary contains:
237 'id': (mandatory) VIM network id
238 'name': (mandatory) VIM network name
239 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
240 'network_type': (optional) can be 'vxlan', 'vlan' or 'flat'
241 'segmentation_id': (optional) in case network_type is vlan or vxlan this field contains the segmentation id
242 'error_msg': (optional) text that explains the ERROR status
243 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
244 List can be empty if no network map the filter_dict. Raise an exception only upon VIM connectivity,
245 authorization, or some other unspecific error
247 raise vimconnNotImplemented( "Should have implemented this" )
249 def get_network(self
, net_id
):
250 """Obtain network details from the 'net_id' VIM network
251 Return a dict that contains:
252 'id': (mandatory) VIM network id, that is, net_id
253 'name': (mandatory) VIM network name
254 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
255 'error_msg': (optional) text that explains the ERROR status
256 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
257 Raises an exception upon error or when network is not found
259 raise vimconnNotImplemented( "Should have implemented this" )
261 def delete_network(self
, net_id
):
262 """Deletes a tenant network from VIM
263 Returns the network identifier or raises an exception upon error or when network is not found
265 raise vimconnNotImplemented( "Should have implemented this" )
267 def refresh_nets_status(self
, net_list
):
268 """Get the status of the networks
270 'net_list': a list with the VIM network id to be get the status
271 Returns a dictionary with:
272 'net_id': #VIM id of this network
273 status: #Mandatory. Text with one of:
274 # DELETED (not found at vim)
275 # VIM_ERROR (Cannot connect to VIM, authentication problems, VIM response error, ...)
276 # OTHER (Vim reported other status not understood)
277 # ERROR (VIM indicates an ERROR status)
278 # ACTIVE, INACTIVE, DOWN (admin down),
279 # BUILD (on building process)
280 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
281 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
284 raise vimconnNotImplemented( "Should have implemented this" )
286 def get_flavor(self
, flavor_id
):
287 """Obtain flavor details from the VIM
288 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific }
289 Raises an exception upon error or if not found
291 raise vimconnNotImplemented( "Should have implemented this" )
293 def get_flavor_id_from_data(self
, flavor_dict
):
294 """Obtain flavor id that match the flavor description
296 'flavor_dict': dictionary that contains:
297 'disk': main hard disk in GB
299 'vcpus': number of virtual cpus
300 #TODO: complete parameters for EPA
301 Returns the flavor_id or raises a vimconnNotFoundException
303 raise vimconnNotImplemented( "Should have implemented this" )
305 def new_flavor(self
, flavor_data
):
306 """Adds a tenant flavor to VIM
307 flavor_data contains a dictionary with information, keys:
309 ram: memory (cloud type) in MBytes
310 vpcus: cpus (cloud type)
311 extended: EPA parameters
312 - numas: #items requested in same NUMA
313 memory: number of 1G huge pages memory
314 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
315 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
316 - name: interface name
317 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
318 bandwidth: X Gbps; requested guarantee bandwidth
319 vpci: requested virtual PCI address
323 Returns the flavor identifier"""
324 raise vimconnNotImplemented( "Should have implemented this" )
326 def delete_flavor(self
, flavor_id
):
327 """Deletes a tenant flavor from VIM identify by its id
328 Returns the used id or raise an exception"""
329 raise vimconnNotImplemented( "Should have implemented this" )
331 def new_image(self
, image_dict
):
332 """ Adds a tenant image to VIM
333 Returns the image id or raises an exception if failed
335 raise vimconnNotImplemented( "Should have implemented this" )
337 def delete_image(self
, image_id
):
338 """Deletes a tenant image from VIM
339 Returns the image_id if image is deleted or raises an exception on error"""
340 raise vimconnNotImplemented( "Should have implemented this" )
342 def get_image_id_from_path(self
, path
):
343 """Get the image id from image path in the VIM database.
344 Returns the image_id or raises a vimconnNotFoundException
346 raise vimconnNotImplemented( "Should have implemented this" )
348 def get_image_list(self
, filter_dict
={}):
349 """Obtain tenant images from VIM
353 checksum: image checksum
355 Returns the image list of dictionaries:
356 [{<the fields at Filter_dict plus some VIM specific>}, ...]
359 raise vimconnNotImplemented( "Should have implemented this" )
361 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
362 availability_zone_index
=None, availability_zone_list
=None):
363 """Adds a VM instance to VIM
365 'start': (boolean) indicates if VM must start or created in pause mode.
366 'image_id','flavor_id': image and flavor VIM id to use for the VM
367 'net_list': list of interfaces, each one is a dictionary with:
368 'name': (optional) name for the interface.
369 'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
370 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
371 'model': (optional and only have sense for type==virtual) interface model: virtio, e2000, ...
372 'mac_address': (optional) mac address to assign to this interface
373 #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
374 the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
375 'type': (mandatory) can be one of:
376 'virtual', in this case always connected to a network of type 'net_type=bridge'
377 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
378 can created unconnected
379 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
380 'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
381 are allocated on the same physical NIC
382 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS
383 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing
384 or True, it must apply the default VIM behaviour
385 After execution the method will add the key:
386 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this
387 interface. 'net_list' is modified
388 'cloud_config': (optional) dictionary with:
389 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
390 'users': (optional) list of users to be inserted, each item is a dict with:
391 'name': (mandatory) user name,
392 'key-pairs': (optional) list of strings with the public key to be inserted to the user
393 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
394 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
395 'config-files': (optional). List of files to be transferred. Each item is a dict with:
396 'dest': (mandatory) string with the destination absolute path
397 'encoding': (optional, by default text). Can be one of:
398 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
399 'content' (mandatory): string with the content of the file
400 'permissions': (optional) string with file permissions, typically octal notation '0644'
401 'owner': (optional) file owner, string with the format 'owner:group'
402 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
403 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
404 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
405 'size': (mandatory) string with the size of the disk in GB
406 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
407 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
408 availability_zone_index is None
409 Returns the instance identifier or raises an exception on error
411 raise vimconnNotImplemented( "Should have implemented this" )
413 def get_vminstance(self
,vm_id
):
414 """Returns the VM instance information from VIM"""
415 raise vimconnNotImplemented( "Should have implemented this" )
417 def delete_vminstance(self
, vm_id
):
418 """Removes a VM instance from VIM
419 Returns the instance identifier"""
420 raise vimconnNotImplemented( "Should have implemented this" )
422 def refresh_vms_status(self
, vm_list
):
423 """Get the status of the virtual machines and their interfaces/ports
424 Params: the list of VM identifiers
425 Returns a dictionary with:
426 vm_id: #VIM id of this Virtual Machine
427 status: #Mandatory. Text with one of:
428 # DELETED (not found at vim)
429 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
430 # OTHER (Vim reported other status not understood)
431 # ERROR (VIM indicates an ERROR status)
432 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
433 # BUILD (on building process), ERROR
434 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
436 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
437 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
438 interfaces: list with interface info. Each item a dictionary with:
439 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
440 mac_address: #Text format XX:XX:XX:XX:XX:XX
441 vim_net_id: #network id where this interface is connected, if provided at creation
442 vim_interface_id: #interface/port VIM id
443 ip_address: #null, or text with IPv4, IPv6 address
444 compute_node: #identification of compute node where PF,VF interface is allocated
445 pci: #PCI address of the NIC that hosts the PF,VF
446 vlan: #physical VLAN used for VF
448 raise vimconnNotImplemented( "Should have implemented this" )
450 def action_vminstance(self
, vm_id
, action_dict
):
451 """Send and action over a VM instance from VIM
452 Returns the vm_id if the action was successfully sent to the VIM"""
453 raise vimconnNotImplemented( "Should have implemented this" )
455 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
457 Get a console for the virtual machine
459 vm_id: uuid of the VM
460 console_type, can be:
461 "novnc" (by default), "xvpvnc" for VNC types,
462 "rdp-html5" for RDP types, "spice-html5" for SPICE types
463 Returns dict with the console parameters:
464 protocol: ssh, ftp, http, https, ...
465 server: usually ip address
466 port: the http, ssh, ... port
467 suffix: extra text, e.g. the http path and query string
469 raise vimconnNotImplemented( "Should have implemented this" )
471 def new_classification(self
, name
, ctype
, definition
):
472 """Creates a traffic classification in the VIM
474 'name': name of this classification
475 'ctype': type of this classification
476 'definition': definition of this classification (type-dependent free-form text)
477 Returns the VIM's classification ID on success or raises an exception on failure
479 raise vimconnNotImplemented( "SFC support not implemented" )
481 def get_classification(self
, classification_id
):
482 """Obtain classification details of the VIM's classification with ID='classification_id'
483 Return a dict that contains:
484 'id': VIM's classification ID (same as classification_id)
485 'name': VIM's classification name
486 'type': type of this classification
487 'definition': definition of the classification
488 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
489 'error_msg': (optional) text that explains the ERROR status
490 other VIM specific fields: (optional) whenever possible
491 Raises an exception upon error or when classification is not found
493 raise vimconnNotImplemented( "SFC support not implemented" )
495 def get_classification_list(self
, filter_dict
={}):
496 """Obtain classifications from the VIM
498 'filter_dict' (optional): contains the entries to filter the classifications on and only return those that match ALL:
499 id: string => returns classifications with this VIM's classification ID, which implies a return of one classification at most
500 name: string => returns only classifications with this name
501 type: string => returns classifications of this type
502 definition: string => returns classifications that have this definition
503 tenant_id: string => returns only classifications that belong to this tenant/project
504 Returns a list of classification dictionaries, each dictionary contains:
505 'id': (mandatory) VIM's classification ID
506 'name': (mandatory) VIM's classification name
507 'type': type of this classification
508 'definition': definition of the classification
509 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
510 List can be empty if no classification matches the filter_dict. Raise an exception only upon VIM connectivity,
511 authorization, or some other unspecific error
513 raise vimconnNotImplemented( "SFC support not implemented" )
515 def delete_classification(self
, classification_id
):
516 """Deletes a classification from the VIM
517 Returns the classification ID (classification_id) or raises an exception upon error or when classification is not found
519 raise vimconnNotImplemented( "SFC support not implemented" )
521 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
522 """Creates a service function instance in the VIM
524 'name': name of this service function instance
525 'ingress_ports': set of ingress ports (VIM's port IDs)
526 'egress_ports': set of egress ports (VIM's port IDs)
527 'sfc_encap': boolean stating whether this specific instance supports IETF SFC Encapsulation
528 Returns the VIM's service function instance ID on success or raises an exception on failure
530 raise vimconnNotImplemented( "SFC support not implemented" )
532 def get_sfi(self
, sfi_id
):
533 """Obtain service function instance details of the VIM's service function instance with ID='sfi_id'
534 Return a dict that contains:
535 'id': VIM's sfi ID (same as sfi_id)
536 'name': VIM's sfi name
537 'ingress_ports': set of ingress ports (VIM's port IDs)
538 'egress_ports': set of egress ports (VIM's port IDs)
539 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
540 'error_msg': (optional) text that explains the ERROR status
541 other VIM specific fields: (optional) whenever possible
542 Raises an exception upon error or when service function instance is not found
544 raise vimconnNotImplemented( "SFC support not implemented" )
546 def get_sfi_list(self
, filter_dict
={}):
547 """Obtain service function instances from the VIM
549 'filter_dict' (optional): contains the entries to filter the sfis on and only return those that match ALL:
550 id: string => returns sfis with this VIM's sfi ID, which implies a return of one sfi at most
551 name: string => returns only service function instances with this name
552 tenant_id: string => returns only service function instances that belong to this tenant/project
553 Returns a list of service function instance dictionaries, each dictionary contains:
554 'id': (mandatory) VIM's sfi ID
555 'name': (mandatory) VIM's sfi name
556 'ingress_ports': set of ingress ports (VIM's port IDs)
557 'egress_ports': set of egress ports (VIM's port IDs)
558 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
559 List can be empty if no sfi matches the filter_dict. Raise an exception only upon VIM connectivity,
560 authorization, or some other unspecific error
562 raise vimconnNotImplemented( "SFC support not implemented" )
564 def delete_sfi(self
, sfi_id
):
565 """Deletes a service function instance from the VIM
566 Returns the service function instance ID (sfi_id) or raises an exception upon error or when sfi is not found
568 raise vimconnNotImplemented( "SFC support not implemented" )
570 def new_sf(self
, name
, sfis
, sfc_encap
=True):
571 """Creates (an abstract) service function in the VIM
573 'name': name of this service function
574 'sfis': set of service function instances of this (abstract) service function
575 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
576 Returns the VIM's service function ID on success or raises an exception on failure
578 raise vimconnNotImplemented( "SFC support not implemented" )
580 def get_sf(self
, sf_id
):
581 """Obtain service function details of the VIM's service function with ID='sf_id'
582 Return a dict that contains:
583 'id': VIM's sf ID (same as sf_id)
584 'name': VIM's sf name
585 'sfis': VIM's sf's set of VIM's service function instance IDs
586 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
587 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
588 'error_msg': (optional) text that explains the ERROR status
589 other VIM specific fields: (optional) whenever possible
590 Raises an exception upon error or when sf is not found
593 def get_sf_list(self
, filter_dict
={}):
594 """Obtain service functions from the VIM
596 'filter_dict' (optional): contains the entries to filter the sfs on and only return those that match ALL:
597 id: string => returns sfs with this VIM's sf ID, which implies a return of one sf at most
598 name: string => returns only service functions with this name
599 tenant_id: string => returns only service functions that belong to this tenant/project
600 Returns a list of service function dictionaries, each dictionary contains:
601 'id': (mandatory) VIM's sf ID
602 'name': (mandatory) VIM's sf name
603 'sfis': VIM's sf's set of VIM's service function instance IDs
604 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation
605 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
606 List can be empty if no sf matches the filter_dict. Raise an exception only upon VIM connectivity,
607 authorization, or some other unspecific error
609 raise vimconnNotImplemented( "SFC support not implemented" )
611 def delete_sf(self
, sf_id
):
612 """Deletes (an abstract) service function from the VIM
613 Returns the service function ID (sf_id) or raises an exception upon error or when sf is not found
615 raise vimconnNotImplemented( "SFC support not implemented" )
618 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
619 """Creates a service function path
621 'name': name of this service function path
622 'classifications': set of traffic classifications that should be matched on to get into this sfp
623 'sfs': list of every service function that constitutes this path , from first to last
624 'sfc_encap': whether this is an SFC-Encapsulated chain (i.e using NSH), True by default
625 'spi': (optional) the Service Function Path identifier (SPI: Service Path Identifier) for this path
626 Returns the VIM's sfp ID on success or raises an exception on failure
628 raise vimconnNotImplemented( "SFC support not implemented" )
630 def get_sfp(self
, sfp_id
):
631 """Obtain service function path details of the VIM's sfp with ID='sfp_id'
632 Return a dict that contains:
633 'id': VIM's sfp ID (same as sfp_id)
634 'name': VIM's sfp name
635 'classifications': VIM's sfp's list of VIM's classification IDs
636 'sfs': VIM's sfp's list of VIM's service function IDs
637 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
638 'error_msg': (optional) text that explains the ERROR status
639 other VIM specific fields: (optional) whenever possible
640 Raises an exception upon error or when sfp is not found
642 raise vimconnNotImplemented( "SFC support not implemented" )
644 def get_sfp_list(self
, filter_dict
={}):
645 """Obtain service function paths from VIM
647 'filter_dict' (optional): contains the entries to filter the sfps on, and only return those that match ALL:
648 id: string => returns sfps with this VIM's sfp ID , which implies a return of one sfp at most
649 name: string => returns only sfps with this name
650 tenant_id: string => returns only sfps that belong to this tenant/project
651 Returns a list of service function path dictionaries, each dictionary contains:
652 'id': (mandatory) VIM's sfp ID
653 'name': (mandatory) VIM's sfp name
654 'classifications': VIM's sfp's list of VIM's classification IDs
655 'sfs': VIM's sfp's list of VIM's service function IDs
656 other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
657 List can be empty if no sfp matches the filter_dict. Raise an exception only upon VIM connectivity,
658 authorization, or some other unspecific error
660 raise vimconnNotImplemented( "SFC support not implemented" )
662 def delete_sfp(self
, sfp_id
):
663 """Deletes a service function path from the VIM
664 Returns the sfp ID (sfp_id) or raises an exception upon error or when sf is not found
666 raise vimconnNotImplemented( "SFC support not implemented" )
668 def inject_user_key(self
, ip_addr
=None, user
=None, key
=None, ro_key
=None, password
=None):
670 Inject a ssh public key in a VM
672 ip_addr: ip address of the VM
673 user: username (default-user) to enter in the VM
674 key: public key to be injected in the VM
675 ro_key: private key of the RO, used to enter in the VM if the password is not provided
676 password: password of the user to enter in the VM
677 The function doesn't return a value:
679 if not ip_addr
or not user
:
680 raise vimconnNotSupportedException("All parameters should be different from 'None'")
681 elif not ro_key
and not password
:
682 raise vimconnNotSupportedException("All parameters should be different from 'None'")
684 commands
= {'mkdir -p ~/.ssh/', 'echo "%s" >> ~/.ssh/authorized_keys' % key
,
685 'chmod 644 ~/.ssh/authorized_keys', 'chmod 700 ~/.ssh/'}
686 client
= paramiko
.SSHClient()
689 pkey
= paramiko
.RSAKey
.from_private_key(StringIO
.StringIO(ro_key
))
692 client
.set_missing_host_key_policy(paramiko
.AutoAddPolicy())
693 client
.connect(ip_addr
, username
=user
, password
=password
, pkey
=pkey
, timeout
=10)
694 for command
in commands
:
695 (i
, o
, e
) = client
.exec_command(command
, timeout
=10)
696 returncode
= o
.channel
.recv_exit_status()
700 text
= "run_command='{}' Error='{}'".format(command
, outerror
)
701 raise vimconnUnexpectedResponse("Cannot inject ssh key in VM: '{}'".format(text
))
703 except (socket
.error
, paramiko
.AuthenticationException
, paramiko
.SSHException
) as message
:
704 raise vimconnUnexpectedResponse(
705 "Cannot inject ssh key in VM: '{}' - {}".format(ip_addr
, str(message
)))
709 #NOT USED METHODS in current version
711 def host_vim2gui(self
, host
, server_dict
):
712 """Transform host dictionary from VIM format to GUI format,
713 and append to the server_dict
715 raise vimconnNotImplemented( "Should have implemented this" )
717 def get_hosts_info(self
):
718 """Get the information of deployed hosts
719 Returns the hosts content"""
720 raise vimconnNotImplemented( "Should have implemented this" )
722 def get_hosts(self
, vim_tenant
):
723 """Get the hosts and deployed instances
724 Returns the hosts content"""
725 raise vimconnNotImplemented( "Should have implemented this" )
727 def get_processor_rankings(self
):
728 """Get the processor rankings in the VIM database"""
729 raise vimconnNotImplemented( "Should have implemented this" )
731 def new_host(self
, host_data
):
732 """Adds a new host to VIM"""
733 """Returns status code of the VIM response"""
734 raise vimconnNotImplemented( "Should have implemented this" )
736 def new_external_port(self
, port_data
):
737 """Adds a external port to VIM"""
738 """Returns the port identifier"""
739 raise vimconnNotImplemented( "Should have implemented this" )
741 def new_external_network(self
,net_name
,net_type
):
742 """Adds a external network to VIM (shared)"""
743 """Returns the network identifier"""
744 raise vimconnNotImplemented( "Should have implemented this" )
746 def connect_port_network(self
, port_id
, network_id
, admin
=False):
747 """Connects a external port to a network"""
748 """Returns status code of the VIM response"""
749 raise vimconnNotImplemented( "Should have implemented this" )
751 def new_vminstancefromJSON(self
, vm_data
):
752 """Adds a VM instance to VIM"""
753 """Returns the instance identifier"""
754 raise vimconnNotImplemented( "Should have implemented this" )