functest/utils/openstack_tacker.py

   1 ###########################################################################
   2 # Copyright (c) 2016 Ericsson AB and others.
   3 # Author: George Paraskevopoulos <geopar@intracom-telecom.com>
   4 #
   5 # Wrappers for trozet's python-tackerclient v1.0
   6 # (https://github.com/trozet/python-tackerclient)
   7 #
   8 # All rights reserved. This program and the accompanying materials
   9 # are made available under the terms of the Apache License, Version 2.0
  10 # which accompanies this distribution, and is available at
  11 # http://www.apache.org/licenses/LICENSE-2.0
  12 ##########################################################################
  13
  14
  15 from tackerclient.v1_0 import client as tackerclient
  16 import functest.utils.functest_logger as ft_logger
  17 import functest.utils.openstack_utils as os_utils
  18 import time
  19
  20 logger = ft_logger.Logger("tacker_utils").getLogger()
  21
  22
  23 def get_tacker_client(other_creds={}):
  24     sess = os_utils.get_session(other_creds)
  25     return tackerclient.Client(session=sess)
  26
  27
  28 # *********************************************
  29 #   TACKER
  30 # *********************************************
  31 def get_id_from_name(tacker_client, resource_type, resource_name):
  32     try:
  33         req_params = {'fields': 'id', 'name': resource_name}
  34         endpoint = '/{0}s'.format(resource_type)
  35         resp = tacker_client.get(endpoint, params=req_params)
  36         endpoint = endpoint.replace('-', '_')
  37         return resp[endpoint[1:]][0]['id']
  38     except Exception, e:
  39         logger.error("Error [get_id_from_name(tacker_client, "
  40                      "resource_type, resource_name)]: %s" % e)
  41         return None
  42
  43
  44 def get_vnfd_id(tacker_client, vnfd_name):
  45     return get_id_from_name(tacker_client, 'vnfd', vnfd_name)
  46
  47
  48 def get_vnf_id(tacker_client, vnf_name, timeout=5):
  49     vnf_id = None
  50     while vnf_id is None and timeout >= 0:
  51         vnf_id = get_id_from_name(tacker_client, 'vnf', vnf_name)
  52         if vnf_id is None:
  53             logger.info("Could not retrieve ID for vnf with name [%s]."
  54                         " Retrying." % vnf_name)
  55             time.sleep(1)
  56             timeout -= 1
  57     return vnf_id
  58
  59
  60 def get_sfc_id(tacker_client, sfc_name):
  61     return get_id_from_name(tacker_client, 'sfc', sfc_name)
  62
  63
  64 def get_sfc_classifier_id(tacker_client, sfc_clf_name):
  65     return get_id_from_name(tacker_client, 'sfc-classifier', sfc_clf_name)
  66
  67
  68 def list_vnfds(tacker_client, verbose=False):
  69     try:
  70         vnfds = tacker_client.list_vnfds(retrieve_all=True)
  71         if not verbose:
  72             vnfds = [vnfd['id'] for vnfd in vnfds['vnfds']]
  73         return vnfds
  74     except Exception, e:
  75         logger.error("Error [list_vnfds(tacker_client)]: %s" % e)
  76         return None
  77
  78
  79 def create_vnfd(tacker_client, tosca_file=None):
  80     try:
  81         vnfd_body = {}
  82         if tosca_file is not None:
  83             with open(tosca_file) as tosca_fd:
  84                 vnfd_body = tosca_fd.read()
  85             logger.info('VNFD template:\n{0}'.format(vnfd_body))
  86         return tacker_client.create_vnfd(
  87             body={"vnfd": {"attributes": {"vnfd": vnfd_body}}})
  88     except Exception, e:
  89         logger.error("Error [create_vnfd(tacker_client, '%s')]: %s"
  90                      % (tosca_file, e))
  91         return None
  92
  93
  94 def delete_vnfd(tacker_client, vnfd_id=None, vnfd_name=None):
  95     try:
  96         vnfd = vnfd_id
  97         if vnfd is None:
  98             if vnfd_name is None:
  99                 raise Exception('You need to provide VNFD id or VNFD name')
 100             vnfd = get_vnfd_id(tacker_client, vnfd_name)
 101         return tacker_client.delete_vnfd(vnfd)
 102     except Exception, e:
 103         logger.error("Error [delete_vnfd(tacker_client, '%s', '%s')]: %s"
 104                      % (vnfd_id, vnfd_name, e))
 105         return None
 106
 107
 108 def list_vnfs(tacker_client, verbose=False):
 109     try:
 110         vnfs = tacker_client.list_vnfs(retrieve_all=True)
 111         if not verbose:
 112             vnfs = [vnf['id'] for vnf in vnfs['vnfs']]
 113         return vnfs
 114     except Exception, e:
 115         logger.error("Error [list_vnfs(tacker_client)]: %s" % e)
 116         return None
 117
 118
 119 def create_vnf(tacker_client, vnf_name, vnfd_id=None,
 120                vnfd_name=None, param_file=None):
 121     try:
 122         vnf_body = {
 123             'vnf': {
 124                 'attributes': {},
 125                 'name': vnf_name
 126             }
 127         }
 128         if param_file is not None:
 129             params = None
 130             with open(param_file) as f:
 131                 params = f.read()
 132             vnf_body['vnf']['attributes']['param_values'] = params
 133         if vnfd_id is not None:
 134             vnf_body['vnf']['vnfd_id'] = vnfd_id
 135         else:
 136             if vnfd_name is None:
 137                 raise Exception('vnfd id or vnfd name is required')
 138             vnf_body['vnf']['vnfd_id'] = get_vnfd_id(tacker_client, vnfd_name)
 139         return tacker_client.create_vnf(body=vnf_body)
 140     except Exception, e:
 141         logger.error("error [create_vnf(tacker_client,"
 142                      " '%s', '%s', '%s')]: %s"
 143                      % (vnf_name, vnfd_id, vnfd_name, e))
 144         return None
 145
 146
 147 def get_vnf(tacker_client, vnf_id=None, vnf_name=None):
 148     try:
 149         if vnf_id is None and vnf_name is None:
 150             raise Exception('You must specify vnf_id or vnf_name')
 151
 152         _id = get_vnf_id(tacker_client, vnf_name) if vnf_id is None else vnf_id
 153
 154         if _id is not None:
 155             all_vnfs = list_vnfs(tacker_client, verbose=True)['vnfs']
 156             return next((vnf for vnf in all_vnfs if vnf['id'] == _id), None)
 157         else:
 158             raise Exception('Could not retrieve ID from name [%s]' % vnf_name)
 159
 160     except Exception, e:
 161         logger.error("Could not retrieve VNF [vnf_id=%s, vnf_name=%s] - %s"
 162                      % (vnf_id, vnf_name, e))
 163         return None
 164
 165
 166 def wait_for_vnf(tacker_client, vnf_id=None, vnf_name=None, timeout=60):
 167     try:
 168         vnf = get_vnf(tacker_client, vnf_id, vnf_name)
 169         if vnf is None:
 170             raise Exception("Could not retrieve VNF - id='%s', name='%s'"
 171                             % vnf_id, vnf_name)
 172         logger.info('Waiting for vnf {0}'.format(str(vnf)))
 173         while vnf['status'] != 'ACTIVE' and timeout >= 0:
 174             if vnf['status'] == 'ERROR':
 175                 raise Exception('Error when booting vnf %s' % vnf['id'])
 176             elif vnf['status'] == 'PENDING_CREATE':
 177                 time.sleep(3)
 178                 timeout -= 3
 179         return vnf['id']
 180     except Exception, e:
 181         logger.error("error [wait_for_vnf(tacker_client, '%s', '%s')]: %s"
 182                      % (vnf_id, vnf_name, e))
 183         return None
 184
 185
 186 def delete_vnf(tacker_client, vnf_id=None, vnf_name=None):
 187     try:
 188         vnf = vnf_id
 189         if vnf is None:
 190             if vnf_name is None:
 191                 raise Exception('You need to provide a VNF id or name')
 192             vnf = get_vnf_id(tacker_client, vnf_name)
 193         return tacker_client.delete_vnf(vnf)
 194     except Exception, e:
 195         logger.error("Error [delete_vnf(tacker_client, '%s', '%s')]: %s"
 196                      % (vnf_id, vnf_name, e))
 197         return None
 198
 199
 200 def list_sfcs(tacker_client, verbose=False):
 201     try:
 202         sfcs = tacker_client.list_sfcs(retrieve_all=True)
 203         if not verbose:
 204             sfcs = [sfc['id'] for sfc in sfcs['sfcs']]
 205         return sfcs
 206     except Exception, e:
 207         logger.error("Error [list_sfcs(tacker_client)]: %s" % e)
 208         return None
 209
 210
 211 def create_sfc(tacker_client, sfc_name,
 212                chain_vnf_ids=None,
 213                chain_vnf_names=None,
 214                symmetrical=False):
 215     try:
 216         sfc_body = {
 217             'sfc': {
 218                 'attributes': {},
 219                 'name': sfc_name,
 220                 'chain': []
 221             }
 222         }
 223         if symmetrical:
 224             sfc_body['sfc']['symmetrical'] = True
 225         if chain_vnf_ids is not None:
 226             sfc_body['sfc']['chain'] = chain_vnf_ids
 227         else:
 228             if chain_vnf_names is None:
 229                 raise Exception('You need to provide a chain of VNFs')
 230             sfc_body['sfc']['chain'] = [get_vnf_id(tacker_client, name)
 231                                         for name in chain_vnf_names]
 232         return tacker_client.create_sfc(body=sfc_body)
 233     except Exception, e:
 234         logger.error("error [create_sfc(tacker_client,"
 235                      " '%s', '%s', '%s')]: %s"
 236                      % (sfc_name, chain_vnf_ids, chain_vnf_names, e))
 237         return None
 238
 239
 240 def delete_sfc(tacker_client, sfc_id=None, sfc_name=None):
 241     try:
 242         sfc = sfc_id
 243         if sfc is None:
 244             if sfc_name is None:
 245                 raise Exception('You need to provide an SFC id or name')
 246             sfc = get_sfc_id(tacker_client, sfc_name)
 247         return tacker_client.delete_sfc(sfc)
 248     except Exception, e:
 249         logger.error("Error [delete_sfc(tacker_client, '%s', '%s')]: %s"
 250                      % (sfc_id, sfc_name, e))
 251         return None
 252
 253
 254 def list_sfc_classifiers(tacker_client, verbose=False):
 255     try:
 256         sfc_clfs = tacker_client.list_sfc_classifiers(retrieve_all=True)
 257         if not verbose:
 258             sfc_clfs = [sfc_clf['id']
 259                         for sfc_clf in sfc_clfs['sfc_classifiers']]
 260         return sfc_clfs
 261     except Exception, e:
 262         logger.error("Error [list_sfc_classifiers(tacker_client)]: %s" % e)
 263         return None
 264
 265
 266 def create_sfc_classifier(tacker_client, sfc_clf_name, sfc_id=None,
 267                           sfc_name=None, match={}):
 268     # Example match:
 269     # match: {
 270     #     "source_port": "0",
 271     #     "protocol": "6",
 272     #     "dest_port": "80"
 273     # }
 274     try:
 275         sfc_clf_body = {
 276             'sfc_classifier': {
 277                 'attributes': {},
 278                 'name': sfc_clf_name,
 279                 'match': match,
 280                 'chain': ''
 281             }
 282         }
 283         if sfc_id is not None:
 284             sfc_clf_body['sfc_classifier']['chain'] = sfc_id
 285         else:
 286             if sfc_name is None:
 287                 raise Exception('You need to provide an SFC id or name')
 288             sfc_clf_body['sfc_classifier']['chain'] = get_sfc_id(
 289                 tacker_client, sfc_name)
 290         return tacker_client.create_sfc_classifier(body=sfc_clf_body)
 291     except Exception, e:
 292         logger.error("error [create_sfc_classifier(tacker_client,"
 293                      " '%s', '%s','%s', '%s')]: '%s'"
 294                      % (sfc_clf_name, sfc_id, sfc_name, str(match), e))
 295         return None
 296
 297
 298 def delete_sfc_classifier(tacker_client,
 299                           sfc_clf_id=None,
 300                           sfc_clf_name=None):
 301     try:
 302         sfc_clf = sfc_clf_id
 303         if sfc_clf is None:
 304             if sfc_clf_name is None:
 305                 raise Exception('You need to provide an SFC'
 306                                 'classifier id or name')
 307             sfc_clf = get_sfc_classifier_id(tacker_client, sfc_clf_name)
 308         return tacker_client.delete_sfc_classifier(sfc_clf)
 309     except Exception, e:
 310         logger.error("Error [delete_sfc_classifier(tacker_client, '%s', "
 311                      "'%s')]: %s" % (sfc_clf_id, sfc_clf_name, e))
 312         return None