RUN /root/RO/RO/osm_ro/scripts/install-osm-im.sh --develop && \
mkdir -p /var/log/osm && \
+ python3 -m pip install -e /root/RO/RO-plugin && \
python3 -m pip install -e /root/RO/RO && \
python3 -m pip install -e /root/RO/RO-client && \
python3 -m pip install -e /root/RO/RO-VIM-vmware && \
#
# This work has been performed in the context of Arista Telefonica OSM PoC.
##
-from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
import re
import socket
# Required by compare function
requests
uuid
cvprac
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='oscarluis.peral@atos.net', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='Oscar Luis Peral',
+ maintainer_email='oscarluis.peral@atos.net',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
packages=[_name],
include_package_data=True,
- install_requires=["requests",
- "uuid",
- "cvprac",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"],
+ install_requires=[
+ "requests",
+ "uuid",
+ "cvprac",
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
+ ],
setup_requires=['setuptools-version-command'],
entry_points={
'osm_rosdn.plugins': ['rosdn_arista_cloudvision = osm_rosdn_arista_cloudvision.'
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
+Depends3: python3-requests, python3-osm-ro-plugin, python3-pip
import requests
import struct
import sys
-from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
class DpbSshInterface():
paramiko
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
+
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
packages=[_name],
include_package_data=True,
dependency_links=["git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro"],
- install_requires=["paramiko", "requests", "osm-ro"],
+ install_requires=[
+ "paramiko",
+ "requests",
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin",
+ ],
setup_requires=['setuptools-version-command'],
entry_points={
'osm_rosdn.plugins': ['rosdn_dpb = osm_rosdn_dpb.wimconn_dpb:DpbConnector'],
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-paramiko, python3-requests, python3-osm-ro
+Depends3: python3-paramiko, python3-requests, python3-osm-ro-plugin
import logging
from enum import Enum
-from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
class SdnError(Enum):
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
include_package_data=True,
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
+Depends3: python3-requests, python3-osm-ro-plugin
import json
import requests
import logging
-from osm_ro.wim.openflow_conn import OpenflowConn, OpenflowConnUnexpectedResponse, OpenflowConnConnectionException
+from osm_ro_plugin.openflow_conn import OpenflowConn, OpenflowConnUnexpectedResponse, OpenflowConnConnectionException
class OfConnFloodLight(OpenflowConn):
"""
import logging
-from osm_ro.wim.openflow_conn import SdnConnectorOpenFlow
+from osm_ro_plugin.openflow_conn import SdnConnectorOpenFlow
from .floodlight_of import OfConnFloodLight
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
include_package_data=True,
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
-
+Maintainer: Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>
+Depends3: python3-requests, python3-osm-ro-plugin
import requests
import uuid
import logging
-from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
"""CHeck layer where we move it"""
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
dependency_links=["git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro"],
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
+Depends3: python3-requests, python3-osm-ro-plugin
import logging
import json
-from osm_ro.wim.sdnconn import SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorError
from osm_rosdn_juniper_contrail.rest_lib import ContrailHttp
from osm_rosdn_juniper_contrail.rest_lib import NotFound
# from osm_rosdn_juniper_contrail.rest_lib import DuplicateFound
import yaml
import random
-from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
# from osm_rosdn_juniper_contrail.rest_lib import ContrailHttp
# from osm_rosdn_juniper_contrail.rest_lib import NotFound
from osm_rosdn_juniper_contrail.rest_lib import DuplicateFound
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
#dependency_links=["git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro"],
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
+Depends3: python3-requests, python3-osm-ro-plugin
import requests
import base64
import logging
-from osm_ro.wim.openflow_conn import OpenflowConn, OpenflowConnException, OpenflowConnConnectionException, \
+from osm_ro_plugin.openflow_conn import OpenflowConn, OpenflowConnException, OpenflowConnConnectionException, \
OpenflowConnUnexpectedResponse, OpenflowConnAuthException, OpenflowConnNotFoundException, \
OpenflowConnConflictException, OpenflowConnNotSupportedException, OpenflowConnNotImplemented
"""
import logging
-from osm_ro.wim.openflow_conn import SdnConnectorOpenFlow
+from osm_ro_plugin.openflow_conn import SdnConnectorOpenFlow
from .odl_of import OfConnOdl
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
include_package_data=True,
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
-
+Maintainer: Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>
+Depends3: python3-requests, python3-osm-ro-plugin
import requests
import base64
import logging
-from osm_ro.wim.openflow_conn import OpenflowConn, OpenflowConnException, OpenflowConnConnectionException, \
+from osm_ro_plugin.openflow_conn import OpenflowConn, OpenflowConnException, OpenflowConnConnectionException, \
OpenflowConnUnexpectedResponse, OpenflowConnAuthException, OpenflowConnNotFoundException, \
OpenflowConnConflictException, OpenflowConnNotSupportedException, OpenflowConnNotImplemented
"""
import logging
-from osm_ro.wim.openflow_conn import SdnConnectorOpenFlow
+from osm_ro_plugin.openflow_conn import SdnConnectorOpenFlow
from .onos_of import OfConnOnos
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
include_package_data=True,
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
-
+Maintainer: Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>
+Depends3: python3-requests, python3-osm-ro-plugin
import requests
from requests.auth import HTTPBasicAuth
-from osm_ro.wim.sdnconn import SdnConnectorBase, SdnConnectorError
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
class OnosVpls(SdnConnectorBase):
##
requests
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
-
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@list.etsi.org',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@list.etsi.org',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
include_package_data=True,
install_requires=[
"requests",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-osm-ro
+Depends3: python3-requests, python3-osm-ro-plugin
__author__ = "Saboor Ahmad"
__date__ = "10-Apr-2017"
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
import yaml
import logging
import netaddr
import boto.vpc
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None,
config={}, persistent_info={}):
""" Params: uuid - id asigned to this VIM
empty dict. Useful to store login/tokens information for speed up communication
"""
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
config, persistent_info)
self.persistent_info = persistent_info
if user:
self.a_creds['aws_access_key_id'] = user
else:
- raise vimconn.vimconnAuthException("Username is not specified")
+ raise vimconn.VimConnAuthException("Username is not specified")
if passwd:
self.a_creds['aws_secret_access_key'] = passwd
else:
- raise vimconn.vimconnAuthException("Password is not specified")
+ raise vimconn.VimConnAuthException("Password is not specified")
if 'region_name' in config:
self.region = config.get('region_name')
else:
- raise vimconn.vimconnException("AWS region_name is not specified at config")
+ raise vimconn.VimConnException("AWS region_name is not specified at config")
self.vpc_data = {}
self.subnet_data = {}
self.flavor_info = yaml.load(flavor_data, Loader=yaml.Loader)
except yaml.YAMLError as e:
self.flavor_info = None
- raise vimconn.vimconnException("Bad format at file '{}': {}".format(flavor_data[1:], e))
+ raise vimconn.VimConnException("Bad format at file '{}': {}".format(flavor_data[1:], e))
except IOError as e:
- raise vimconn.vimconnException("Error reading file '{}': {}".format(flavor_data[1:], e))
+ raise vimconn.VimConnException("Error reading file '{}': {}".format(flavor_data[1:], e))
elif isinstance(flavor_data, dict):
self.flavor_info = flavor_data
elif index == 'region':
self.region = value
else:
- vimconn.vimconnector.__setitem__(self, index, value)
+ vimconn.VimConnector.__setitem__(self, index, value)
def _reload_connection(self):
"""Returns: sets boto.EC2 and boto.VPC connection to work with AWS services
self.conn = None
self.conn_vpc = None
- raise vimconn.vimconnConnectionException(type(e).__name__ + ": " + str(e))
+ raise vimconn.VimConnConnectionException(type(e).__name__ + ": " + str(e))
def get_availability_zones_list(self):
"""Obtain AvailabilityZones from AWS
if availability_zones != 2 and availability_zones != 3:
self.logger.debug("Number of AZs should be 2 or 3")
- raise vimconn.vimconnNotSupportedException("Number of AZs should be 2 or 3")
+ raise vimconn.VimConnNotSupportedException("Number of AZs should be 2 or 3")
netmasks = ('255.255.252.0', '255.255.254.0', '255.255.255.0', '255.255.255.128')
ip = netaddr.IPNetwork(cidr)
if str(mask) not in netmasks:
self.logger.debug("Netmask " + str(mask) + " not found")
- raise vimconn.vimconnNotFoundException("Netmask " + str(mask) + " not found")
+ raise vimconn.VimConnNotFoundException("Netmask " + str(mask) + " not found")
if availability_zones == 2:
for n, netmask in enumerate(netmasks):
if flavor_id in self.flavor_info:
return self.flavor_info[flavor_id]
else:
- raise vimconn.vimconnNotFoundException("Cannot find flavor with this flavor ID/Name")
+ raise vimconn.VimConnNotFoundException("Cannot find flavor with this flavor ID/Name")
except Exception as e:
self.format_vimconn_exception(e)
flavor = (key, values)
if flavor:
return flavor[0]
- raise vimconn.vimconnNotFoundException("Cannot find flavor with this flavor ID/Name")
+ raise vimconn.VimConnNotFoundException("Cannot find flavor with this flavor ID/Name")
except Exception as e:
self.format_vimconn_exception(e)
requests
netaddr
boto
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
include_package_data=True,
install_requires=[
"requests", "netaddr", "PyYAML", "boto",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_aws = osm_rovim_aws.vimconn_aws'],
+ 'osm_rovim.plugins': ['rovim_aws = osm_rovim_aws.vimconn_aws:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-boto, python3-requests, python3-netaddr, python3-yaml, python3-osm-ro
+Depends3: python3-boto, python3-requests, python3-netaddr, python3-yaml, python3-osm-ro-plugin
##
import base64
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
import logging
import netaddr
import re
pdb.set_trace()
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
# Translate azure provisioning state to OSM provision state
# The first three ones are the transitional status once a user initiated action has been requested
"^Standard_B" will select a serie B maybe for test environment
"""
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
config, persistent_info)
# Variable that indicates if client must be reloaded or initialized
self._config["subscription_id"] = config.get('subscription_id')
# self.logger.debug('Setting subscription to: %s', self.config["subscription_id"])
else:
- raise vimconn.vimconnException('Subscription not specified')
+ raise vimconn.VimConnException('Subscription not specified')
# REGION
if 'region_name' in config:
self.region = config.get('region_name')
else:
- raise vimconn.vimconnException('Azure region_name is not specified at config')
+ raise vimconn.VimConnException('Azure region_name is not specified at config')
# RESOURCE_GROUP
if 'resource_group' in config:
self.resource_group = config.get('resource_group')
else:
- raise vimconn.vimconnException('Azure resource_group is not specified at config')
+ raise vimconn.VimConnException('Azure resource_group is not specified at config')
# VNET_NAME
if 'vnet_name' in config:
resource = str(resource_id.split('/')[-1])
return resource
except Exception as e:
- raise vimconn.vimconnException("Unable to get resource name from resource_id '{}' Error: '{}'".
+ raise vimconn.VimConnException("Unable to get resource name from resource_id '{}' Error: '{}'".
format(resource_id, e))
def _get_location_from_resource_group(self, resource_group_name):
location = self.conn.resource_groups.get(resource_group_name).location
return location
except Exception as e:
- raise vimconn.vimconnNotFoundException("Location '{}' not found".format(resource_group_name))
+ raise vimconn.VimConnNotFoundException("Location '{}' not found".format(resource_group_name))
def _get_resource_group_name_from_resource_id(self, resource_id):
rg = str(resource_id.split('/')[4])
return rg
except Exception as e:
- raise vimconn.vimconnException("Unable to get resource group from invalid resource_id format '{}'".
+ raise vimconn.VimConnException("Unable to get resource group from invalid resource_id format '{}'".
format(resource_id))
def _get_net_name_from_resource_id(self, resource_id):
net_name = str(resource_id.split('/')[8])
return net_name
except Exception as e:
- raise vimconn.vimconnException("Unable to get azure net_name from invalid resource_id format '{}'".
+ raise vimconn.VimConnException("Unable to get azure net_name from invalid resource_id format '{}'".
format(resource_id))
def _check_subnets_for_vm(self, net_list):
"""
Transforms a generic or azure exception to a vimcommException
"""
- if isinstance(e, vimconn.vimconnException):
+ if isinstance(e, vimconn.VimConnException):
raise
elif isinstance(e, AuthenticationError):
- raise vimconn.vimconnAuthException(type(e).__name__ + ': ' + str(e))
+ raise vimconn.VimConnAuthException(type(e).__name__ + ': ' + str(e))
elif isinstance(e, ConnectionError):
- raise vimconn.vimconnConnectionException(type(e).__name__ + ': ' + str(e))
+ raise vimconn.VimConnConnectionException(type(e).__name__ + ': ' + str(e))
else:
# In case of generic error recreate client
self.reload_client = True
- raise vimconn.vimconnException(type(e).__name__ + ': ' + str(e))
+ raise vimconn.VimConnException(type(e).__name__ + ': ' + str(e))
def _check_or_create_resource_group(self):
"""
self.logger.debug('dinamically obtained ip_profile: %s', ip_range)
break
else:
- raise vimconn.vimconnException("Cannot find a non-used subnet range in {}".
+ raise vimconn.VimConnException("Cannot find a non-used subnet range in {}".
format(self.vnet_address_space))
else:
ip_profile = {"subnet_address": ip_profile['subnet_address']}
"""
It is not allowed to create new flavors in Azure, must always use an existing one
"""
- raise vimconn.vimconnAuthException("It is not possible to create new flavors in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to create new flavors in AZURE")
def new_tenant(self, tenant_name, tenant_description):
"""
It is not allowed to create new tenants in azure
"""
- raise vimconn.vimconnAuthException("It is not possible to create a TENANT in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to create a TENANT in AZURE")
def new_image(self, image_dict):
"""
It is not allowed to create new images in Azure, must always use an existing one
"""
- raise vimconn.vimconnAuthException("It is not possible to create new images in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to create new images in AZURE")
def get_image_id_from_path(self, path):
"""Get the image id from image path in the VIM database.
Returns the image_id or raises a vimconnNotFoundException
"""
- raise vimconn.vimconnAuthException("It is not possible to obtain image from path in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to obtain image from path in AZURE")
def get_image_list(self, filter_dict={}):
"""Obtain tenant images from VIM
else:
image_list = self._get_sku_image_list(publisher, offer, sku)
else:
- raise vimconn.vimconnAuthException(
+ raise vimconn.VimConnAuthException(
"List images in Azure must include name param with at least publisher")
else:
- raise vimconn.vimconnAuthException("List images in Azure must include name param with at"
+ raise vimconn.VimConnAuthException("List images in Azure must include name param with at"
" least publisher")
return image_list
# At least one network must be provided
if not net_list:
- raise vimconn.vimconnException("At least one net must be provided to create a new VM")
+ raise vimconn.VimConnException("At least one net must be provided to create a new VM")
# image_id are several fields of the image_id
image_reference = self._get_image_reference(image_id)
else:
return availability_zone_list[availability_zone_index]
else:
- raise vimconn.vimconnConflictException("No enough availability zones at VIM for this deployment")
+ raise vimconn.VimConnConflictException("No enough availability zones at VIM for this deployment")
def _get_azure_availability_zones(self):
return self.AZURE_ZONES
created_items[data_disk.id] = True
else:
- raise vimconn.vimconnNotFoundException("Invalid image_id: %s ", image_id)
+ raise vimconn.VimConnNotFoundException("Invalid image_id: %s ", image_id)
else:
- raise vimconn.vimconnNotFoundException("Invalid image_id: %s ", image_id)
+ raise vimconn.VimConnNotFoundException("Invalid image_id: %s ", image_id)
# Attach the disk created
virtual_machine.storage_profile.data_disks.append({
'version': version
}
except Exception as e:
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"Unable to get image_reference from invalid image_id format: '{}'".format(image_id))
# Azure VM names can not have some special characters
if listedFilteredSizes:
return listedFilteredSizes[0]['name']
- raise vimconn.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict)))
+ raise vimconn.VimConnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict)))
except Exception as e:
self._format_vimconn_exception(e)
self._reload_connection()
return True
except Exception as e:
- raise vimconn.vimconnException("Connectivity issue with Azure API: {}".format(e))
+ raise vimconn.VimConnException("Connectivity issue with Azure API: {}".format(e))
def get_network(self, net_id):
network_list = self.get_network_list(filter_dict)
if not network_list:
- raise vimconn.vimconnNotFoundException("network '{}' not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("network '{}' not found".format(net_id))
else:
return network_list[0]
filter_dict = {'name': res_name}
network_list = self.get_network_list(filter_dict)
if not network_list:
- raise vimconn.vimconnNotFoundException("network '{}' not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("network '{}' not found".format(net_id))
try:
# Subnet API fails (CloudError: Azure Error: ResourceNotFound)
except CloudError as e:
if e.error.error and "notfound" in e.error.error.lower():
- raise vimconn.vimconnNotFoundException("network '{}' not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("network '{}' not found".format(net_id))
else:
self._format_vimconn_exception(e)
except Exception as e:
except CloudError as e:
if e.error.error and "notfound" in e.error.error.lower():
- raise vimconn.vimconnNotFoundException("No vm instance found '{}'".format(vm_id))
+ raise vimconn.VimConnNotFoundException("No vm instance found '{}'".format(vm_id))
else:
self._format_vimconn_exception(e)
except Exception as e:
return None
except CloudError as e:
if e.error.error and "notfound" in e.error.error.lower():
- raise vimconn.vimconnNotFoundException("No vm found '{}'".format(vm_id))
+ raise vimconn.VimConnNotFoundException("No vm found '{}'".format(vm_id))
else:
self._format_vimconn_exception(e)
except Exception as e:
self._format_vimconn_exception(e)
def delete_flavor(self, flavor_id):
- raise vimconn.vimconnAuthException("It is not possible to delete a FLAVOR in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to delete a FLAVOR in AZURE")
def delete_tenant(self, tenant_id,):
- raise vimconn.vimconnAuthException("It is not possible to delete a TENANT in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to delete a TENANT in AZURE")
def delete_image(self, image_id):
- raise vimconn.vimconnAuthException("It is not possible to delete a IMAGE in AZURE")
+ raise vimconn.VimConnAuthException("It is not possible to delete a IMAGE in AZURE")
def get_vminstance(self, vm_id):
"""
vm = self.conn_compute.virtual_machines.get(self.resource_group, resName)
except CloudError as e:
if e.error.error and "notfound" in e.error.error.lower():
- raise vimconn.vimconnNotFoundException("No vminstance found '{}'".format(vm_id))
+ raise vimconn.VimConnNotFoundException("No vminstance found '{}'".format(vm_id))
else:
self._format_vimconn_exception(e)
except Exception as e:
}
return flavor
else:
- raise vimconn.vimconnNotFoundException("flavor '{}' not found".format(flavor_id))
+ raise vimconn.VimConnNotFoundException("flavor '{}' not found".format(flavor_id))
def get_tenant_list(self, filter_dict={}):
""" Obtains the list of tenants
"status": "VIM_ERROR",
"error_msg": str(e)
}
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
self.logger.error("VimConnNotFoundException %s when searching subnet", e)
out_nets[net_id] = {
"status": "DELETED",
requests
netaddr
azure==4.0.0
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
"netaddr",
"PyYAML",
"azure==4.0.0",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_azure = osm_rovim_azure.vimconn_azure'],
+ 'osm_rovim.plugins': ['rovim_azure = osm_rovim_azure.vimconn_azure:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro, python3-pip
+Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro-plugin, python3-pip
import uuid
import socket
import struct
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
import json
from functools import partial
from fog05 import FIMAPI
from fog05_sdk.interfaces.FDU import FDU
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None,
config={}, persistent_info={}):
"""Constructor of VIM
check against the VIM
"""
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
config, persistent_info)
self.logger.debug('vimconn_fos init with config: {}'.format(config))
def check_vim_connectivity(self):
"""Checks VIM can be reached and user credentials are ok.
- Returns None if success or raised vimconnConnectionException, vimconnAuthException, ...
+ Returns None if success or raised VimConnConnectionException, VimConnAuthException, ...
"""
try:
self.fos_api.node.list()
return None
except fimapi.FIMAuthExcetpion as fae:
- raise vimconn.vimconnAuthException("Unable to authenticate to the VIM. Error {}".format(fae))
+ raise vimconn.VimConnAuthException("Unable to authenticate to the VIM. Error {}".format(fae))
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
def new_network(self, net_name, net_type, ip_profile=None, shared=False, provider_network_profile=None):
"""Adds a tenant network to VIM
"""
self.logger.debug('new_network: {}'.format(locals()))
if net_type in ['data','ptp']:
- raise vimconn.vimconnNotImplemented('{} type of network not supported'.format(net_type))
+ raise vimconn.VimConnNotImplemented('{} type of network not supported'.format(net_type))
net_uuid = '{}'.format(uuid.uuid4())
desc = {
ip.update({'gateway':ip_profile.get('gateway_address', None)})
desc.update({'ip_configuration':ip_info})
else:
- raise vimconn.vimconnNotImplemented('IPV6 network is not implemented at VIM')
+ raise vimconn.VimConnNotImplemented('IPV6 network is not implemented at VIM')
desc.update({'ip_configuration':ip})
self.logger.debug('VIM new_network args: {} - Generated Eclipse fog05 Descriptor {}'.format(locals(), desc))
try:
self.fos_api.network.add_network(desc)
except fimapi.FIMAResouceExistingException as free:
- raise vimconn.vimconnConflictException("Network already exists at VIM. Error {}".format(free))
+ raise vimconn.VimConnConflictException("Network already exists at VIM. Error {}".format(free))
except Exception as e:
- raise vimconn.vimconnException("Unable to create network {}. Error {}".format(net_name, e))
+ raise vimconn.VimConnException("Unable to create network {}. Error {}".format(net_name, e))
# No way from the current rest service to get the actual error, most likely it will be an already existing error
return net_uuid,{}
try:
nets = self.fos_api.network.list()
except Exception as e:
- raise vimconn.vimconnConnectionException("Cannot get network list from VIM, connection error. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("Cannot get network list from VIM, connection error. Error {}".format(e))
filters = [
partial(self.__name_filter, filter_name=filter_dict.get('name')),
self.logger.debug('get_network: {}'.format(net_id))
res = self.get_network_list(filter_dict={'id':net_id})
if len(res) == 0:
- raise vimconn.vimconnNotFoundException("Network {} not found at VIM".format(net_id))
+ raise vimconn.VimConnNotFoundException("Network {} not found at VIM".format(net_id))
return res[0]
def delete_network(self, net_id, created_items=None):
try:
self.fos_api.network.remove_network(net_id)
except fimapi.FIMNotFoundException as fnfe:
- raise vimconn.vimconnNotFoundException("Network {} not found at VIM (already deleted?). Error {}".format(net_id, fnfe))
+ raise vimconn.VimConnNotFoundException("Network {} not found at VIM (already deleted?). Error {}".format(net_id, fnfe))
except Exception as e:
- raise vimconn.vimconnException("Cannot delete network {} from VIM. Error {}".format(net_id, e))
+ raise vimconn.VimConnException("Cannot delete network {} from VIM. Error {}".format(net_id, e))
return net_id
def refresh_nets_status(self, net_list):
r.update({
osm_n.get('id'):{'status':osm_n.get('status')}
})
- except vimconn.vimconnNotFoundException:
+ except vimconn.VimConnNotFoundException:
r.update({
n:{'status':'VIM_ERROR'}
})
try:
r = self.fos_api.flavor.get(flavor_id)
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
if r is None:
- raise vimconn.vimconnNotFoundException("Flavor not found at VIM")
+ raise vimconn.VimConnNotFoundException("Flavor not found at VIM")
return {'id':r.get('uuid'), 'name':r.get('name'), 'fos':r}
def get_flavor_id_from_data(self, flavor_dict):
try:
flvs = self.fos_api.flavor.list()
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
r = [x.get('uuid') for x in flvs if (x.get('cpu_min_count') == flavor_dict.get('vcpus') and x.get('ram_size_mb') == flavor_dict.get('ram') and x.get('storage_size_gb') == flavor_dict.get('disk'))]
if len(r) == 0:
- raise vimconn.vimconnNotFoundException ( "No flavor found" )
+ raise vimconn.VimConnNotFoundException ( "No flavor found" )
return r[0]
def new_flavor(self, flavor_data):
try:
self.fos_api.flavor.add(desc)
except fimapi.FIMAResouceExistingException as free:
- raise vimconn.vimconnConflictException("Flavor {} already exist at VIM. Error {}".format(flv_id, free))
+ raise vimconn.VimConnConflictException("Flavor {} already exist at VIM. Error {}".format(flv_id, free))
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
return flv_id
def delete_flavor(self, flavor_id):
try:
self.fos_api.flavor.remove(flavor_id)
except fimapi.FIMNotFoundException as fnfe:
- raise vimconn.vimconnNotFoundException("Flavor {} not found at VIM (already deleted?). Error {}".format(flavor_id, fnfe))
+ raise vimconn.VimConnNotFoundException("Flavor {} not found at VIM (already deleted?). Error {}".format(flavor_id, fnfe))
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
return flavor_id
def new_image(self, image_dict):
try:
self.fos_api.image.add(desc)
except fimapi.FIMAResouceExistingException as free:
- raise vimconn.vimconnConflictException("Image {} already exist at VIM. Error {}".format(img_id, free))
+ raise vimconn.VimConnConflictException("Image {} already exist at VIM. Error {}".format(img_id, free))
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
return img_id
def get_image_id_from_path(self, path):
try:
imgs = self.fos_api.image.list()
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
res = [x.get('uuid') for x in imgs if x.get('uri')==path]
if len(res) == 0:
- raise vimconn.vimconnNotFoundException("Image with this path was not found")
+ raise vimconn.VimConnNotFoundException("Image with this path was not found")
return res[0]
def get_image_list(self, filter_dict={}):
try:
fimgs = self.fos_api.image.list()
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
filters = [
partial(self.__name_filter, filter_name=filter_dict.get('name')),
}
r.append(img_info)
return r
- #raise vimconnNotImplemented( "Should have implemented this" )
+ #raise VimConnNotImplemented( "Should have implemented this" )
def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
availability_zone_index=None, availability_zone_list=None):
img = self.fos_api.image.get(image_id)
if flv is None:
- raise vimconn.vimconnNotFoundException("Flavor {} not found at VIM".format(flavor_id))
+ raise vimconn.VimConnNotFoundException("Flavor {} not found at VIM".format(flavor_id))
if img is None:
- raise vimconn.vimconnNotFoundException("Image {} not found at VIM".format(image_id))
+ raise vimconn.VimConnNotFoundException("Image {} not found at VIM".format(image_id))
created_items = {
'fdu_id':'',
self.logger.debug('Eclipse fog05 FDU Descriptor: {}'.format(fdu_desc))
+
fdu = FDU(fdu_desc)
try:
self.logger.debug('new_vminstance returns: {} {}'.format( instance.uuid, created_items))
return str(instance.uuid), created_items
except fimapi.FIMAResouceExistingException as free:
- raise vimconn.vimconnConflictException("VM already exists at VIM. Error {}".format(free))
+ raise vimconn.VimConnConflictException("VM already exists at VIM. Error {}".format(free))
except Exception as e:
- raise vimconn.vimconnException("Error while instantiating VM {}. Error {}".format(name, e))
+ raise vimconn.VimConnException("Error while instantiating VM {}. Error {}".format(name, e))
def get_vminstance(self,vm_id):
"""Returns the VM instance information from VIM"""
try:
instance = self.fos_api.fdu.instance_info(vm_id)
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
if instance is None:
- raise vimconn.vimconnNotFoundException('VM with id {} not found!'.format(vm_id))
+ raise vimconn.VimConnNotFoundException('VM with id {} not found!'.format(vm_id))
return instance.to_json()
def delete_vminstance(self, vm_id, created_items=None):
self.fos_api.fdu.offload(fduid)
except Exception as e:
- raise vimconn.vimconnException("Error on deletting VM with id {}. Error {}".format(vm_id,e))
+ raise vimconn.VimConnException("Error on deletting VM with id {}. Error {}".format(vm_id,e))
return vm_id
- #raise vimconnNotImplemented( "Should have implemented this" )
+ #raise VimConnNotImplemented( "Should have implemented this" )
def refresh_vms_status(self, vm_list):
"""Get the status of the virtual machines and their interfaces/ports
self.logger.debug('VIM action_vminstance with args: {}'.format(locals()))
nid = self.fdu_node_map.get(vm_id)
if nid is None:
- raise vimconn.vimconnNotFoundException('No node for this VM')
+ raise vimconn.VimConnNotFoundException('No node for this VM')
try:
instance = self.fos_api.fdu.instance_info(vm_id)
if "start" in action_dict:
elif instance.get('status') == 'PAUSE':
self.fos_api.fdu.resume(vm_id)
else:
- raise vimconn.vimconnConflictException('Cannot start from current state: {}'.format(instance.get('status')))
+ raise vimconn.VimConnConflictException('Cannot start from current state: {}'.format(instance.get('status')))
elif "pause" in action_dict:
if instance.get('status') == 'RUN':
self.fos_api.fdu.pause(vm_id)
else:
- raise vimconn.vimconnConflictException('Cannot pause from current state: {}'.format(instance.get('status')))
+ raise vimconn.VimConnConflictException('Cannot pause from current state: {}'.format(instance.get('status')))
elif "resume" in action_dict:
if instance.get('status') == 'PAUSE':
self.fos_api.fdu.resume(vm_id)
else:
- raise vimconn.vimconnConflictException('Cannot resume from current state: {}'.format(instance.get('status')))
+ raise vimconn.VimConnConflictException('Cannot resume from current state: {}'.format(instance.get('status')))
elif "shutoff" in action_dict or "shutdown" or "forceOff" in action_dict:
if instance.get('status') == 'RUN':
self.fos_api.fdu.stop(vm_id)
else:
- raise vimconn.vimconnConflictException('Cannot shutoff from current state: {}'.format(instance.get('status')))
+ raise vimconn.VimConnConflictException('Cannot shutoff from current state: {}'.format(instance.get('status')))
elif "terminate" in action_dict:
if instance.get('status') == 'RUN':
self.fos_api.fdu.stop(vm_id)
self.fos_api.fdu.undefine(vm_id)
# self.fos_api.fdu.offload(vm_id)
else:
- raise vimconn.vimconnConflictException('Cannot terminate from current state: {}'.format(instance.get('status')))
+ raise vimconn.VimConnConflictException('Cannot terminate from current state: {}'.format(instance.get('status')))
elif "rebuild" in action_dict:
- raise vimconn.vimconnNotImplemented("Rebuild not implememnted")
+ raise vimconn.VimConnNotImplemented("Rebuild not implemented")
elif "reboot" in action_dict:
if instance.get('status') == 'RUN':
self.fos_api.fdu.stop(vm_id)
self.fos_api.fdu.start(vm_id)
else:
- raise vimconn.vimconnConflictException('Cannot reboot from current state: {}'.format(instance.get('status')))
+ raise vimconn.VimConnConflictException('Cannot reboot from current state: {}'.format(instance.get('status')))
except Exception as e:
- raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e))
+ raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))
yaks==0.3.0.post1
pyangbind
sphinx
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
"fog05==0.2.0",
"pyangbind",
"sphinx",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_fos = osm_rovim_fos.vimconn_fos'],
+ 'osm_rovim.plugins': ['rovim_fos = osm_rovim_fos.vimconn_fos:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-pip, python3-requests, python3-netaddr, python3-yaml, python3-osm-ro
+Depends3: python3-pip, python3-requests, python3-netaddr, python3-yaml, python3-osm-ro-plugin
__author__ = "Jose Maria Carmona Perez,Juan Antonio Hernando Labajo, Emilio Abraham Garrido Garcia,Alberto Florez " \
"Pages, Andres Pozo Munoz, Santiago Perez Marin, Onlife Networks Telefonica I+D Product Innovation "
__date__ = "$13-dec-2017 11:09:29$"
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
import requests
import logging
import oca
import random
import pyone
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,
log_level="DEBUG", config={}, persistent_info={}):
check against the VIM
"""
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
config)
def _new_one_connection(self):
return str(group.id)
except Exception as e:
self.logger.error("Create new tenant error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def delete_tenant(self, tenant_id):
"""Delete a tenant from VIM. Returns the old tenant identifier"""
self._delete_secondarygroup(user.id, group.id)
group.delete(client)
return None
- raise vimconn.vimconnNotFoundException("Group {} not found".format(tenant_id))
+ raise vimconn.VimConnNotFoundException("Group {} not found".format(tenant_id))
except Exception as e:
self.logger.error("Delete tenant " + str(tenant_id) + " error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def _add_secondarygroup(self, id_user, id_group):
# change secondary_group to primary_group
return net_id, created_items
except Exception as e:
self.logger.error("Create new network error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def get_network_list(self, filter_dict={}):
"""Obtain tenant networks of VIM
return response
except Exception as e:
self.logger.error("Get network list error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def get_network(self, net_id):
"""Obtain network details from the 'net_id' VIM network
if net:
return net
else:
- raise vimconn.vimconnNotFoundException("Network {} not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("Network {} not found".format(net_id))
except Exception as e:
self.logger.error("Get network " + str(net_id) + " error): " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def delete_network(self, net_id, created_items=None):
"""
return net_id
except Exception as e:
self.logger.error("Delete network " + str(net_id) + "error: network not found" + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def refresh_nets_status(self, net_list):
"""Get the status of the networks
net_vim = self.get_network(net_id)
net["status"] = net_vim["status"]
net["vim_info"] = None
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
self.logger.error("Exception getting net status: {}".format(str(e)))
net['status'] = "DELETED"
net['error_msg'] = str(e)
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
self.logger.error(e)
net["status"] = "VIM_ERROR"
net["error_msg"] = str(e)
net_dict[net_id] = net
return net_dict
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
self.logger.error(e)
for k in net_dict:
net_dict[k]["status"] = "VIM_ERROR"
template = one.template.info(int(flavor_id))
if template is not None:
return {'id': template.ID, 'name': template.NAME}
- raise vimconn.vimconnNotFoundException("Flavor {} not found".format(flavor_id))
+ raise vimconn.VimConnNotFoundException("Flavor {} not found".format(flavor_id))
except Exception as e:
self.logger.error("get flavor " + str(flavor_id) + " error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def new_flavor(self, flavor_data):
"""Adds a tenant flavor to VIM
except Exception as e:
self.logger.error("Create new flavor error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def delete_flavor(self, flavor_id):
""" Deletes a tenant flavor from VIM
return flavor_id
except Exception as e:
self.logger.error("Error deleting flavor " + str(flavor_id) + ". Flavor not found")
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def get_image_list(self, filter_dict={}):
"""Obtain tenant images from VIM
return images
except Exception as e:
self.logger.error("Get image list error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
availability_zone_index=None, availability_zone_list=None):
return str(vm_instance_id), None
except pyone.OneNoExistsException as e:
self.logger.error("Network with id " + str(e) + " not found: " + str(e))
- raise vimconn.vimconnNotFoundException(e)
+ raise vimconn.VimConnNotFoundException(e)
except Exception as e:
self.logger.error("Create new vm instance error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def get_vminstance(self, vm_id):
"""Returns the VM instance information from VIM"""
return vm
except Exception as e:
self.logger.error("Getting vm instance error: " + str(e) + ": VM Instance not found")
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def delete_vminstance(self, vm_id, created_items=None):
"""
except pyone.OneNoExistsException as e:
self.logger.info("The vm " + str(vm_id) + " does not exist or is already deleted")
- raise vimconn.vimconnNotFoundException("The vm {} does not exist or is already deleted".format(vm_id))
+ raise vimconn.VimConnNotFoundException("The vm {} does not exist or is already deleted".format(vm_id))
except Exception as e:
self.logger.error("Delete vm instance " + str(vm_id) + " error: " + str(e))
- raise vimconn.vimconnException(e)
+ raise vimconn.VimConnException(e)
def refresh_vms_status(self, vm_list):
"""Get the status of the virtual machines and their interfaces/ports
untangle
pyone
git+https://github.com/python-oca/python-oca#egg=oca
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
"requests",
"netaddr",
"PyYAML",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_opennebula = osm_rovim_opennebula.vimconn_opennebula'],
+ 'osm_rovim.plugins': ['rovim_opennebula = osm_rovim_opennebula.vimconn_opennebula:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro, python3-pip
+Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro-plugin, python3-pip
import mock
from neutronclient.v2_0.client import Client
-from osm_ro import vimconn
-from osm_ro.vimconn_openstack import vimconnector
+from osm_ro_plugin import vimconn
+from osm_rovim_openstack.vimconn_openstack import vimconnector
__author__ = "Igor D.C."
@mock.patch.object(Client, 'create_sfc_flow_classifier')
def test_new_classification_unsupported_type(self, create_sfc_flow_classifier):
- self.assertRaises(vimconn.vimconnNotSupportedException,
+ self.assertRaises(vimconn.VimConnNotSupportedException,
self._test_new_classification,
create_sfc_flow_classifier, 'h265')
def test_new_sfi_bad_ingress_ports(self, create_sfc_port_pair):
ingress_ports = ['5311c75d-d718-4369-bbda-cdcc6da60fcc',
'a0273f64-82c9-11e7-b08f-6328e53f0fa7']
- self.assertRaises(vimconn.vimconnNotSupportedException,
+ self.assertRaises(vimconn.VimConnNotSupportedException,
self._test_new_sfi,
create_sfc_port_pair, True, ingress_ports=ingress_ports)
ingress_ports = []
- self.assertRaises(vimconn.vimconnNotSupportedException,
+ self.assertRaises(vimconn.VimConnNotSupportedException,
self._test_new_sfi,
create_sfc_port_pair, True, ingress_ports=ingress_ports)
def test_new_sfi_bad_egress_ports(self, create_sfc_port_pair):
egress_ports = ['230cdf1b-de37-4891-bc07-f9010cf1f967',
'b41228fe-82c9-11e7-9b44-17504174320b']
- self.assertRaises(vimconn.vimconnNotSupportedException,
+ self.assertRaises(vimconn.VimConnNotSupportedException,
self._test_new_sfi,
create_sfc_port_pair, True, egress_ports=egress_ports)
egress_ports = []
- self.assertRaises(vimconn.vimconnNotSupportedException,
+ self.assertRaises(vimconn.VimConnNotSupportedException,
self._test_new_sfi,
create_sfc_port_pair, True, egress_ports=egress_ports)
def test_new_sf_inconsistent_sfc_encap(self, create_sfc_port_pair_group,
get_sfi):
get_sfi.return_value = {'sfc_encap': 'nsh'}
- self.assertRaises(vimconn.vimconnNotSupportedException,
+ self.assertRaises(vimconn.VimConnNotSupportedException,
self._test_new_sf, create_sfc_port_pair_group)
@mock.patch.object(Client, 'create_sfc_port_chain')
]}
# call the VIM connector
- self.assertRaises(vimconn.vimconnConflictException,
+ self.assertRaises(vimconn.VimConnConflictException,
self.vimconn.get_classification,
'3196bafc-82dd-11e7-a205-9bf6c14b0721')
list_sfc_flow_classifiers.return_value = {'flow_classifiers': []}
# call the VIM connector
- self.assertRaises(vimconn.vimconnNotFoundException,
+ self.assertRaises(vimconn.VimConnNotFoundException,
self.vimconn.get_classification,
'3196bafc-82dd-11e7-a205-9bf6c14b0721')
]}
# call the VIM connector
- self.assertRaises(vimconn.vimconnConflictException,
+ self.assertRaises(vimconn.VimConnConflictException,
self.vimconn.get_sfi,
'c0436d92-82db-11e7-8f9c-5fa535f1261f')
list_sfc_port_pairs.return_value = {'port_pairs': []}
# call the VIM connector
- self.assertRaises(vimconn.vimconnNotFoundException,
+ self.assertRaises(vimconn.VimConnNotFoundException,
self.vimconn.get_sfi,
'b22892fc-82d9-11e7-ae85-0fea6a3b3757')
]}
# call the VIM connector
- self.assertRaises(vimconn.vimconnConflictException,
+ self.assertRaises(vimconn.VimConnConflictException,
self.vimconn.get_sf,
'b22892fc-82d9-11e7-ae85-0fea6a3b3757')
list_sfc_port_pair_groups.return_value = {'port_pair_groups': []}
# call the VIM connector
- self.assertRaises(vimconn.vimconnNotFoundException,
+ self.assertRaises(vimconn.VimConnNotFoundException,
self.vimconn.get_sf,
'b22892fc-82d9-11e7-ae85-0fea6a3b3757')
]}
# call the VIM connector
- self.assertRaises(vimconn.vimconnConflictException,
+ self.assertRaises(vimconn.VimConnConflictException,
self.vimconn.get_sfp,
'5d002f38-82de-11e7-a770-f303f11ce66a')
list_sfc_port_chains.return_value = {'port_chains': []}
# call the VIM connector
- self.assertRaises(vimconn.vimconnNotFoundException,
+ self.assertRaises(vimconn.VimConnNotFoundException,
self.vimconn.get_sfp,
'5d002f38-82de-11e7-a770-f303f11ce66a')
__author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C., Eduardo Sousa"
__date__ = "$22-sep-2017 23:59:59$"
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
# import json
import logging
import netaddr
return super(SafeDumper, self).represent_data(data)
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,
log_level=None, config={}, persistent_info={}):
'''using common constructor parameters. In this case
'''
api_version = config.get('APIversion')
if api_version and api_version not in ('v3.3', 'v2.0', '2', '3'):
- raise vimconn.vimconnException("Invalid value '{}' for config:APIversion. "
+ raise vimconn.VimConnException("Invalid value '{}' for config:APIversion. "
"Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version))
vim_type = config.get('vim_type')
if vim_type and vim_type not in ('vio', 'VIO'):
- raise vimconn.vimconnException("Invalid value '{}' for config:vim_type."
+ raise vimconn.VimConnException("Invalid value '{}' for config:vim_type."
"Allowed values are 'vio' or 'VIO'".format(vim_type))
if config.get('dataplane_net_vlan_range') is not None:
#validate vlan ranges provided by user
self._validate_vlan_ranges(config.get('multisegment_vlan_range'), 'multisegment_vlan_range')
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
config)
if self.config.get("insecure") and self.config.get("ca_cert"):
- raise vimconn.vimconnException("options insecure and ca_cert are mutually exclusive")
+ raise vimconn.VimConnException("options insecure and ca_cert are mutually exclusive")
self.verify = True
if self.config.get("insecure"):
self.verify = False
elif index == 'user_domain_id':
return self.config.get("user_domain_id")
else:
- return vimconn.vimconnector.__getitem__(self, index)
+ return vimconn.VimConnector.__getitem__(self, index)
def __setitem__(self, index, value):
"""Set individuals parameters and it is marked as dirty so to force connection reload.
elif index == 'user_domain_id':
self.config["user_domain_id"] = value
else:
- vimconn.vimconnector.__setitem__(self, index, value)
+ vimconn.VimConnector.__setitem__(self, index, value)
self.session['reload_client'] = True
def serialize(self, value):
if isinstance(exception, (neExceptions.NetworkNotFoundClient, nvExceptions.NotFound, ksExceptions.NotFound,
gl1Exceptions.HTTPNotFound)):
- raise vimconn.vimconnNotFoundException(type(exception).__name__ + ": " + message_error)
+ raise vimconn.VimConnNotFoundException(type(exception).__name__ + ": " + message_error)
elif isinstance(exception, (HTTPException, gl1Exceptions.HTTPException, gl1Exceptions.CommunicationError,
ConnectionError, ksExceptions.ConnectionError, neExceptions.ConnectionFailed)):
- raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + message_error)
+ raise vimconn.VimConnConnectionException(type(exception).__name__ + ": " + message_error)
elif isinstance(exception, (KeyError, nvExceptions.BadRequest, ksExceptions.BadRequest)):
- raise vimconn.vimconnException(type(exception).__name__ + ": " + message_error)
+ raise vimconn.VimConnException(type(exception).__name__ + ": " + message_error)
elif isinstance(exception, (nvExceptions.ClientException, ksExceptions.ClientException,
neExceptions.NeutronException)):
- raise vimconn.vimconnUnexpectedResponse(type(exception).__name__ + ": " + message_error)
+ raise vimconn.VimConnUnexpectedResponse(type(exception).__name__ + ": " + message_error)
elif isinstance(exception, nvExceptions.Conflict):
- raise vimconn.vimconnConflictException(type(exception).__name__ + ": " + message_error)
- elif isinstance(exception, vimconn.vimconnException):
+ raise vimconn.VimConnConflictException(type(exception).__name__ + ": " + message_error)
+ elif isinstance(exception, vimconn.VimConnException):
raise exception
else: # ()
self.logger.error("General Exception " + message_error, exc_info=True)
- raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + message_error)
+ raise vimconn.VimConnConnectionException(type(exception).__name__ + ": " + message_error)
def _get_ids_from_name(self):
"""
# get tenant_id if only tenant_name is supplied
self._reload_connection()
if not self.my_tenant_id:
- raise vimconn.vimconnConnectionException("Error getting tenant information from name={} id={}".
+ raise vimconn.VimConnConnectionException("Error getting tenant information from name={} id={}".
format(self.tenant_name, self.tenant_id))
if self.config.get('security_groups') and not self.security_groups_id:
# convert from name to id
break
else:
self.security_groups_id = None
- raise vimconn.vimconnConnectionException("Not found security group {} for this tenant".format(sg))
+ raise vimconn.VimConnConnectionException("Not found security group {} for this tenant".format(sg))
def check_vim_connectivity(self):
# just get network list to check connectivity and credentials
# or not declared, just ignore the checking
if isinstance(self.config.get('dataplane_physical_net'), (tuple, list)) and \
provider_physical_network not in self.config['dataplane_physical_net']:
- raise vimconn.vimconnConflictException(
+ raise vimconn.VimConnConflictException(
"Invalid parameter 'provider-network:physical-network' for network creation. '{}' is not "
"one of the declared list at VIM_config:dataplane_physical_net".format(
provider_physical_network))
provider_physical_network = provider_physical_network[0]
if not provider_physical_network:
- raise vimconn.vimconnConflictException("You must provide a 'dataplane_physical_net' at VIM_config "
+ raise vimconn.VimConnConflictException("You must provide a 'dataplane_physical_net' at VIM_config "
"for creating underlay networks. or use the NS instantiation"
" parameter provider-network:physical-network for the VLD")
vlanID = self._generate_multisegment_vlanID()
segment2_dict["provider:segmentation_id"] = vlanID
# else
- # raise vimconn.vimconnConflictException(
+ # raise vimconn.VimConnConflictException(
# "You must provide 'multisegment_vlan_range' at config dict before creating a multisegment network")
segment_list.append(segment2_dict)
network_dict["segments"] = segment_list
# VIO Specific Changes. It needs a concrete VLAN
if self.vim_type == "VIO" and vlan is None:
if self.config.get('dataplane_net_vlan_range') is None:
- raise vimconn.vimconnConflictException(
+ raise vimconn.VimConnConflictException(
"You must provide 'dataplane_net_vlan_range' in format [start_ID - end_ID] at VIM_config "
"for creating underlay networks")
network_dict["provider:segmentation_id"] = self._generate_vlanID()
filter_dict={"id": net_id}
net_list = self.get_network_list(filter_dict)
if len(net_list)==0:
- raise vimconn.vimconnNotFoundException("Network '{}' not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("Network '{}' not found".format(net_id))
elif len(net_list)>1:
- raise vimconn.vimconnConflictException("Found more than one network with this criteria")
+ raise vimconn.VimConnConflictException("Found more than one network with this criteria")
net = net_list[0]
subnets=[]
for subnet_id in net.get("subnets", () ):
if net_vim.get('fault'): #TODO
net['error_msg'] = str(net_vim['fault'])
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
self.logger.error("Exception getting net status: %s", str(e))
net['status'] = "DELETED"
net['error_msg'] = str(e)
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
self.logger.error("Exception getting net status: %s", str(e))
net['status'] = "VIM_ERROR"
net['error_msg'] = str(e)
extended = flavor_dict.get("extended", {})
if extended:
#TODO
- raise vimconn.vimconnNotFoundException("Flavor with EPA still not implemented")
+ raise vimconn.VimConnNotFoundException("Flavor with EPA still not implemented")
# if len(numas) > 1:
- # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
+ # raise vimconn.VimConnNotFoundException("Cannot find any flavor with more than one numa")
# numa=numas[0]
# numas = extended.get("numas")
for flavor in self.nova.flavors.list():
flavor_candidate_data = flavor_data
if not exact_match and flavor_candidate_id:
return flavor_candidate_id
- raise vimconn.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict)))
+ raise vimconn.VimConnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict)))
except (nvExceptions.NotFound, nvExceptions.ClientException, ksExceptions.ClientException, ConnectionError) as e:
self._format_exception(e)
extra_specs["hw:cpu_policy"] = "dedicated"
# for interface in numa.get("interfaces",() ):
# if interface["dedicated"]=="yes":
- # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
+ # raise vimconn.VimConnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
# #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
elif extended.get("cpu-quota"):
self.process_resource_quota(extended.get("cpu-quota"), "cpu", extra_specs)
new_image = self.glance.images.create(name=image_dict['name'])
if image_dict['location'].startswith("http"):
# TODO there is not a method to direct download. It must be downloaded locally with requests
- raise vimconn.vimconnNotImplemented("Cannot create image from URL")
+ raise vimconn.VimConnNotImplemented("Cannot create image from URL")
else: #local path
with open(image_dict['location']) as fimage:
self.glance.images.upload(new_image.id, fimage)
continue
self._format_exception(e)
except IOError as e: #can not open the file
- raise vimconn.vimconnConnectionException(type(e).__name__ + ": " + str(e)+ " for " + image_dict['location'],
+ raise vimconn.VimConnConnectionException(type(e).__name__ + ": " + str(e)+ " for " + image_dict['location'],
http_code=vimconn.HTTP_Bad_Request)
def delete_image(self, image_id):
for image in images:
if image.metadata.get("location")==path:
return image.id
- raise vimconn.vimconnNotFoundException("image with location '{}' not found".format( path))
+ raise vimconn.VimConnNotFoundException("image with location '{}' not found".format( path))
except (ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e:
self._format_exception(e)
# if we exceeded the timeout rollback
if elapsed_time >= server_timeout:
- raise vimconn.vimconnException('Timeout waiting for instance ' + vm_id + ' to get ' + status,
+ raise vimconn.VimConnException('Timeout waiting for instance ' + vm_id + ' to get ' + status,
http_code=vimconn.HTTP_Request_Timeout)
def _get_openstack_availablity_zones(self):
else:
return availability_zone_list[availability_zone_index]
else:
- raise vimconn.vimconnConflictException("No enough availability zones at VIM for this deployment")
+ raise vimconn.VimConnConflictException("No enough availability zones at VIM for this deployment")
def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
availability_zone_index=None, availability_zone_list=None):
elapsed_time += 5
# If we exceeded the timeout rollback
if elapsed_time >= volume_timeout:
- raise vimconn.vimconnException('Timeout creating volumes for instance ' + name,
+ raise vimconn.VimConnException('Timeout creating volumes for instance ' + name,
http_code=vimconn.HTTP_Request_Timeout)
# get availability Zone
vm_av_zone = self._get_vm_availability_zone(availability_zone_index, availability_zone_list)
self.neutron.update_port(port_id,
{"port": {"port_security_enabled": False, "security_groups": None}})
except Exception as e:
- raise vimconn.vimconnException("It was not possible to disable port security for port {}".format(
+ raise vimconn.VimConnException("It was not possible to disable port security for port {}".format(
port_id))
# print "DONE :-)", server
external_nets.append(net)
if len(external_nets) == 0:
- raise vimconn.vimconnException("Cannot create floating_ip automatically since no external "
+ raise vimconn.VimConnException("Cannot create floating_ip automatically since no external "
"network is present",
http_code=vimconn.HTTP_Conflict)
if len(external_nets) > 1:
- raise vimconn.vimconnException("Cannot create floating_ip automatically since multiple "
+ raise vimconn.VimConnException("Cannot create floating_ip automatically since multiple "
"external networks are present",
http_code=vimconn.HTTP_Conflict)
new_floating_ip = self.neutron.create_floatingip(param)
free_floating_ip = new_floating_ip['floatingip']['id']
except Exception as e:
- raise vimconn.vimconnException(type(e).__name__ + ": Cannot create new floating_ip " +
+ raise vimconn.VimConnException(type(e).__name__ + ": Cannot create new floating_ip " +
str(e), http_code=vimconn.HTTP_Conflict)
while not assigned:
if time.time() - vm_start_time < server_timeout:
time.sleep(5)
continue
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"Cannot create floating_ip: {} {}".format(type(e).__name__, e),
http_code=vimconn.HTTP_Conflict)
# error_value=-vimconn.HTTP_Not_Found
# error_text= "vm instance %s not found" % vm_id
# except TypeError as e:
-# raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
+# raise vimconn.VimConnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
except Exception as e:
server_id = None
elif console_type == "spice-html5":
console_dict = server.get_spice_console(console_type)
else:
- raise vimconn.vimconnException("console type '{}' not allowed".format(console_type), http_code=vimconn.HTTP_Bad_Request)
+ raise vimconn.VimConnException("console type '{}' not allowed".format(console_type), http_code=vimconn.HTTP_Bad_Request)
console_dict1 = console_dict.get("console")
if console_dict1:
}
protocol_index += 2
return console_dict
- raise vimconn.vimconnUnexpectedResponse("Unexpected response from VIM")
+ raise vimconn.VimConnUnexpectedResponse("Unexpected response from VIM")
except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.BadRequest, ConnectionError) as e:
self._format_exception(e)
except Exception as e:
self.logger.error("Error getting vm interface information {}: {}".format(type(e).__name__, e),
exc_info=True)
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
self.logger.error("Exception getting vm status: %s", str(e))
vm['status'] = "DELETED"
vm['error_msg'] = str(e)
- except vimconn.vimconnException as e:
+ except vimconn.VimConnException as e:
self.logger.error("Exception getting vm status: %s", str(e))
vm['status'] = "VIM_ERROR"
vm['error_msg'] = str(e)
elif console_type == "spice-html5":
console_dict = server.get_spice_console(console_type)
else:
- raise vimconn.vimconnException("console type '{}' not allowed".format(console_type),
+ raise vimconn.VimConnException("console type '{}' not allowed".format(console_type),
http_code=vimconn.HTTP_Bad_Request)
try:
console_url = console_dict["console"]["url"]
suffix_index = console_url[protocol_index+2:].find("/") + protocol_index+2
port_index = console_url[protocol_index+2:suffix_index].find(":") + protocol_index+2
if protocol_index < 0 or port_index<0 or suffix_index<0:
- raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
+ raise vimconn.VimConnException("Unexpected response from VIM " + str(console_dict))
console_dict2={"protocol": console_url[0:protocol_index],
"server": console_url[protocol_index+2 : port_index],
"port": int(console_url[port_index+1 : suffix_index]),
}
return console_dict2
except Exception as e:
- raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
+ raise vimconn.VimConnException("Unexpected response from VIM " + str(console_dict))
return None
except (ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.NotFound, ConnectionError) as e:
if vlanID not in used_vlanIDs:
return vlanID
except Exception as exp:
- raise vimconn.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp))
+ raise vimconn.VimConnException("Exception {} occurred while generating VLAN ID.".format(exp))
else:
- raise vimconn.vimconnConflictException("Unable to create the SRIOV VLAN network."\
+ raise vimconn.VimConnConflictException("Unable to create the SRIOV VLAN network."\
" All given Vlan IDs {} are in use.".format(self.config.get('dataplane_net_vlan_range')))
if vlanID not in used_vlanIDs:
return vlanID
except Exception as exp:
- raise vimconn.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp))
+ raise vimconn.VimConnException("Exception {} occurred while generating VLAN ID.".format(exp))
else:
- raise vimconn.vimconnConflictException("Unable to create the VLAN segment."
+ raise vimconn.VimConnConflictException("Unable to create the VLAN segment."
" All VLAN IDs {} are in use.".format(self.config.get('multisegment_vlan_range')))
vlanID_pattern = r'(\d)*-(\d)*$'
match_obj = re.match(vlanID_pattern, vlan_range)
if not match_obj:
- raise vimconn.vimconnConflictException("Invalid VLAN range for {}: {}.You must provide "\
+ raise vimconn.VimConnConflictException("Invalid VLAN range for {}: {}.You must provide "\
"'{}' in format [start_ID - end_ID].".format(text_vlan_range, vlanID_range, text_vlan_range))
start_vlanid , end_vlanid = map(int,vlan_range.split("-"))
if start_vlanid <= 0 :
- raise vimconn.vimconnConflictException("Invalid VLAN range for {}: {}."\
+ raise vimconn.VimConnConflictException("Invalid VLAN range for {}: {}."\
"Start ID can not be zero. For VLAN "\
"networks valid IDs are 1 to 4094 ".format(text_vlan_range, vlanID_range))
if end_vlanid > 4094 :
- raise vimconn.vimconnConflictException("Invalid VLAN range for {}: {}."\
+ raise vimconn.VimConnConflictException("Invalid VLAN range for {}: {}."\
"End VLAN ID can not be greater than 4094. For VLAN "\
"networks valid IDs are 1 to 4094 ".format(text_vlan_range, vlanID_range))
if start_vlanid > end_vlanid:
- raise vimconn.vimconnConflictException("Invalid VLAN range for {}: {}."\
+ raise vimconn.VimConnConflictException("Invalid VLAN range for {}: {}."\
"You must provide '{}' in format start_ID - end_ID and "\
"start_ID < end_ID ".format(text_vlan_range, vlanID_range, text_vlan_range))
new_class = None
self._reload_connection()
if ctype not in supportedClassificationTypes:
- raise vimconn.vimconnNotSupportedException(
+ raise vimconn.VimConnNotSupportedException(
'OpenStack VIM connector doesn\'t support provided '
'Classification Type {}, supported ones are: '
'{}'.format(ctype, supportedClassificationTypes))
if not self._validate_classification(ctype, definition):
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
'Incorrect Classification definition '
'for the type specified.')
classification_dict = definition
filter_dict = {"id": class_id}
class_list = self.get_classification_list(filter_dict)
if len(class_list) == 0:
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Classification '{}' not found".format(class_id))
elif len(class_list) > 1:
- raise vimconn.vimconnConflictException(
+ raise vimconn.VimConnConflictException(
"Found more than one Classification with this criteria")
classification = class_list[0]
return classification
if sfc_encap:
correlation = 'nsh'
if len(ingress_ports) != 1:
- raise vimconn.vimconnNotSupportedException(
+ raise vimconn.VimConnNotSupportedException(
"OpenStack VIM connector can only have "
"1 ingress port per SFI")
if len(egress_ports) != 1:
- raise vimconn.vimconnNotSupportedException(
+ raise vimconn.VimConnNotSupportedException(
"OpenStack VIM connector can only have "
"1 egress port per SFI")
sfi_dict = {'name': name,
filter_dict = {"id": sfi_id}
sfi_list = self.get_sfi_list(filter_dict)
if len(sfi_list) == 0:
- raise vimconn.vimconnNotFoundException("Service Function Instance '{}' not found".format(sfi_id))
+ raise vimconn.VimConnNotFoundException("Service Function Instance '{}' not found".format(sfi_id))
elif len(sfi_list) > 1:
- raise vimconn.vimconnConflictException(
+ raise vimconn.VimConnConflictException(
'Found more than one Service Function Instance '
'with this criteria')
sfi = sfi_list[0]
for instance in sfis:
sfi = self.get_sfi(instance)
if sfi.get('sfc_encap') != sfc_encap:
- raise vimconn.vimconnNotSupportedException(
+ raise vimconn.VimConnNotSupportedException(
"OpenStack VIM connector requires all SFIs of the "
"same SF to share the same SFC Encapsulation")
sf_dict = {'name': name,
filter_dict = {"id": sf_id}
sf_list = self.get_sf_list(filter_dict)
if len(sf_list) == 0:
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Service Function '{}' not found".format(sf_id))
elif len(sf_list) > 1:
- raise vimconn.vimconnConflictException(
+ raise vimconn.VimConnConflictException(
"Found more than one Service Function with this criteria")
sf = sf_list[0]
return sf
filter_dict = {"id": sfp_id}
sfp_list = self.get_sfp_list(filter_dict)
if len(sfp_list) == 0:
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Service Function Path '{}' not found".format(sfp_id))
elif len(sfp_list) > 1:
- raise vimconn.vimconnConflictException(
+ raise vimconn.VimConnConflictException(
"Found more than one Service Function Path with this criteria")
sfp = sfp_list[0]
return sfp
if sfp_vim.get('fault'):
sfp['error_msg'] = str(sfp_vim['fault'])
- except vimconn.vimconnNotFoundException as e:
+ 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:
+ except vimconn.VimConnException as e:
self.logger.error("Exception getting sfp status: %s", str(e))
sfp['status'] = "VIM_ERROR"
sfp['error_msg'] = str(e)
if sfi_vim.get('fault'):
sfi['error_msg'] = str(sfi_vim['fault'])
- except vimconn.vimconnNotFoundException as e:
+ 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:
+ except vimconn.VimConnException as e:
self.logger.error("Exception getting sfi status: %s", str(e))
sfi['status'] = "VIM_ERROR"
sfi['error_msg'] = str(e)
if sf_vim.get('fault'):
sf['error_msg'] = str(sf_vim['fault'])
- except vimconn.vimconnNotFoundException as e:
+ 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:
+ except vimconn.VimConnException as e:
self.logger.error("Exception getting sf status: %s", str(e))
sf['status'] = "VIM_ERROR"
sf['error_msg'] = str(e)
if classification_vim.get('fault'):
classification['error_msg'] = str(classification_vim['fault'])
- except vimconn.vimconnNotFoundException as e:
+ 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:
+ except vimconn.VimConnException as e:
self.logger.error("Exception getting classification status: %s", str(e))
classification['status'] = "VIM_ERROR"
classification['error_msg'] = str(e)
#TODO py3 python-keystoneclient
#TODO py3 python-glanceclient
#TODO py3 python-cinderclient
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
install_requires=[
"python-openstackclient", "python-neutronclient",
"requests", "netaddr", "PyYAML",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
# TODO py3 "networking-l2gw"
# "python-novaclient", "python-keystoneclient", "python-glanceclient", "python-cinderclient",
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_openstack = osm_rovim_openstack.vimconn_openstack'],
+ 'osm_rovim.plugins': ['rovim_openstack = osm_rovim_openstack.vimconn_openstack:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
+Maintainer: Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>
Depends3: python3-openstackclient, python3-neutronclient, python3-requests, python3-netaddr, python3-yaml,
- python3-osm-ro, python3-pip
+ python3-osm-ro-plugin, python3-pip
# TODO py3 python3-networking-l2gw
__author__="Alfonso Tierno, Gerardo Garcia"
__date__ ="$26-aug-2014 11:09:29$"
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
import requests
import json
import yaml
}
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,
log_level="DEBUG", config={}, persistent_info={}):
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, config)
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, config)
self.tenant = None
self.headers_req = {'content-type': 'application/json'}
self.logger = logging.getLogger('openmano.vim.openvim')
self.tenant = value
elif index=='tenant_name':
self.tenant = None
- vimconn.vimconnector.__setitem__(self,index, value)
+ vimconn.VimConnector.__setitem__(self,index, value)
def _get_my_tenant(self):
'''Obtain uuid of my tenant from name
try:
tenant_list = vim_response.json()["tenants"]
if len(tenant_list) == 0:
- raise vimconn.vimconnNotFoundException("No tenant found for name '{}'".format(self.tenant_name))
+ raise vimconn.VimConnNotFoundException("No tenant found for name '{}'".format(self.tenant_name))
elif len(tenant_list) > 1:
- raise vimconn.vimconnConflictException ("More that one tenant found for name '{}'".format(self.tenant_name))
+ raise vimconn.VimConnConflictException ("More that one tenant found for name '{}'".format(self.tenant_name))
self.tenant = tenant_list[0]["id"]
return self.tenant
except Exception as e:
- raise vimconn.vimconnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e).__name__, str(e)))
+ raise vimconn.VimConnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e).__name__, str(e)))
def _format_jsonerror(self,http_response):
#DEPRECATED, to delete in the future
def _format_request_exception(self, request_exception):
'''Transform a request exception into a vimconn exception'''
if isinstance(request_exception, js_e.ValidationError):
- raise vimconn.vimconnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception.message, request_exception.path))
+ raise vimconn.VimConnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception.message, request_exception.path))
elif isinstance(request_exception, requests.exceptions.HTTPError):
- raise vimconn.vimconnUnexpectedResponse(type(request_exception).__name__ + ": " + str(request_exception))
+ raise vimconn.VimConnUnexpectedResponse(type(request_exception).__name__ + ": " + str(request_exception))
else:
- raise vimconn.vimconnConnectionException(type(request_exception).__name__ + ": " + str(request_exception))
+ raise vimconn.VimConnConnectionException(type(request_exception).__name__ + ": " + str(request_exception))
def _check_http_request_response(self, request_response):
'''Raise a vimconn exception if the response is not Ok'''
if request_response.status_code >= 200 and request_response.status_code < 300:
return
if request_response.status_code == vimconn.HTTP_Unauthorized:
- raise vimconn.vimconnAuthException(request_response.text)
+ raise vimconn.VimConnAuthException(request_response.text)
elif request_response.status_code == vimconn.HTTP_Not_Found:
- raise vimconn.vimconnNotFoundException(request_response.text)
+ raise vimconn.VimConnNotFoundException(request_response.text)
elif request_response.status_code == vimconn.HTTP_Conflict:
- raise vimconn.vimconnConflictException(request_response.text)
+ raise vimconn.VimConnConflictException(request_response.text)
else:
- raise vimconn.vimconnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response.status_code, str(request_response.text)))
+ raise vimconn.VimConnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response.status_code, str(request_response.text)))
def new_tenant(self,tenant_name,tenant_description):
'''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
#if r is not None:
# self.logger.warn("Warning: remove extra items %s", str(r))
if len(response['images'])==0:
- raise vimconn.vimconnNotFoundException("Image not found at VIM with path '{}'".format(path))
+ raise vimconn.VimConnNotFoundException("Image not found at VIM with path '{}'".format(path))
elif len(response['images'])>1:
- raise vimconn.vimconnConflictException("More than one image found at VIM with path '{}'".format(path))
+ raise vimconn.VimConnConflictException("More than one image found at VIM with path '{}'".format(path))
return response['images'][0]['id']
except (requests.exceptions.RequestException, js_e.ValidationError) as e:
self._format_request_exception(e)
if vm['status'] == "ACTIVE" and not management_ip:
vm['status'] = "ACTIVE:NoMgmtIP"
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
self.logger.error("Exception getting vm status: %s", str(e))
vm['status'] = "DELETED"
vm['error_msg'] = str(e)
- except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.vimconnException) as e:
+ except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.VimConnException) as e:
self.logger.error("Exception getting vm status: %s", str(e))
vm['status'] = "VIM_ERROR"
vm['error_msg'] = str(e)
if net_vim.get('last_error'):
net['error_msg'] = net_vim['last_error']
net["vim_info"] = yaml.safe_dump(net_vim)
- except vimconn.vimconnNotFoundException as e:
+ except vimconn.VimConnNotFoundException as e:
self.logger.error("Exception getting net status: %s", str(e))
net['status'] = "DELETED"
net['error_msg'] = str(e)
- except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.vimconnException) as e:
+ except (requests.exceptions.RequestException, js_e.ValidationError, vimconn.VimConnException) as e:
self.logger.error("Exception getting net status: %s", str(e))
net['status'] = "VIM_ERROR"
net['error_msg'] = str(e)
try:
self._get_my_tenant()
if "console" in action_dict:
- raise vimconn.vimconnException("getting console is not available at openvim", http_code=vimconn.HTTP_Service_Unavailable)
+ raise vimconn.VimConnException("getting console is not available at openvim", http_code=vimconn.HTTP_Service_Unavailable)
url = self.url+'/'+self.tenant+'/servers/'+vm_id+"/action"
self.logger.info("Action over VM instance POST %s", url)
vim_response = requests.post(url, headers = self.headers_req, data=json.dumps(action_dict) )
PyYAML
requests
netaddr
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
include_package_data=True,
install_requires=[
"requests", "netaddr", "PyYAML",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_openvim = osm_rovim_openvim.vimconn_openvim'],
+ 'osm_rovim.plugins': ['rovim_openvim = osm_rovim_openvim.vimconn_openvim:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro
+Maintainer: Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>
+Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro-plugin
from osm_rovim_vmware.vimconn_vmware import vimconnector
-from osm_ro.vimconn import vimconnUnexpectedResponse, vimconnNotFoundException,vimconnException
+from osm_ro_plugin.vimconn import VimConnUnexpectedResponse, VimConnNotFoundException,VimConnException
from pyvcloud.vcd.client import Client
from lxml import etree as lxmlElementTree
from pyvcloud.vcd.org import Org
perform_request.return_value.content = xml_resp.vdc_xml_response
# call to VIM connector method with invalid id
- self.assertRaises(vimconnNotFoundException,self.vim.get_network,'mgmt-net')
+ self.assertRaises(VimConnNotFoundException,self.vim.get_network,'mgmt-net')
@mock.patch.object(vimconnector,'perform_request')
@mock.patch.object(vimconnector,'get_vdc_details')
<OrgVdcNetwork></OrgVdcNetwork>"""
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnUnexpectedResponse,self.vim.new_network,
+ self.assertRaises(VimConnUnexpectedResponse,self.vim.new_network,
'test_net',
'bridge')
# assumed return value from VIM connector
get_vcd_network.return_value = False
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnNotFoundException,self.vim.delete_network,
+ self.assertRaises(VimConnNotFoundException,self.vim.delete_network,
'2a23e5d1-42a2-0648-bc92-cb508046bf87')
def test_get_flavor(self):
"""
vimconnector.flavorlist = {}
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnNotFoundException,self.vim.get_flavor,
+ self.assertRaises(VimConnNotFoundException,self.vim.get_flavor,
'a646eb8a-95bd-4e81-8321-5413ee72b62e')
def test_new_flavor(self):
]
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnNotFoundException, self.vim.delete_image, 'invali3453')
+ self.assertRaises(VimConnNotFoundException, self.vim.delete_image, 'invali3453')
@mock.patch.object(vimconnector,'get_vdc_details')
@mock.patch.object(vimconnector,'connect')
create_vdc.return_value = None
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnException,self.vim.new_tenant,tenant_name)
+ self.assertRaises(VimConnException,self.vim.new_tenant,tenant_name)
@mock.patch.object(vimconnector,'connect_as_admin')
@mock.patch.object(vimconnector,'connect')
perform_request.return_value.status_code = 201
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnNotFoundException,self.vim.delete_tenant,tenant_id)
+ self.assertRaises(VimConnNotFoundException,self.vim.delete_tenant,tenant_id)
@mock.patch.object(vimconnector,'get_vdc_details')
@mock.patch.object(Org,'list_catalogs')
content = "Bad request error")]
# call to VIM connector method
- self.assertRaises(vimconnUnexpectedResponse,self.vim.new_vminstance,
+ self.assertRaises(VimConnUnexpectedResponse,self.vim.new_vminstance,
name='Test1_vm',
image_id=image_id,
flavor_id=flavor_id,
get_catalogid.return_value = '34925a30-0f4a-4018-9759-0d6799063b51'
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnException,self.vim.new_image,{'name':'TestImage', 'location':path})
+ self.assertRaises(VimConnException,self.vim.new_image,{'name':'TestImage', 'location':path})
@mock.patch.object(vimconnector,'connect_as_admin')
@mock.patch.object(vimconnector,'perform_request')
create_catalog.return_value = catalog
upload_vimimage.return_value = False
get_catalogid.return_value = '7208-0f6777052c30'
- self.assertRaises(vimconnException, self.vim.get_image_id_from_path, path)
+ self.assertRaises(VimConnException, self.vim.get_image_id_from_path, path)
@mock.patch.object(vimconnector,'get_vdc_details')
@mock.patch.object(vimconnector,'connect')
get_vapp_details_rest.return_value = False
# assert verified expected and return result from VIM connector
- self.assertRaises(vimconnNotFoundException, self.vim.get_vminstance,invalid_vmid)
+ self.assertRaises(VimConnNotFoundException, self.vim.get_vminstance,invalid_vmid)
@mock.patch.object(vimconnector,'connect')
@mock.patch.object(vimconnector,'get_namebyvappid')
get_vapp.return_value = None
# call to VIM connector method
- self.assertRaises(vimconnException, self.vim.delete_vminstance,vm_id)
+ self.assertRaises(VimConnException, self.vim.delete_vminstance,vm_id)
@mock.patch.object(vimconnector,'get_vcd_network')
def test_refresh_nets_status_negative(self, get_vcd_network):
self.vim.client = self.vim.connect()
# call to VIM connector method
- self.assertRaises(vimconnException, self.vim.action_vminstance, vm_id,{'invalid': None})
+ self.assertRaises(VimConnException, self.vim.action_vminstance, vm_id,{'invalid': None})
"""
from lxml import etree as lxmlElementTree
-from osm_ro import vimconn
+from osm_ro_plugin import vimconn
from progressbar import Percentage, Bar, ETA, FileTransferSpeed, ProgressBar
from pyVim.connect import SmartConnect, Disconnect
from pyVmomi import vim, vmodl # @UnresolvedImport
}
-class vimconnector(vimconn.vimconnector):
+class vimconnector(vimconn.VimConnector):
# dict used to store flavor in memory
flavorlist = {}
Nothing.
"""
- vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url,
+ vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url,
url_admin, user, passwd, log_level, config)
self.logger = logging.getLogger('openmano.vim.vmware')
self.admin_user = config['admin_username']
self.admin_password = config['admin_password']
except KeyError:
- raise vimconn.vimconnException(message="Error admin username or admin password is empty.")
+ raise vimconn.VimConnException(message="Error admin username or admin password is empty.")
try:
self.nsx_manager = config['nsx_manager']
self.nsx_user = config['nsx_user']
self.nsx_password = config['nsx_password']
except KeyError:
- raise vimconn.vimconnException(message="Error: nsx manager or nsx user or nsx password is empty in Config")
+ raise vimconn.VimConnException(message="Error: nsx manager or nsx user or nsx password is empty in Config")
self.vcenter_ip = config.get("vcenter_ip", None)
self.vcenter_port = config.get("vcenter_port", None)
# try:
# self.dvs_name = config['dv_switch_name']
# except KeyError:
-# raise vimconn.vimconnException(message="Error: distributed virtaul switch name is empty in Config")
+# raise vimconn.VimConnException(message="Error: distributed virtaul switch name is empty in Config")
#
# self.vlanID_range = config.get("vlanID_range", None)
self.client = None
if not url:
- raise vimconn.vimconnException('url param can not be NoneType')
+ raise vimconn.VimConnException('url param can not be NoneType')
if not self.url_admin: # try to use normal url
self.url_admin = self.url
client_as_admin = Client(host, verify_ssl_certs=False, api_version=API_VERSION)
client_as_admin.set_credentials(BasicLoginCredentials(self.admin_user, org, self.admin_password))
except Exception as e:
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"Can't connect to vCloud director as: {} with exception {}".format(self.admin_user, e))
return client_as_admin
client = Client(host, verify_ssl_certs=False, api_version=API_VERSION)
client.set_credentials(BasicLoginCredentials(self.user, self.org_name, self.passwd))
except Exception as e:
- raise vimconn.vimconnConnectionException("Can't connect to vCloud director org: "
+ raise vimconn.VimConnConnectionException("Can't connect to vCloud director org: "
"{} as user {} with exception: {}".format(self.org_name,
self.user,
e))
"""
client = self.connect()
if not client:
- raise vimconn.vimconnConnectionException("Failed to connect vCD.")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD.")
self.client = client
try:
self.logger.debug("Setting organization UUID {}".format(self.org_uuid))
break
else:
- raise vimconn.vimconnException("Vcloud director organization {} not found".format(self.org_name))
+ raise vimconn.VimConnException("Vcloud director organization {} not found".format(self.org_name))
# if well good we require for org details
org_details_dict = self.get_org(org_uuid=self.org_uuid)
self.org_name))
break
else:
- raise vimconn.vimconnException("Tenant name indicated but not present in vcloud director.")
+ raise vimconn.VimConnException("Tenant name indicated but not present in vcloud director.")
# case two we have tenant_id but we don't have tenant name so we find and set it.
if self.tenant_id is not None and self.tenant_name is None and 'vdcs' in org_details_dict:
vdcs_dict = org_details_dict['vdcs']
self.org_name))
break
else:
- raise vimconn.vimconnException("Tenant id indicated but not present in vcloud director")
+ raise vimconn.VimConnException("Tenant id indicated but not present in vcloud director")
self.logger.debug("Setting organization uuid {}".format(self.org_uuid))
except Exception as e:
self.logger.debug("Failed initialize organization UUID for org {}: {}".format(self.org_name), e)
Return:
returns the tenant identifier in UUID format.
- If action is failed method will throw vimconn.vimconnException method
+ If action is failed method will throw vimconn.VimConnException method
"""
vdc_task = self.create_vdc(vdc_name=tenant_name)
if vdc_task is not None:
self.logger.info("Created new vdc {} and uuid: {}".format(tenant_name, vdc_uuid))
return vdc_uuid
else:
- raise vimconn.vimconnException("Failed create tenant {}".format(tenant_name))
+ raise vimconn.VimConnException("Failed create tenant {}".format(tenant_name))
def delete_tenant(self, tenant_id=None):
""" Delete a tenant from VIM
"""
vca = self.connect_as_admin()
if not vca:
- raise vimconn.vimconnConnectionException("Failed to connect vCD")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD")
if tenant_id is not None:
if vca._session:
self.logger.debug("delete_tenant():GET REST API call {} failed. "
"Return status code {}".format(orgvdc_herf,
response.status_code))
- raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
+ raise vimconn.VimConnNotFoundException("Fail to get tenant {}".format(tenant_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
self.logger.debug("delete_tenant(): DELETE REST API call {} failed. "
"Return status code {}".format(vdc_remove_href,
response.status_code))
- raise vimconn.vimconnException("Fail to delete tenant with ID {}".format(tenant_id))
+ raise vimconn.VimConnException("Fail to delete tenant with ID {}".format(tenant_id))
else:
self.logger.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id))
- raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
+ raise vimconn.VimConnNotFoundException("Fail to get tenant {}".format(tenant_id))
def get_tenant_list(self, filter_dict={}):
"""Obtain tenants of VIM
except Exception:
self.logger.debug("Error in get_tenant_list()")
self.logger.debug(traceback.format_exc())
- raise vimconn.vimconnException("Incorrect state. {}")
+ raise vimconn.VimConnException("Incorrect state. {}")
return vdclist
# ############# Stub code for SRIOV #################
# if net_type == "data" or net_type == "ptp":
# if self.config.get('dv_switch_name') == None:
-# raise vimconn.vimconnConflictException("You must provide 'dv_switch_name' at config value")
+# raise vimconn.VimConnConflictException("You must provide 'dv_switch_name' at config value")
# network_uuid = self.create_dvPort_group(net_name)
parent_network_uuid = None
if network_uuid is not None:
return network_uuid, created_items
else:
- raise vimconn.vimconnUnexpectedResponse("Failed create a new network {}".format(net_name))
+ raise vimconn.VimConnUnexpectedResponse("Failed create a new network {}".format(net_name))
def get_vcd_network_list(self):
""" Method available organization for a logged in tenant
self.logger.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self.tenant_name))
if not self.tenant_name:
- raise vimconn.vimconnConnectionException("Tenant name is empty.")
+ raise vimconn.VimConnConnectionException("Tenant name is empty.")
_, vdc = self.get_vdc_details()
if vdc is None:
- raise vimconn.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self.tenant_name))
+ raise vimconn.VimConnConnectionException("Can't retrieve information for a VDC {}".format(self.tenant_name))
vdc_uuid = vdc.get('id').split(":")[3]
if self.client._session:
headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
- raise vimconn.vimconnNotFoundException("Failed to get vdc content")
+ raise vimconn.VimConnNotFoundException("Failed to get vdc content")
else:
content = XmlElementTree.fromstring(response.text)
if response.status_code != 200:
self.logger.error("Failed to get network content")
- raise vimconn.vimconnNotFoundException("Failed to get network content")
+ raise vimconn.VimConnNotFoundException("Failed to get network content")
else:
net_details = XmlElementTree.fromstring(response.text)
self.logger.debug("get_network_list(): retrieving network list for vcd {}".format(self.tenant_name))
if not self.tenant_name:
- raise vimconn.vimconnConnectionException("Tenant name is empty.")
+ raise vimconn.VimConnConnectionException("Tenant name is empty.")
_, vdc = self.get_vdc_details()
if vdc is None:
- raise vimconn.vimconnConnectionException(
+ raise vimconn.VimConnConnectionException(
"Can't retrieve information for a VDC {}.".format(self.tenant_name))
try:
headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
- raise vimconn.vimconnNotFoundException("Failed to get vdc content")
+ raise vimconn.VimConnNotFoundException("Failed to get vdc content")
else:
content = XmlElementTree.fromstring(response.text)
if response.status_code != 200:
self.logger.error("Failed to get network content")
- raise vimconn.vimconnNotFoundException("Failed to get network content")
+ raise vimconn.VimConnNotFoundException("Failed to get network content")
else:
net_details = XmlElementTree.fromstring(response.text)
network_list.append(filtered_entry)
except Exception as e:
self.logger.debug("Error in get_network_list", exc_info=True)
- if isinstance(e, vimconn.vimconnException):
+ if isinstance(e, vimconn.VimConnException):
raise
else:
- raise vimconn.vimconnNotFoundException("Failed : Networks list not found {} ".format(e))
+ raise vimconn.VimConnNotFoundException("Failed : Networks list not found {} ".format(e))
self.logger.debug("Returning {}".format(network_list))
return network_list
headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
- raise vimconn.vimconnNotFoundException("Failed to get vdc content")
+ raise vimconn.VimConnNotFoundException("Failed to get vdc content")
else:
content = XmlElementTree.fromstring(response.text)
if response.status_code != 200:
self.logger.error("Failed to get network content")
- raise vimconn.vimconnNotFoundException("Failed to get network content")
+ raise vimconn.VimConnNotFoundException("Failed to get network content")
else:
net_details = XmlElementTree.fromstring(response.text)
self.logger.debug("Returning {}".format(filter_dict))
return filter_dict
else:
- raise vimconn.vimconnNotFoundException("Network {} not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("Network {} not found".format(net_id))
except Exception as e:
self.logger.debug("Error in get_network")
self.logger.debug(traceback.format_exc())
- if isinstance(e, vimconn.vimconnException):
+ if isinstance(e, vimconn.VimConnException):
raise
else:
- raise vimconn.vimconnNotFoundException("Failed : Network not found {} ".format(e))
+ raise vimconn.VimConnNotFoundException("Failed : Network not found {} ".format(e))
return filter_dict
if self.delete_network_action(network_uuid=net_id):
return net_id
else:
- raise vimconn.vimconnNotFoundException("Network {} not found".format(net_id))
+ raise vimconn.VimConnNotFoundException("Network {} not found".format(net_id))
def refresh_nets_status(self, net_list):
"""Get the status of the networks
Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
"""
if flavor_id not in vimconnector.flavorlist:
- raise vimconn.vimconnNotFoundException("Flavor not found.")
+ raise vimconn.VimConnNotFoundException("Flavor not found.")
return vimconnector.flavorlist[flavor_id]
def new_flavor(self, flavor_data):
disk = flavor_data.get(FLAVOR_DISK_KEY, 0)
if not isinstance(ram, int):
- raise vimconn.vimconnException("Non-integer value for ram")
+ raise vimconn.VimConnException("Non-integer value for ram")
elif not isinstance(cpu, int):
- raise vimconn.vimconnException("Non-integer value for cpu")
+ raise vimconn.VimConnException("Non-integer value for cpu")
elif not isinstance(disk, int):
- raise vimconn.vimconnException("Non-integer value for disk")
+ raise vimconn.VimConnException("Non-integer value for disk")
extended_flv = flavor_data.get("extended")
if extended_flv:
Returns the used id or raise an exception
"""
if flavor_id not in vimconnector.flavorlist:
- raise vimconn.vimconnNotFoundException("Flavor not found.")
+ raise vimconn.VimConnNotFoundException("Flavor not found.")
vimconnector.flavorlist.pop(flavor_id, None)
return flavor_id
"""
conn = self.connect_as_admin()
if not conn:
- raise vimconn.vimconnConnectionException("Failed to connect vCD")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD")
# Get Catalog details
url_list = [self.url, '/api/catalog/', image_id]
catalog_herf = ''.join(url_list)
self.logger.debug("delete_image():GET REST API call {} failed. "
"Return status code {}".format(catalog_herf,
response.status_code))
- raise vimconn.vimconnNotFoundException("Fail to get image {}".format(image_id))
+ raise vimconn.VimConnNotFoundException("Fail to get image {}".format(image_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
self.logger.debug("delete_image():GET REST API call {} failed. "
"Return status code {}".format(catalog_herf,
response.status_code))
- raise vimconn.vimconnNotFoundException("Fail to get catalogItem {} for catalog {}".format(
+ raise vimconn.VimConnNotFoundException("Fail to get catalogItem {} for catalog {}".format(
catalogItem,
image_id))
if response.status_code == requests.codes.no_content:
self.logger.debug("Deleted Catalog item {}".format(catalogItem))
else:
- raise vimconn.vimconnException("Fail to delete Catalog Item {}".format(catalogItem))
+ raise vimconn.VimConnException("Fail to delete Catalog Item {}".format(catalogItem))
# Remove catalog
url_list = [self.url, '/api/admin/catalog/', image_id]
self.logger.debug("Deleted Catalog {}".format(image_id))
return image_id
else:
- raise vimconn.vimconnException("Fail to delete Catalog {}".format(image_id))
+ raise vimconn.VimConnException("Fail to delete Catalog {}".format(image_id))
def catalog_exists(self, catalog_name, catalogs):
"""
except Exception as exp:
self.logger.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
.format(catalog_name, media_file_name, exp))
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
.format(catalog_name, media_file_name, exp))
"""
if not path:
- raise vimconn.vimconnException("Image path can't be None.")
+ raise vimconn.VimConnException("Image path can't be None.")
if not os.path.isfile(path):
- raise vimconn.vimconnException("Can't read file. File not found.")
+ raise vimconn.VimConnException("Can't read file. File not found.")
if not os.access(path, os.R_OK):
- raise vimconn.vimconnException("Can't read file. Check file permission to read.")
+ raise vimconn.VimConnException("Can't read file. Check file permission to read.")
self.logger.debug("get_image_id_from_path() client requesting {} ".format(path))
_, file_extension = os.path.splitext(path)
if file_extension != '.ovf':
self.logger.debug("Wrong file extension {} connector support only OVF container.".format(file_extension))
- raise vimconn.vimconnException("Wrong container. vCloud director supports only OVF.")
+ raise vimconn.VimConnException("Wrong container. vCloud director supports only OVF.")
catalog_name = os.path.splitext(filename)[0]
catalog_md5_name = hashlib.md5(path.encode('utf-8')).hexdigest()
catalogs = org.list_catalogs()
except Exception as exp:
self.logger.debug("Failed get catalogs() with Exception {} ".format(exp))
- raise vimconn.vimconnException("Failed get catalogs() with Exception {} ".format(exp))
+ raise vimconn.VimConnException("Failed get catalogs() with Exception {} ".format(exp))
if len(catalogs) == 0:
self.logger.info("Creating a new catalog entry {} in vcloud director".format(catalog_name))
if self.create_vimcatalog(org, catalog_md5_name) is None:
- raise vimconn.vimconnException("Failed create new catalog {} ".format(catalog_md5_name))
+ raise vimconn.VimConnException("Failed create new catalog {} ".format(catalog_md5_name))
result = self.upload_vimimage(vca=org, catalog_name=catalog_md5_name,
media_name=filename, medial_file_name=path, progress=progress)
if not result:
- raise vimconn.vimconnException("Failed create vApp template for catalog {} ".format(catalog_name))
+ raise vimconn.VimConnException("Failed create vApp template for catalog {} ".format(catalog_name))
return self.get_catalogid(catalog_name, catalogs)
else:
for catalog in catalogs:
# if we didn't find existing catalog we create a new one and upload image.
self.logger.debug("Creating new catalog entry {} - {}".format(catalog_name, catalog_md5_name))
if self.create_vimcatalog(org, catalog_md5_name) is None:
- raise vimconn.vimconnException("Failed create new catalog {} ".format(catalog_md5_name))
+ raise vimconn.VimConnException("Failed create new catalog {} ".format(catalog_md5_name))
result = self.upload_vimimage(vca=org, catalog_name=catalog_md5_name,
media_name=filename, medial_file_name=path, progress=progress)
if not result:
- raise vimconn.vimconnException("Failed create vApp template for catalog {} ".format(catalog_md5_name))
+ raise vimconn.VimConnException("Failed create vApp template for catalog {} ".format(catalog_md5_name))
return self.get_catalogid(catalog_md5_name, org.list_catalogs())
self.logger.debug("List of already created catalog items: {}".format(image_list))
return image_list
except Exception as exp:
- raise vimconn.vimconnException("Exception occured while retriving catalog items {}".format(exp))
+ raise vimconn.VimConnException("Exception occured while retriving catalog items {}".format(exp))
def get_vappid(self, vdc=None, vapp_name=None):
""" Method takes vdc object and vApp name and returns vapp uuid or None
for net in net_list:
if net['type'] == "PCI-PASSTHROUGH":
- raise vimconn.vimconnNotSupportedException(
+ raise vimconn.VimConnNotSupportedException(
"Current vCD version does not support type : {}".format(net['type']))
if len(net_list) > 10:
- raise vimconn.vimconnNotSupportedException(
+ raise vimconn.VimConnNotSupportedException(
"The VM hardware versions 7 and above support upto 10 NICs only")
# if vm already deployed we return existing uuid
# we check for presence of VDC, Catalog entry and Flavor.
org, vdc = self.get_vdc_details()
if vdc is None:
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name))
catalogs = org.list_catalogs()
if catalogs is None:
org = Org(self.client, resource=self.client.get_org())
catalogs = org.list_catalogs()
if catalogs is None:
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"new_vminstance(): Failed create vApp {}: (Failed retrieve catalogs list)".format(name))
catalog_hash_name = self.get_catalogbyid(catalog_uuid=image_id, catalogs=catalogs)
if catalog_hash_name:
self.logger.info("Found catalog entry {} for image id {}".format(catalog_hash_name, image_id))
else:
- raise vimconn.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
+ raise vimconn.VimConnNotFoundException("new_vminstance(): Failed create vApp {}: "
"(Failed retrieve catalog information {})".format(name, image_id))
# Set vCPU and Memory based on flavor.
if flavor_id is not None:
if flavor_id not in vimconnector.flavorlist:
- raise vimconn.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
+ raise vimconn.VimConnNotFoundException("new_vminstance(): Failed create vApp {}: "
"Failed retrieve flavor information "
"flavor id {}".format(name, flavor_id))
else:
numas = extended.get("numas", None)
except Exception as exp:
- raise vimconn.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id, exp))
+ raise vimconn.VimConnException("Corrupted flavor. {}.Exception: {}".format(flavor_id, exp))
# image upload creates template name as catalog name space Template.
templateName = self.get_catalogbyid(catalog_uuid=image_id, catalogs=catalogs)
primary_netname = network_dict['name']
except KeyError:
- raise vimconn.vimconnException("Corrupted flavor. {}".format(primary_net))
+ raise vimconn.VimConnException("Corrupted flavor. {}".format(primary_net))
else:
- raise vimconn.vimconnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name))
+ raise vimconn.VimConnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name))
# use: 'data', 'bridge', 'mgmt'
# create vApp. Set vcpu and ram based on flavor id.
try:
vdc_obj = VDC(self.client, resource=org.get_vdc(self.tenant_name))
if not vdc_obj:
- raise vimconn.vimconnNotFoundException("new_vminstance(): Failed to get VDC object")
+ raise vimconn.VimConnNotFoundException("new_vminstance(): Failed to get VDC object")
for retry in (1, 2):
items = org.get_catalog_item(catalog_hash_name, catalog_hash_name)
"status code : {}".format(instantiate_vapp_href,
response.text,
response.status_code))
- raise vimconn.vimconnException("new_vminstance(): Failed to create"
+ raise vimconn.VimConnException("new_vminstance(): Failed to create"
"vAapp {}".format(vmname_andid))
else:
vapptask = self.get_task_from_response(response.text)
break
if vapptask is None or vapptask is False:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"new_vminstance(): failed to create vApp {}".format(vmname_andid))
# wait for task to complete
if result.get('status') == 'success':
self.logger.debug("new_vminstance(): Sucessfully created Vapp {}".format(vmname_andid))
else:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"new_vminstance(): failed to create vApp {}".format(vmname_andid))
except Exception as exp:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"new_vminstance(): failed to create vApp {} with Exception:{}".format(vmname_andid, exp))
# we should have now vapp in undeployed state.
vapp = VApp(self.client, resource=vapp_resource)
except Exception as exp:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
.format(vmname_andid, exp))
if vapp_uuid is None:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"new_vminstance(): Failed to retrieve vApp {} after creation".format(vmname_andid))
# Add PCI passthrough/SRIOV configrations
# it might be a case if specific mandatory entry in dict is empty or some other pyVcloud exception
self.logger.error("new_vminstance(): Failed create new vm instance {} with exception {}"
.format(name, exp))
- raise vimconn.vimconnException("new_vminstance(): Failed create new vm instance {} with exception {}"
+ raise vimconn.VimConnException("new_vminstance(): Failed create new vm instance {} with exception {}"
.format(name, exp))
# check if vApp deployed and if that the case return vApp UUID otherwise -1
wait_time = 0
vapp_resource = vdc_obj.get_vapp(vmname_andid)
vapp = VApp(self.client, resource=vapp_resource)
except Exception as exp:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
.format(vmname_andid, exp))
# Admin access required for creating Affinity rules
client = self.connect_as_admin()
if not client:
- raise vimconn.vimconnConnectionException("Failed to connect vCD as admin")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD as admin")
else:
self.client = client
if self.client:
if vapp_uuid is not None:
return vapp_uuid, None
else:
- raise vimconn.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name))
+ raise vimconn.VimConnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name))
def create_config_drive_iso(self, user_data):
tmpdir = tempfile.mkdtemp()
else:
return availability_zone_list[availability_zone_index]
else:
- raise vimconn.vimconnConflictException("No enough availability zones at VIM for this deployment")
+ raise vimconn.VimConnConflictException("No enough availability zones at VIM for this deployment")
def create_vm_to_host_affinity_rule(self, addrule_href, vmgrpname, hostgrpname, polarity, headers):
""" Method to create VM to Host Affinity rule in vCD
affinity_task = self.get_task_from_response(resp.content)
self.logger.debug("affinity_task: {}".format(affinity_task))
if affinity_task is None or affinity_task is False:
- raise vimconn.vimconnUnexpectedResponse("failed to find affinity task")
+ raise vimconn.VimConnUnexpectedResponse("failed to find affinity task")
# wait for task to complete
result = self.client.get_task_monitor().wait_for_success(task=affinity_task)
if result.get('status') == 'success':
self.logger.debug("Successfully created affinity rule {}".format(rule_name))
return True
else:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"failed to create affinity rule {}".format(rule_name))
def get_add_rule_reference(self, respool_href, headers):
else:
vmgroup_task = self.get_task_from_response(resp.content)
if vmgroup_task is None or vmgroup_task is False:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"create_vmgroup(): failed to create VM group {}".format(vmgroup_name))
# wait for task to complete
vmgroup_status = True
return vmgroup_status
else:
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"create_vmgroup(): failed to create VM group {}".format(vmgroup_name))
def find_vmgroup_reference(self, url, headers):
# Get vdcReferences to find org
pvdc_resp = self.perform_request(req_type='GET', url=pvdc_href, headers=headers)
if pvdc_resp.status_code != requests.codes.ok:
- raise vimconn.vimconnException("REST API call {} failed. "
+ raise vimconn.VimConnException("REST API call {} failed. "
"Return status code {}"
.format(url, pvdc_resp.status_code))
url=vdc_href,
headers=headers)
if vdc_resp.status_code != requests.codes.ok:
- raise vimconn.vimconnException("REST API call {} failed. "
+ raise vimconn.VimConnException("REST API call {} failed. "
"Return status code {}"
.format(url, vdc_resp.status_code))
vdc_resp_xml = XmlElementTree.fromstring(vdc_resp.content)
# get token to connect vCD as a normal user
self.get_token()
self.logger.debug(msg)
- raise vimconn.vimconnException(msg)
+ raise vimconn.VimConnException(msg)
# #
# #
_, vdc = self.get_vdc_details()
if vdc is None:
- raise vimconn.vimconnConnectionException(
+ raise vimconn.VimConnConnectionException(
"Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
vm_info_dict = self.get_vapp_details_rest(vapp_uuid=vim_vm_uuid)
if not vm_info_dict:
self.logger.debug("get_vminstance(): Failed to get vApp name by UUID {}".format(vim_vm_uuid))
- raise vimconn.vimconnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid))
+ raise vimconn.VimConnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid))
status_key = vm_info_dict['status']
error = ''
if vdc_obj is None:
self.logger.debug("delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(
self.tenant_name))
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
try:
return vm__vim_uuid
except Exception:
self.logger.debug(traceback.format_exc())
- raise vimconn.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid))
+ raise vimconn.VimConnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid))
def refresh_vms_status(self, vm_list):
"""Get the status of the virtual machines and their interfaces/ports
_, vdc = self.get_vdc_details()
if vdc is None:
- raise vimconn.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
+ raise vimconn.VimConnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
vms_dict = {}
nsx_edge_list = []
"status code : {}".format(vm.get('href'),
response.text,
response.status_code))
- raise vimconn.vimconnException("refresh_vms_status : Failed to get VM details")
+ raise vimconn.VimConnException("refresh_vms_status : Failed to get VM details")
xmlroot = XmlElementTree.fromstring(response.text)
result = response.text.replace("\n", " ")
if not nsx_edge_list:
nsx_edge_list = self.get_edge_details()
if nsx_edge_list is None:
- raise vimconn.vimconnException("refresh_vms_status:"
+ raise vimconn.VimConnException("refresh_vms_status:"
"Failed to get edge details from NSX Manager")
if vm_mac is not None:
vm_ip = self.get_ipaddr_from_NSXedge(nsx_edge_list, vm_mac)
if edge_summary.tag == 'pagingInfo':
for element in edge_summary:
if element.tag == 'totalCount' and element.text == '0':
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"get_edge_details: No NSX edges details found: {}"
.format(self.nsx_manager))
if element.tag == 'id':
edge_list.append(element.text)
else:
- raise vimconn.vimconnException("get_edge_details: No NSX edge details found: {}"
+ raise vimconn.VimConnException("get_edge_details: No NSX edge details found: {}"
.format(self.nsx_manager))
if not edge_list:
- raise vimconn.vimconnException("get_edge_details: "
+ raise vimconn.VimConnException("get_edge_details: "
"No NSX edge details found: {}"
.format(self.nsx_manager))
else:
self.logger.debug("get_edge_details: "
"Failed to get NSX edge details from NSX Manager: {}"
.format(exp))
- raise vimconn.vimconnException("get_edge_details: "
+ raise vimconn.VimConnException("get_edge_details: "
"Failed to get NSX edge details from NSX Manager: {}"
.format(exp))
self.logger.debug("Received action for vm {} and action dict {}".format(vm__vim_uuid, action_dict))
if vm__vim_uuid is None or action_dict is None:
- raise vimconn.vimconnException("Invalid request. VM id or action is None.")
+ raise vimconn.VimConnException("Invalid request. VM id or action is None.")
_, vdc = self.get_vdc_details()
if vdc is None:
- raise vimconn.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
+ raise vimconn.VimConnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
vapp_name = self.get_namebyvappid(vm__vim_uuid)
if vapp_name is None:
self.logger.debug("action_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid))
- raise vimconn.vimconnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid))
+ raise vimconn.VimConnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid))
else:
self.logger.info("Action_vminstance vApp {} and UUID {}".format(vapp_name, vm__vim_uuid))
reboot_task = vapp.reboot()
self.client.get_task_monitor().wait_for_success(task=reboot_task)
else:
- raise vimconn.vimconnException(
+ raise vimconn.VimConnException(
"action_vminstance: Invalid action {} or action is None.".format(action_dict))
return vm__vim_uuid
except Exception as exp:
self.logger.debug("action_vminstance: Failed with Exception {}".format(exp))
- raise vimconn.vimconnException("action_vminstance: Failed with Exception {}".format(exp))
+ raise vimconn.VimConnException("action_vminstance: Failed with Exception {}".format(exp))
def instance_actions_result(self, action, result, vapp_name):
if result.get('status') == 'success':
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("get_vminstance_console : Failed to get "
+ raise vimconn.VimConnException("get_vminstance_console : Failed to get "
"VM Mks ticket details")
s = re.search("<Host>(.*?)</Host>", response.text)
console_dict['server'] = s.group(1) if s else None
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("get_vminstance_console : Failed to get "
+ raise vimconn.VimConnException("get_vminstance_console : Failed to get "
"VM console details")
s = re.search(">.*?/(vm-\d+.*)</", response.text)
console_dict['suffix'] = s.group(1) if s else None
"""Transform host dictionary from VIM format to GUI format,
and append to the server_dict
"""
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def get_hosts_info(self):
"""Get the information of deployed hosts
Returns the hosts content"""
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def get_hosts(self, vim_tenant):
"""Get the hosts and deployed instances
Returns the hosts content"""
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def get_processor_rankings(self):
"""Get the processor rankings in the VIM database"""
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def new_host(self, host_data):
"""Adds a new host to VIM"""
'''Returns status code of the VIM response'''
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def new_external_port(self, port_data):
"""Adds a external port to VIM"""
'''Returns the port identifier'''
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def new_external_network(self, net_name, net_type):
"""Adds a external network to VIM (shared)"""
'''Returns the network identifier'''
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def connect_port_network(self, port_id, network_id, admin=False):
"""Connects a external port to a network"""
'''Returns status code of the VIM response'''
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def new_vminstancefromJSON(self, vm_data):
"""Adds a VM instance to VIM"""
'''Returns the instance identifier'''
- raise vimconn.vimconnNotImplemented("Should have implemented this")
+ raise vimconn.VimConnNotImplemented("Should have implemented this")
def get_network_name_by_id(self, network_uuid=None):
"""Method gets vcloud director network named based on supplied uuid.
try:
client_as_admin = self.connect_as_admin()
if not client_as_admin:
- raise vimconn.vimconnConnectionException("Failed to connect vCD.")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD.")
url_list = [self.url, '/api/admin/vdc/', self.tenant_id]
vm_list_rest_call = ''.join(url_list)
vm_dict = {}
vca = self.connect()
if not vca:
- raise vimconn.vimconnConnectionException("self.connect() is failed")
+ raise vimconn.VimConnConnectionException("self.connect() is failed")
if vdc_name is None:
return vm_dict
network_configuration[tagKey] = configuration.text.strip()
except Exception as exp:
self.logger.debug("get_vcd_network: Failed with Exception {}".format(exp))
- raise vimconn.vimconnException("get_vcd_network: Failed with Exception {}".format(exp))
+ raise vimconn.VimConnException("get_vcd_network: Failed with Exception {}".format(exp))
return network_configuration
"""
client = self.connect_as_admin()
if not client:
- raise vimconn.vimconnConnectionException("Failed to connect vCD as admin")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD as admin")
if network_uuid is None:
return False
"""
client_as_admin = self.connect_as_admin()
if not client_as_admin:
- raise vimconn.vimconnConnectionException("Failed to connect vCD.")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD.")
if network_name is None:
return None
dns_address = ip_profile['dns_address']
except KeyError as exp:
self.logger.debug("Create Network REST: Key error {}".format(exp))
- raise vimconn.vimconnException("Create Network REST: Key error{}".format(exp))
+ raise vimconn.VimConnException("Create Network REST: Key error{}".format(exp))
# either use client provided UUID or search for a first available
# if both are not defined we return none
self.logger.info("Creating new vdc {}".format(vdc_name))
vca = self.connect_as_admin()
if not vca:
- raise vimconn.vimconnConnectionException("Failed to connect vCD")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD")
if vdc_name is None:
return None
vca = self.connect_as_admin()
if not vca:
- raise vimconn.vimconnConnectionException("Failed to connect vCD")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD")
if vdc_name is None:
return None
vca = self.client
if not vca:
- raise vimconn.vimconnConnectionException("Failed to connect vCD")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD")
if vapp_uuid is None:
return None
host_obj = new_host_obj
else:
self.logger.info("Fail to migrate VM : {}".format(result))
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Fail to migrate VM : {} to host {}".format(
vmname_andid,
new_host_obj)
no_of_pci_devices,
vmname_andid)
)
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Currently there is no host with {} "
"number of avaialble PCI devices required for VM {}".format(
no_of_pci_devices,
if self.vcenter_ip is not None:
vm_vcenter_info["vm_vcenter_ip"] = self.vcenter_ip
else:
- raise vimconn.vimconnException(message="vCenter IP is not provided."
+ raise vimconn.VimConnException(message="vCenter IP is not provided."
" Please provide vCenter IP while attaching datacenter "
"to tenant in --config")
if self.vcenter_port is not None:
vm_vcenter_info["vm_vcenter_port"] = self.vcenter_port
else:
- raise vimconn.vimconnException(message="vCenter port is not provided."
+ raise vimconn.VimConnException(message="vCenter port is not provided."
" Please provide vCenter port while attaching datacenter "
"to tenant in --config")
if self.vcenter_user is not None:
vm_vcenter_info["vm_vcenter_user"] = self.vcenter_user
else:
- raise vimconn.vimconnException(message="vCenter user is not provided."
+ raise vimconn.VimConnException(message="vCenter user is not provided."
" Please provide vCenter user while attaching datacenter "
"to tenant in --config")
if self.vcenter_password is not None:
vm_vcenter_info["vm_vcenter_password"] = self.vcenter_password
else:
- raise vimconn.vimconnException(message="vCenter user password is not provided."
+ raise vimconn.VimConnException(message="vCenter user password is not provided."
" Please provide vCenter user password while attaching datacenter "
"to tenant in --config")
except Exception as exp:
self.logger.error("Error occurred while getting VM information"
" for VM : {}".format(exp))
- raise vimconn.vimconnException(message=exp)
+ raise vimconn.VimConnException(message=exp)
def reserve_memory_for_all_vms(self, vapp, memory_mb):
"""
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("reserve_memory_for_all_vms : Failed to get "
+ raise vimconn.VimConnException("reserve_memory_for_all_vms : Failed to get "
"memory")
bytexml = bytes(bytearray(response.text, encoding='utf-8'))
"status code : {} ".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("reserve_memory_for_all_vms : Failed to update "
+ raise vimconn.VimConnException("reserve_memory_for_all_vms : Failed to update "
"virtual hardware memory section")
else:
mem_task = self.get_task_from_response(response.text)
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to get "
+ raise vimconn.VimConnException("connect_vapp_to_org_vdc_network : Failed to get "
"network config section")
data = response.text
headers['Content-Type'] = 'application/vnd.vmware.vcloud.networkConfigSection+xml'
net_id = self.get_network_id_by_name(net_name)
if not net_id:
- raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to find "
+ raise vimconn.VimConnException("connect_vapp_to_org_vdc_network : Failed to find "
"existing network")
bytexml = bytes(bytearray(data, encoding='utf-8'))
"status code : {} ".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to update "
+ raise vimconn.VimConnException("connect_vapp_to_org_vdc_network : Failed to update "
"network config section")
else:
vapp_task = self.get_task_from_response(response.text)
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("remove_primary_network_adapter : Failed to get "
+ raise vimconn.VimConnException("remove_primary_network_adapter : Failed to get "
"network connection section")
data = response.text
"status code : {} ".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("remove_primary_network_adapter : Failed to update "
+ raise vimconn.VimConnException("remove_primary_network_adapter : Failed to update "
"network connection section")
else:
nic_task = self.get_task_from_response(response.text)
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to get "
+ raise vimconn.VimConnException("add_network_adapter_to_vms : Failed to get "
"network connection section")
data = response.text
"status code : {} ".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to update "
+ raise vimconn.VimConnException("add_network_adapter_to_vms : Failed to update "
"network connection section")
else:
nic_task = self.get_task_from_response(response.text)
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to get "
+ raise vimconn.VimConnException("add_network_adapter_to_vms : Failed to get "
"network connection section")
data = response.text
data = data.split('<Link rel="edit"')[0]
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to update "
+ raise vimconn.VimConnException("add_network_adapter_to_vms : Failed to update "
"network connection section")
else:
nic_task = self.get_task_from_response(response.text)
except Exception as exp:
self.logger.error("add_network_adapter_to_vms() : exception occurred "
"while adding Network adapter")
- raise vimconn.vimconnException(message=exp)
+ raise vimconn.VimConnException(message=exp)
def set_numa_affinity(self, vmuuid, paired_threads_id):
"""
except Exception as exp:
self.logger.error("set_numa_affinity : exception occurred while setting numa affinity "
"for VM {} : {}".format(vm_obj, vm_moref_id))
- raise vimconn.vimconnException("set_numa_affinity : Error {} failed to assign numa "
+ raise vimconn.VimConnException("set_numa_affinity : Error {} failed to assign numa "
"affinity".format(exp))
def cloud_init(self, vapp, cloud_config):
except Exception as exp:
self.logger.error("cloud_init : exception occurred while injecting "
"ssh-key")
- raise vimconn.vimconnException("cloud_init : Error {} failed to inject "
+ raise vimconn.VimConnException("cloud_init : Error {} failed to inject "
"ssh-key".format(exp))
def format_script(self, key_pairs=[], users_list=[]):
else:
self.logger.error("guest_customization : task for customized guest os"
"failed for VM {}".format(vm_name))
- raise vimconn.vimconnException("guest_customization : failed to perform"
+ raise vimconn.VimConnException("guest_customization : failed to perform"
"guest os customization on VM {}".format(vm_name))
def add_new_disk(self, vapp_uuid, disk_size):
except Exception as exp:
self.logger.error("Error occurred while getting vCenter infromationn"
" for VM : {}".format(exp))
- raise vimconn.vimconnException(message=exp)
+ raise vimconn.VimConnException(message=exp)
context = None
if hasattr(ssl, '_create_unverified_context'):
vca = self.connect_as_admin()
if not vca:
- raise vimconn.vimconnConnectionException("Failed to connect vCD")
+ raise vimconn.VimConnConnectionException("Failed to connect vCD")
try:
org, _ = self.get_vdc_details()
msg = "No vApp ID"
self.logger.error(msg)
if exp_type == "Genric":
- raise vimconn.vimconnException(msg)
+ raise vimconn.VimConnException(msg)
elif exp_type == "NotFound":
- raise vimconn.vimconnNotFoundException(message=msg)
+ raise vimconn.VimConnNotFoundException(message=msg)
def add_sriov(self, vapp_uuid, sriov_nets, vmname_andid):
"""
host_obj = new_host_obj
else:
self.logger.info("Fail to migrate VM : {}".format(result))
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Fail to migrate VM : {} to host {}".format(
vmname_andid,
new_host_obj)
self.logger.error("Fail to add SRIOV {} to VM {}".format(
no_of_sriov_devices,
str(vm_obj)))
- raise vimconn.vimconnUnexpectedResponse(
+ raise vimconn.VimConnUnexpectedResponse(
"Fail to add SRIOV adapter in VM ".format(str(vm_obj))
)
return True, vm_obj, vcenter_conect
no_of_sriov_devices,
vmname_andid)
)
- raise vimconn.vimconnNotFoundException(
+ raise vimconn.VimConnNotFoundException(
"Currently there is no host with {} "
"number of avaialble SRIOV devices required for VM {}".format(
no_of_sriov_devices,
vlan_id = None
used_ids = []
if self.config.get('vlanID_range') is None:
- raise vimconn.vimconnConflictException("You must provide a 'vlanID_range' "
+ raise vimconn.VimConnConflictException("You must provide a 'vlanID_range' "
"at config value before creating sriov network with vlan tag")
if "used_vlanIDs" not in self.persistent_info:
self.persistent_info["used_vlanIDs"] = {}
for vlanID_range in self.config.get('vlanID_range'):
start_vlanid, end_vlanid = vlanID_range.split("-")
if start_vlanid > end_vlanid:
- raise vimconn.vimconnConflictException("Invalid vlan ID range {}".format(
+ raise vimconn.VimConnConflictException("Invalid vlan ID range {}".format(
vlanID_range))
for vid in range(int(start_vlanid), int(end_vlanid) + 1):
self.persistent_info["used_vlanIDs"][network_name] = vlan_id
return vlan_id
if vlan_id is None:
- raise vimconn.vimconnConflictException("All Vlan IDs are in use")
+ raise vimconn.VimConnConflictException("All Vlan IDs are in use")
def get_obj(self, content, vimtype, name):
"""
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("insert_media_to_vm(): Failed to get "
+ raise vimconn.VimConnException("insert_media_to_vm(): Failed to get "
"catalog details")
# searching iso name and id
iso_name, media_id = self.get_media_details(vca, response.text)
error_msg = ("insert_media_to_vm() : Failed to insert CD-ROM to vm. Reason {}. "
"Status code {}".format(response.text, response.status_code))
self.logger.error(error_msg)
- raise vimconn.vimconnException(error_msg)
+ raise vimconn.VimConnException(error_msg)
else:
task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=task)
except Exception as exp:
self.logger.error("insert_media_to_vm() : exception occurred "
"while inserting media CD-ROM")
- raise vimconn.vimconnException(message=exp)
+ raise vimconn.VimConnException(message=exp)
def get_media_details(self, vca, content):
"""
"status code : {}".format(href,
response.text,
response.status_code))
- raise vimconn.vimconnException("get_media_details : Failed to get "
+ raise vimconn.VimConnException("get_media_details : Failed to get "
"catalogitem details")
list_xmlroot = XmlElementTree.fromstring(response.text)
for child in list_xmlroot.iter():
except Exception as exp:
self.logger.error("get_media_details : exception occurred "
"getting media details")
- raise vimconn.vimconnException(message=exp)
+ raise vimconn.VimConnException(message=exp)
def retry_rest(self, method, url, add_headers=None, data=None):
""" Method to get Token & retry respective REST request
"status code : {} ".format(poweron_href,
response.text,
response.status_code))
- raise vimconn.vimconnException("power_on_vapp() : Failed to power on "
+ raise vimconn.VimConnException("power_on_vapp() : Failed to power on "
"vApp {}".format(vapp_name))
else:
poweron_task = self.get_task_from_response(response.text)
progressbar
prettytable
# TODO py3 genisoimage
-git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO
+git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin
# version=VERSION,
# python_requires='>3.5.0',
author='ETSI OSM',
- # TODO py3 author_email='',
- maintainer='OSM_TECH@LIST.ETSI.ORG', # TODO py3
- # TODO py3 maintainer_email='',
+ author_email='OSM_TECH@LIST.ETSI.ORG',
+ maintainer='ETSI OSM',
+ maintainer_email='OSM_TECH@LIST.ETSI.ORG',
url='https://osm.etsi.org/gitweb/?p=osm/RO.git;a=summary',
license='Apache 2.0',
install_requires=[
"pyvcloud==19.1.1", "progressbar", "prettytable", "pyvmomi",
"requests", "netaddr", "PyYAML",
- "osm-ro @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro&subdirectory=RO"
+ "osm-ro-plugin @ git+https://osm.etsi.org/gerrit/osm/RO.git#egg=osm-ro-plugin&subdirectory=RO-plugin"
],
setup_requires=['setuptools-version-command'],
entry_points={
- 'osm_rovim.plugins': ['rovim_vmware = osm_rovim_vmware.vimconn_vmware'],
+ 'osm_rovim.plugins': ['rovim_vmware = osm_rovim_vmware.vimconn_vmware:vimconnector'],
},
)
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro, python3-pip,
+Depends3: python3-requests, python3-netaddr, python3-yaml, python3-osm-ro-plugin, python3-pip,
genisoimage, python3-progressbar, python3-prettytable, python3-pyvmomi
[DEFAULT]
X-Python3-Version : >= 3.5
-Depends3: python3-argcomplete, python3-requests, python3-yaml
+Maintainer: Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>
+Depends3: python3-argcomplete, python3-requests, python3-yaml
--- /dev/null
+##
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+##
+
+all: clean package
+
+clean:
+ rm -rf dist deb_dist osm_ro_plugin-*.tar.gz osm_ro_plugin.egg-info .eggs
+
+package:
+ python3 setup.py --command-packages=stdeb.command sdist_dsc
+ cd deb_dist/osm-ro-plugin*/ && dpkg-buildpackage -rfakeroot -uc -us
+
--- /dev/null
+##
+# Copyright 2019 Telefonica Investigacion y Desarrollo, S.A.U.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+##
+import logging
+from http import HTTPStatus
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
+from uuid import uuid4
+
+"""
+Implement an Abstract class 'OpenflowConn' and an engine 'SdnConnectorOpenFlow' used for base class for SDN plugings
+that implements a pro-active opeflow rules.
+"""
+
+__author__ = "Alfonso Tierno"
+__date__ = "2019-11-11"
+
+
+class OpenflowConnException(Exception):
+ """Common and base class Exception for all vimconnector exceptions"""
+ def __init__(self, message, http_code=HTTPStatus.BAD_REQUEST.value):
+ Exception.__init__(self, message)
+ self.http_code = http_code
+
+
+class OpenflowConnConnectionException(OpenflowConnException):
+ """Connectivity error with the VIM"""
+ def __init__(self, message, http_code=HTTPStatus.SERVICE_UNAVAILABLE.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConnUnexpectedResponse(OpenflowConnException):
+ """Get an wrong response from VIM"""
+ def __init__(self, message, http_code=HTTPStatus.INTERNAL_SERVER_ERROR.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConnAuthException(OpenflowConnException):
+ """Invalid credentials or authorization to perform this action over the VIM"""
+ def __init__(self, message, http_code=HTTPStatus.UNAUTHORIZED.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConnNotFoundException(OpenflowConnException):
+ """The item is not found at VIM"""
+ def __init__(self, message, http_code=HTTPStatus.NOT_FOUND.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConnConflictException(OpenflowConnException):
+ """There is a conflict, e.g. more item found than one"""
+ def __init__(self, message, http_code=HTTPStatus.CONFLICT.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConnNotSupportedException(OpenflowConnException):
+ """The request is not supported by connector"""
+ def __init__(self, message, http_code=HTTPStatus.SERVICE_UNAVAILABLE.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConnNotImplemented(OpenflowConnException):
+ """The method is not implemented by the connected"""
+ def __init__(self, message, http_code=HTTPStatus.NOT_IMPLEMENTED.value):
+ OpenflowConnException.__init__(self, message, http_code)
+
+
+class OpenflowConn:
+ """
+ Openflow controller connector abstract implementeation.
+ """
+ def __init__(self, params):
+ self.name = "openflow_conector"
+ self.pp2ofi = {} # From Physical Port to OpenFlow Index
+ self.ofi2pp = {} # From OpenFlow Index to Physical Port
+ self.logger = logging.getLogger('openmano.sdn.openflow_conn')
+
+ def get_of_switches(self):
+ """"
+ Obtain a a list of switches or DPID detected by this controller
+ :return: list length, and a list where each element a tuple pair (DPID, IP address), text_error: if fails
+ """
+ raise OpenflowConnNotImplemented("Should have implemented this")
+
+ def obtain_port_correspondence(self):
+ """
+ Obtain the correspondence between physical and openflow port names
+ :return: dictionary: with physical name as key, openflow name as value, error_text: if fails
+ """
+ raise OpenflowConnNotImplemented("Should have implemented this")
+
+ def get_of_rules(self, translate_of_ports=True):
+ """
+ Obtain the rules inserted at openflow controller
+ :param translate_of_ports: if True it translates ports from openflow index to physical switch name
+ :return: list where each item is a dictionary with the following content:
+ priority: rule priority
+ priority: rule priority
+ name: rule name (present also as the master dict key)
+ ingress_port: match input port of the rule
+ dst_mac: match destination mac address of the rule, can be missing or None if not apply
+ vlan_id: match vlan tag of the rule, can be missing or None if not apply
+ actions: list of actions, composed by a pair tuples:
+ (vlan, None/int): for stripping/setting a vlan tag
+ (out, port): send to this port
+ switch: DPID, all
+ text_error if fails
+ """
+ raise OpenflowConnNotImplemented("Should have implemented this")
+
+ def del_flow(self, flow_name):
+ """
+ Delete all existing rules
+ :param flow_name: flow_name, this is the rule name
+ :return: None if ok, text_error if fails
+ """
+ raise OpenflowConnNotImplemented("Should have implemented this")
+
+ def new_flow(self, data):
+ """
+ Insert a new static rule
+ :param data: dictionary with the following content:
+ priority: rule priority
+ name: rule name
+ ingress_port: match input port of the rule
+ dst_mac: match destination mac address of the rule, missing or None if not apply
+ vlan_id: match vlan tag of the rule, missing or None if not apply
+ actions: list of actions, composed by a pair tuples with these posibilities:
+ ('vlan', None/int): for stripping/setting a vlan tag
+ ('out', port): send to this port
+ :return: None if ok, text_error if fails
+ """
+ raise OpenflowConnNotImplemented("Should have implemented this")
+
+ def clear_all_flows(self):
+ """"
+ Delete all existing rules
+ :return: None if ok, text_error if fails
+ """
+ raise OpenflowConnNotImplemented("Should have implemented this")
+
+
+class SdnConnectorOpenFlow(SdnConnectorBase):
+ """
+ This class is the base engine of SDN plugins base on openflow rules
+ """
+ flow_fields = ('priority', 'vlan', 'ingress_port', 'actions', 'dst_mac', 'src_mac', 'net_id')
+
+ def __init__(self, wim, wim_account, config=None, logger=None, of_connector=None):
+ self.logger = logger or logging.getLogger('openmano.sdn.openflow_conn')
+ self.of_connector = of_connector
+ self.of_controller_nets_with_same_vlan = config.get("of_controller_nets_with_same_vlan", False)
+
+ def check_credentials(self):
+ try:
+ self.openflow_conn.obtain_port_correspondence()
+ except OpenflowConnException as e:
+ raise SdnConnectorError(e, http_code=e.http_code)
+
+ def get_connectivity_service_status(self, service_uuid, conn_info=None):
+ conn_info = conn_info or {}
+ return {
+ "sdn_status": conn_info.get("status", "ERROR"),
+ "error_msg": conn_info.get("error_msg", "Variable conn_info not provided"),
+ }
+ # TODO check rules connectirng to of_connector
+
+ def create_connectivity_service(self, service_type, connection_points, **kwargs):
+ net_id = str(uuid4())
+ ports = []
+ for cp in connection_points:
+ port = {
+ "uuid": cp["service_endpoint_id"],
+ "vlan": cp.get("service_endpoint_encapsulation_info", {}).get("vlan"),
+ "mac": cp.get("service_endpoint_encapsulation_info", {}).get("mac"),
+ "switch_port": cp.get("service_endpoint_encapsulation_info", {}).get("switch_port"),
+ }
+ ports.append(port)
+ try:
+ created_items = self._set_openflow_rules(service_type, net_id, ports, created_items=None)
+ return net_id, created_items
+ except (SdnConnectorError, OpenflowConnException) as e:
+ raise SdnConnectorError(e, http_code=e.http_code)
+
+ def delete_connectivity_service(self, service_uuid, conn_info=None):
+ try:
+ service_type = "ELAN"
+ ports = []
+ self._set_openflow_rules(service_type, service_uuid, ports, created_items=conn_info)
+ return None
+ except (SdnConnectorError, OpenflowConnException) as e:
+ raise SdnConnectorError(e, http_code=e.http_code)
+
+ def edit_connectivity_service(self, service_uuid, conn_info=None, connection_points=None, **kwargs):
+ ports = []
+ for cp in connection_points:
+ port = {
+ "uuid": cp["service_endpoint_id"],
+ "vlan": cp.get("service_endpoint_encapsulation_info", {}).get("vlan"),
+ "mac": cp.get("service_endpoint_encapsulation_info", {}).get("mac"),
+ "switch_port": cp.get("service_endpoint_encapsulation_info", {}).get("switch_port"),
+ }
+ ports.append(port)
+ service_type = "ELAN" # TODO. Store at conn_info for later use
+ try:
+ created_items = self._set_openflow_rules(service_type, service_uuid, ports, created_items=conn_info)
+ return created_items
+ except (SdnConnectorError, OpenflowConnException) as e:
+ raise SdnConnectorError(e, http_code=e.http_code)
+
+ def clear_all_connectivity_services(self):
+ """Delete all WAN Links corresponding to a WIM"""
+ pass
+
+ def get_all_active_connectivity_services(self):
+ """Provide information about all active connections provisioned by a
+ WIM
+ """
+ pass
+
+ def _set_openflow_rules(self, net_type, net_id, ports, created_items=None):
+ ifaces_nb = len(ports)
+ if not created_items:
+ created_items = {"status": None, "error_msg": None, "installed_rules_ids": []}
+ rules_to_delete = created_items.get("installed_rules_ids") or []
+ new_installed_rules_ids = []
+ error_list = []
+
+ try:
+ step = "Checking ports and network type compatibility"
+ if ifaces_nb < 2:
+ pass
+ elif net_type == 'ELINE':
+ if ifaces_nb > 2:
+ raise SdnConnectorError("'ELINE' type network cannot connect {} interfaces, only 2".format(
+ ifaces_nb))
+ elif net_type == 'ELAN':
+ if ifaces_nb > 2 and self.of_controller_nets_with_same_vlan:
+ # check all ports are VLAN (tagged) or none
+ vlan_tags = []
+ for port in ports:
+ if port["vlan"] not in vlan_tags:
+ vlan_tags.append(port["vlan"])
+ if len(vlan_tags) > 1:
+ raise SdnConnectorError("This pluging cannot connect ports with diferent VLAN tags when flag "
+ "'of_controller_nets_with_same_vlan' is active")
+ else:
+ raise SdnConnectorError('Only ELINE or ELAN network types are supported for openflow')
+
+ # Get the existing flows at openflow controller
+ step = "Getting installed openflow rules"
+ existing_flows = self.of_connector.get_of_rules()
+ existing_flows_ids = [flow["name"] for flow in existing_flows]
+
+ # calculate new flows to be inserted
+ step = "Compute needed openflow rules"
+ new_flows = self._compute_net_flows(net_id, ports)
+
+ name_index = 0
+ for flow in new_flows:
+ # 1 check if an equal flow is already present
+ index = self._check_flow_already_present(flow, existing_flows)
+ if index >= 0:
+ flow_id = existing_flows[index]["name"]
+ self.logger.debug("Skipping already present flow %s", str(flow))
+ else:
+ # 2 look for a non used name
+ flow_name = flow["net_id"] + "." + str(name_index)
+ while flow_name in existing_flows_ids:
+ name_index += 1
+ flow_name = flow["net_id"] + "." + str(name_index)
+ flow['name'] = flow_name
+ # 3 insert at openflow
+ try:
+ self.of_connector.new_flow(flow)
+ flow_id = flow["name"]
+ existing_flows_ids.append(flow_id)
+ except OpenflowConnException as e:
+ flow_id = None
+ error_list.append("Cannot create rule for ingress_port={}, dst_mac={}: {}"
+ .format(flow["ingress_port"], flow["dst_mac"], e))
+
+ # 4 insert at database
+ if flow_id:
+ new_installed_rules_ids.append(flow_id)
+ if flow_id in rules_to_delete:
+ rules_to_delete.remove(flow_id)
+
+ # delete not needed old flows from openflow
+ for flow_id in rules_to_delete:
+ # Delete flow
+ try:
+ self.of_connector.del_flow(flow_id)
+ except OpenflowConnNotFoundException:
+ pass
+ except OpenflowConnException as e:
+ error_text = "Cannot remove rule '{}': {}".format(flow_id, e)
+ error_list.append(error_text)
+ self.logger.error(error_text)
+ created_items["installed_rules_ids"] = new_installed_rules_ids
+ if error_list:
+ created_items["error_msg"] = ";".join(error_list)[:1000]
+ created_items["error_msg"] = "ERROR"
+ else:
+ created_items["error_msg"] = None
+ created_items["status"] = "ACTIVE"
+ return created_items
+ except (SdnConnectorError, OpenflowConnException) as e:
+ raise SdnConnectorError("Error while {}: {}".format(step, e)) from e
+ except Exception as e:
+ error_text = "Error while {}: {}".format(step, e)
+ self.logger.critical(error_text, exc_info=True)
+ raise SdnConnectorError(error_text)
+
+ def _compute_net_flows(self, net_id, ports):
+ new_flows = []
+ new_broadcast_flows = {}
+ nb_ports = len(ports)
+
+ # Check switch_port information is right
+ for port in ports:
+ nb_ports += 1
+ if str(port['switch_port']) not in self.of_connector.pp2ofi:
+ raise SdnConnectorError("switch port name '{}' is not valid for the openflow controller".
+ format(port['switch_port']))
+ priority = 1000 # 1100
+
+ for src_port in ports:
+ # if src_port.get("groups")
+ vlan_in = src_port['vlan']
+
+ # BROADCAST:
+ broadcast_key = src_port['uuid'] + "." + str(vlan_in)
+ if broadcast_key in new_broadcast_flows:
+ flow_broadcast = new_broadcast_flows[broadcast_key]
+ else:
+ flow_broadcast = {'priority': priority,
+ 'net_id': net_id,
+ 'dst_mac': 'ff:ff:ff:ff:ff:ff',
+ "ingress_port": str(src_port['switch_port']),
+ 'vlan_id': vlan_in,
+ 'actions': []
+ }
+ new_broadcast_flows[broadcast_key] = flow_broadcast
+ if vlan_in is not None:
+ flow_broadcast['vlan_id'] = str(vlan_in)
+
+ for dst_port in ports:
+ vlan_out = dst_port['vlan']
+ if src_port['switch_port'] == dst_port['switch_port'] and vlan_in == vlan_out:
+ continue
+ flow = {
+ "priority": priority,
+ 'net_id': net_id,
+ "ingress_port": str(src_port['switch_port']),
+ 'vlan_id': vlan_in,
+ 'actions': []
+ }
+ # allow that one port have no mac
+ if dst_port['mac'] is None or nb_ports == 2: # point to point or nets with 2 elements
+ flow['priority'] = priority - 5 # less priority
+ else:
+ flow['dst_mac'] = str(dst_port['mac'])
+
+ if vlan_out is None:
+ if vlan_in:
+ flow['actions'].append(('vlan', None))
+ else:
+ flow['actions'].append(('vlan', vlan_out))
+ flow['actions'].append(('out', str(dst_port['switch_port'])))
+
+ if self._check_flow_already_present(flow, new_flows) >= 0:
+ self.logger.debug("Skipping repeated flow '%s'", str(flow))
+ continue
+
+ new_flows.append(flow)
+
+ # BROADCAST:
+ if nb_ports <= 2: # point to multipoint or nets with more than 2 elements
+ continue
+ out = (vlan_out, str(dst_port['switch_port']))
+ if out not in flow_broadcast['actions']:
+ flow_broadcast['actions'].append(out)
+
+ # BROADCAST
+ for flow_broadcast in new_broadcast_flows.values():
+ if len(flow_broadcast['actions']) == 0:
+ continue # nothing to do, skip
+ flow_broadcast['actions'].sort()
+ if 'vlan_id' in flow_broadcast:
+ previous_vlan = 0 # indicates that a packet contains a vlan, and the vlan
+ else:
+ previous_vlan = None
+ final_actions = []
+ action_number = 0
+ for action in flow_broadcast['actions']:
+ if action[0] != previous_vlan:
+ final_actions.append(('vlan', action[0]))
+ previous_vlan = action[0]
+ if self.of_controller_nets_with_same_vlan and action_number:
+ raise SdnConnectorError("Cannot interconnect different vlan tags in a network when flag "
+ "'of_controller_nets_with_same_vlan' is True.")
+ action_number += 1
+ final_actions.append(('out', action[1]))
+ flow_broadcast['actions'] = final_actions
+
+ if self._check_flow_already_present(flow_broadcast, new_flows) >= 0:
+ self.logger.debug("Skipping repeated flow '%s'", str(flow_broadcast))
+ continue
+
+ new_flows.append(flow_broadcast)
+
+ # UNIFY openflow rules with the same input port and vlan and the same output actions
+ # These flows differ at the dst_mac; and they are unified by not filtering by dst_mac
+ # this can happen if there is only two ports. It is converted to a point to point connection
+ flow_dict = {} # use as key vlan_id+ingress_port and as value the list of flows matching these values
+ for flow in new_flows:
+ key = str(flow.get("vlan_id")) + ":" + flow["ingress_port"]
+ if key in flow_dict:
+ flow_dict[key].append(flow)
+ else:
+ flow_dict[key] = [flow]
+ new_flows2 = []
+ for flow_list in flow_dict.values():
+ convert2ptp = False
+ if len(flow_list) >= 2:
+ convert2ptp = True
+ for f in flow_list:
+ if f['actions'] != flow_list[0]['actions']:
+ convert2ptp = False
+ break
+ if convert2ptp: # add only one unified rule without dst_mac
+ self.logger.debug("Convert flow rules to NON mac dst_address " + str(flow_list))
+ flow_list[0].pop('dst_mac')
+ flow_list[0]["priority"] -= 5
+ new_flows2.append(flow_list[0])
+ else: # add all the rules
+ new_flows2 += flow_list
+ return new_flows2
+
+ def _check_flow_already_present(self, new_flow, flow_list):
+ '''check if the same flow is already present in the flow list
+ The flow is repeated if all the fields, apart from name, are equal
+ Return the index of matching flow, -1 if not match'''
+ for index, flow in enumerate(flow_list):
+ for f in self.flow_fields:
+ if flow.get(f) != new_flow.get(f):
+ break
+ else:
+ return index
+ return -1
--- /dev/null
+# -*- coding: utf-8 -*-
+##
+# Copyright 2018 Telefonica
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This WIM does nothing and allows using it for testing and when no WIM is needed
+"""
+
+import logging
+from uuid import uuid4
+from osm_ro_plugin.sdnconn import SdnConnectorBase, SdnConnectorError
+from http import HTTPStatus
+__author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
+
+
+class SdnDummyConnector(SdnConnectorBase):
+ """Abstract base class for all the WIM connectors
+
+ Arguments:
+ wim (dict): WIM record, as stored in the database
+ wim_account (dict): WIM account record, as stored in the database
+ config (dict): optional persistent information related to an specific
+ connector. Inside this dict, a special key,
+ ``service_endpoint_mapping`` provides the internal endpoint
+ mapping.
+ logger (logging.Logger): optional logger object. If none is passed
+ ``openmano.wim.wimconn`` is used.
+
+ The arguments of the constructor are converted to object attributes.
+ An extra property, ``service_endpoint_mapping`` is created from ``config``.
+ """
+ def __init__(self, wim, wim_account, config=None, logger=None):
+ self.logger = logger or logging.getLogger('openmano.sdnconn.dummy')
+ super(SdnDummyConnector, self).__init__(wim, wim_account, config, self.logger)
+ self.logger.debug("__init: wim='{}' wim_account='{}'".format(wim, wim_account))
+ self.connections = {}
+ self.counter = 0
+
+ def check_credentials(self):
+ """Check if the connector itself can access the WIM.
+
+ Raises:
+ SdnConnectorError: Issues regarding authorization, access to
+ external URLs, etc are detected.
+ """
+ self.logger.debug("check_credentials")
+ return None
+
+ def get_connectivity_service_status(self, service_uuid, conn_info=None):
+ """Monitor the status of the connectivity service established
+
+ Arguments:
+ service_uuid (str): UUID of the connectivity service
+ conn_info (dict or None): Information returned by the connector
+ during the service creation/edition and subsequently stored in
+ the database.
+
+ Returns:
+ dict: JSON/YAML-serializable dict that contains a mandatory key
+ ``sdn_status`` associated with one of the following values::
+
+ Additionally ``error_msg``(**str**) and ``sdn_info``(**dict**)
+ keys can be used to provide additional status explanation or
+ new information available for the connectivity service.
+ """
+ self.logger.debug("get_connectivity_service_status: service_uuid='{}' conn_info='{}'".format(service_uuid,
+ conn_info))
+ return {'sdn_status': 'ACTIVE', 'sdn_info': self.connectivity.get(service_uuid)}
+
+ def create_connectivity_service(self, service_type, connection_points,
+ **kwargs):
+ """
+ Stablish WAN connectivity between the endpoints
+
+ """
+ self.logger.debug("create_connectivity_service: service_type='{}' connection_points='{}', kwargs='{}'".
+ format(service_type, connection_points, kwargs))
+ _id = str(uuid4())
+ self.connections[_id] = connection_points.copy()
+ self.counter += 1
+ return _id, None
+
+ def delete_connectivity_service(self, service_uuid, conn_info=None):
+ """Disconnect multi-site endpoints previously connected
+
+ """
+ self.logger.debug("delete_connectivity_service: service_uuid='{}' conn_info='{}'".format(service_uuid,
+ conn_info))
+ if service_uuid not in self.connections:
+ raise SdnConnectorError("connectivity {} not found".format(service_uuid),
+ http_code=HTTPStatus.NOT_FOUND.value)
+ self.connections.pop(service_uuid, None)
+ return None
+
+ def edit_connectivity_service(self, service_uuid, conn_info=None,
+ connection_points=None, **kwargs):
+ """Change an existing connectivity service.
+
+ This method's arguments and return value follow the same convention as
+ :meth:`~.create_connectivity_service`.
+ """
+ self.logger.debug("edit_connectivity_service: service_uuid='{}' conn_info='{}', connection_points='{}'"
+ "kwargs='{}'".format(service_uuid, conn_info, connection_points, kwargs))
+ if service_uuid not in self.connections:
+ raise SdnConnectorError("connectivity {} not found".format(service_uuid),
+ http_code=HTTPStatus.NOT_FOUND.value)
+ self.connections[service_uuid] = connection_points.copy()
+ return None
+
+ def clear_all_connectivity_services(self):
+ """Delete all WAN Links in a WIM.
+
+ This method is intended for debugging only, and should delete all the
+ connections controlled by the WIM, not only the WIM connections that
+ a specific RO is aware of.
+
+ """
+ self.logger.debug("clear_all_connectivity_services")
+ self.connections.clear()
+ return None
+
+ def get_all_active_connectivity_services(self):
+ """Provide information about all active connections provisioned by a
+ WIM.
+
+ Raises:
+ SdnConnectorException: In case of error.
+ """
+ self.logger.debug("get_all_active_connectivity_services")
+ return self.connections
--- /dev/null
+# -*- coding: utf-8 -*-
+##
+# Copyright 2018 University of Bristol - High Performance Networks Research
+# Group
+# All Rights Reserved.
+#
+# Contributors: Anderson Bravalheri, Dimitrios Gkounis, Abubakar Siddique
+# Muqaddas, Navdeep Uniyal, Reza Nejabati and Dimitra Simeonidou
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: <highperformance-networks@bristol.ac.uk>
+#
+# Neither the name of the University of Bristol nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# This work has been performed in the context of DCMS UK 5G Testbeds
+# & Trials Programme and in the framework of the Metro-Haul project -
+# funded by the European Commission under Grant number 761727 through the
+# Horizon 2020 and 5G-PPP programmes.
+##
+
+"""In the case any error happens when trying to initiate the WIM Connector,
+we need a replacement for it, that will throw an error every time we try to
+execute any action
+"""
+import json
+from osm_ro_plugin.sdnconn import SdnConnectorError
+
+
+class SdnFailingConnector(object):
+ """Placeholder for a connector whose incitation failed,
+ This place holder will just raise an error every time an action is needed
+ from the connector.
+
+ This way we can make sure that all the other parts of the program will work
+ but the user will have all the information available to fix the problem.
+ """
+ def __init__(self, error_msg):
+ self.error_msg = error_msg
+
+ def __call__(self, wim, wim_account, config=None, logger=None):
+ return self
+
+ def vimconnector(self, *args, **kwargs):
+ raise Exception(self.error_msg)
+
+ def check_credentials(self):
+ raise SdnConnectorError('Impossible to use WIM:\n' + self.error_msg)
+
+ def get_connectivity_service_status(self, service_uuid, _conn_info=None):
+ raise SdnConnectorError('Impossible to retrieve status for {}\n\n{}'
+ .format(service_uuid, self.error_msg))
+
+ def create_connectivity_service(self, service_uuid, *args, **kwargs):
+ raise SdnConnectorError('Impossible to connect {}.\n{}\n{}\n{}'
+ .format(service_uuid, self.error_msg,
+ json.dumps(args, indent=4),
+ json.dumps(kwargs, indent=4)))
+
+ def delete_connectivity_service(self, service_uuid, _conn_info=None):
+ raise SdnConnectorError('Impossible to disconnect {}\n\n{}'
+ .format(service_uuid, self.error_msg))
+
+ def edit_connectivity_service(self, service_uuid, *args, **kwargs):
+ raise SdnConnectorError('Impossible to change connection {}.\n{}\n'
+ '{}\n{}'
+ .format(service_uuid, self.error_msg,
+ json.dumps(args, indent=4),
+ json.dumps(kwargs, indent=4)))
+
+ def clear_all_connectivity_services(self):
+ raise SdnConnectorError('Impossible to use WIM:\n' + self.error_msg)
+
+ def get_all_active_connectivity_services(self):
+ raise SdnConnectorError('Impossible to use WIM:\n' + self.error_msg)
projects / osm / RO.git / commitdiff