Add MESO component that allows:
- Apmec to collaborate with other orchestration frameworks (e.g, NFV framework) - for oprators to excecute smart placement decisions of MEC applications Change-Id: I28fe23029f11632f1909967238b9fd440aa6f936
This commit is contained in:
Tung Doan
parent
c41e2d080d
commit
bff90fa0b1
|
|
@ -0,0 +1,356 @@
|
|||
# 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.
|
||||
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
from oslo_db.exception import DBDuplicateEntry
|
||||
from oslo_log import log as logging
|
||||
from oslo_utils import timeutils
|
||||
from oslo_utils import uuidutils
|
||||
|
||||
import sqlalchemy as sa
|
||||
from sqlalchemy import orm
|
||||
from sqlalchemy.orm import exc as orm_exc
|
||||
from sqlalchemy import schema
|
||||
|
||||
from apmec.common import exceptions
|
||||
from apmec.db.common_services import common_services_db_plugin
|
||||
from apmec.db import db_base
|
||||
from apmec.db import model_base
|
||||
from apmec.db import models_v1
|
||||
from apmec.db import types
|
||||
from apmec.extensions import meso
|
||||
from apmec.plugins.common import constants
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
_ACTIVE_UPDATE = (constants.ACTIVE, constants.PENDING_UPDATE)
|
||||
_ACTIVE_UPDATE_ERROR_DEAD = (
|
||||
constants.PENDING_CREATE, constants.ACTIVE, constants.PENDING_UPDATE,
|
||||
constants.ERROR, constants.DEAD)
|
||||
CREATE_STATES = (constants.PENDING_CREATE, constants.DEAD)
|
||||
|
||||
|
||||
###########################################################################
|
||||
# db tables
|
||||
|
||||
class MESD(model_base.BASE, models_v1.HasId, models_v1.HasTenant,
|
||||
models_v1.Audit):
|
||||
"""Represents MESD to create MES."""
|
||||
|
||||
__tablename__ = 'mesd'
|
||||
# Descriptive name
|
||||
name = sa.Column(sa.String(255), nullable=False)
|
||||
description = sa.Column(sa.Text)
|
||||
# Mesd template source - onboarded
|
||||
template_source = sa.Column(sa.String(255), server_default='onboarded')
|
||||
mesd_mapping = sa.Column(types.Json, nullable=True)
|
||||
# (key, value) pair to spin up
|
||||
attributes = orm.relationship('MESDAttribute',
|
||||
backref='mesd')
|
||||
|
||||
__table_args__ = (
|
||||
schema.UniqueConstraint(
|
||||
"tenant_id",
|
||||
"name",
|
||||
name="uniq_mesd0tenant_id0name"),
|
||||
)
|
||||
|
||||
|
||||
class MESDAttribute(model_base.BASE, models_v1.HasId):
|
||||
"""Represents attributes necessary for creation of mes in (key, value) pair
|
||||
|
||||
"""
|
||||
|
||||
__tablename__ = 'mesd_attribute'
|
||||
mesd_id = sa.Column(types.Uuid, sa.ForeignKey('mesd.id'),
|
||||
nullable=False)
|
||||
key = sa.Column(sa.String(255), nullable=False)
|
||||
value = sa.Column(sa.TEXT(65535), nullable=True)
|
||||
|
||||
|
||||
class MES(model_base.BASE, models_v1.HasId, models_v1.HasTenant,
|
||||
models_v1.Audit):
|
||||
"""Represents network services that deploys services.
|
||||
|
||||
"""
|
||||
|
||||
__tablename__ = 'mes'
|
||||
mesd_id = sa.Column(types.Uuid, sa.ForeignKey('mesd.id'))
|
||||
mesd = orm.relationship('MESD')
|
||||
mes_mapping = sa.Column(types.Json, nullable=True)
|
||||
reused = sa.Column(types.Json, nullable=True)
|
||||
name = sa.Column(sa.String(255), nullable=False)
|
||||
description = sa.Column(sa.Text, nullable=True)
|
||||
|
||||
# Dict of MEA details that network service launches
|
||||
mea_ids = sa.Column(sa.TEXT(65535), nullable=True)
|
||||
|
||||
# Dict of mgmt urls that network servic launches
|
||||
mgmt_urls = sa.Column(sa.TEXT(65535), nullable=True)
|
||||
|
||||
status = sa.Column(sa.String(64), nullable=False)
|
||||
vim_id = sa.Column(types.Uuid, sa.ForeignKey('vims.id'), nullable=False)
|
||||
error_reason = sa.Column(sa.Text, nullable=True)
|
||||
|
||||
__table_args__ = (
|
||||
schema.UniqueConstraint(
|
||||
"tenant_id",
|
||||
"name",
|
||||
name="uniq_mes0tenant_id0name"),
|
||||
)
|
||||
|
||||
|
||||
class MESOPluginDb(meso.MESOPluginBase, db_base.CommonDbMixin):
|
||||
|
||||
def __init__(self):
|
||||
super(MESOPluginDb, self).__init__()
|
||||
self._cos_db_plg = common_services_db_plugin.CommonServicesPluginDb()
|
||||
|
||||
def _get_resource(self, context, model, id):
|
||||
try:
|
||||
return self._get_by_id(context, model, id)
|
||||
except orm_exc.NoResultFound:
|
||||
if issubclass(model, MESD):
|
||||
raise meso.MESDNotFound(mesd_id=id)
|
||||
if issubclass(model, MES):
|
||||
raise meso.MESNotFound(mes_id=id)
|
||||
else:
|
||||
raise
|
||||
|
||||
def _get_mes_db(self, context, mes_id, current_statuses, new_status):
|
||||
try:
|
||||
mes_db = (
|
||||
self._model_query(context, MES).
|
||||
filter(MES.id == mes_id).
|
||||
filter(MES.status.in_(current_statuses)).
|
||||
with_lockmode('update').one())
|
||||
except orm_exc.NoResultFound:
|
||||
raise meso.MESNotFound(mes_id=mes_id)
|
||||
mes_db.update({'status': new_status})
|
||||
return mes_db
|
||||
|
||||
def _make_attributes_dict(self, attributes_db):
|
||||
return dict((attr.key, attr.value) for attr in attributes_db)
|
||||
|
||||
def _make_mesd_dict(self, mesd, fields=None):
|
||||
res = {
|
||||
'attributes': self._make_attributes_dict(mesd['attributes']),
|
||||
}
|
||||
key_list = ('id', 'tenant_id', 'name', 'description', 'mesd_mapping',
|
||||
'created_at', 'updated_at', 'template_source')
|
||||
res.update((key, mesd[key]) for key in key_list)
|
||||
return self._fields(res, fields)
|
||||
|
||||
def _make_dev_attrs_dict(self, dev_attrs_db):
|
||||
return dict((arg.key, arg.value) for arg in dev_attrs_db)
|
||||
|
||||
def _make_mes_dict(self, mes_db, fields=None):
|
||||
LOG.debug('mes_db %s', mes_db)
|
||||
res = {}
|
||||
key_list = ('id', 'tenant_id', 'mesd_id', 'name', 'description', 'mes_mapping', # noqa
|
||||
'mea_ids', 'status', 'mgmt_urls', 'error_reason', 'reused',
|
||||
'vim_id', 'created_at', 'updated_at')
|
||||
res.update((key, mes_db[key]) for key in key_list)
|
||||
return self._fields(res, fields)
|
||||
|
||||
def create_mesd(self, context, mesd):
|
||||
mesd = mesd['mesd']
|
||||
LOG.debug('mesd %s', mesd)
|
||||
tenant_id = self._get_tenant_id_for_create(context, mesd)
|
||||
template_source = mesd.get('template_source')
|
||||
|
||||
try:
|
||||
with context.session.begin(subtransactions=True):
|
||||
mesd_id = uuidutils.generate_uuid()
|
||||
mesd_db = MESD(
|
||||
id=mesd_id,
|
||||
tenant_id=tenant_id,
|
||||
name=mesd.get('name'),
|
||||
description=mesd.get('description'),
|
||||
mesd_mapping=mesd.get('mesd_mapping'),
|
||||
deleted_at=datetime.min,
|
||||
template_source=template_source)
|
||||
context.session.add(mesd_db)
|
||||
for (key, value) in mesd.get('attributes', {}).items():
|
||||
attribute_db = MESDAttribute(
|
||||
id=uuidutils.generate_uuid(),
|
||||
mesd_id=mesd_id,
|
||||
key=key,
|
||||
value=value)
|
||||
context.session.add(attribute_db)
|
||||
except DBDuplicateEntry as e:
|
||||
raise exceptions.DuplicateEntity(
|
||||
_type="mesd",
|
||||
entry=e.columns)
|
||||
LOG.debug('mesd_db %(mesd_db)s %(attributes)s ',
|
||||
{'mesd_db': mesd_db,
|
||||
'attributes': mesd_db.attributes})
|
||||
mesd_dict = self._make_mesd_dict(mesd_db)
|
||||
LOG.debug('mesd_dict %s', mesd_dict)
|
||||
self._cos_db_plg.create_event(
|
||||
context, res_id=mesd_dict['id'],
|
||||
res_type=constants.RES_TYPE_MESD,
|
||||
res_state=constants.RES_EVT_ONBOARDED,
|
||||
evt_type=constants.RES_EVT_CREATE,
|
||||
tstamp=mesd_dict[constants.RES_EVT_CREATED_FLD])
|
||||
return mesd_dict
|
||||
|
||||
def delete_mesd(self,
|
||||
context,
|
||||
mesd_id,
|
||||
soft_delete=True):
|
||||
with context.session.begin(subtransactions=True):
|
||||
mess_db = context.session.query(MES).filter_by(
|
||||
mesd_id=mesd_id).first()
|
||||
if mess_db is not None and mess_db.deleted_at is None:
|
||||
raise meso.MESDInUse(mesd_id=mesd_id)
|
||||
|
||||
mesd_db = self._get_resource(context, MESD,
|
||||
mesd_id)
|
||||
if soft_delete:
|
||||
mesd_db.update({'deleted_at': timeutils.utcnow()})
|
||||
self._cos_db_plg.create_event(
|
||||
context, res_id=mesd_db['id'],
|
||||
res_type=constants.RES_TYPE_MESD,
|
||||
res_state=constants.RES_EVT_NA_STATE,
|
||||
evt_type=constants.RES_EVT_DELETE,
|
||||
tstamp=mesd_db[constants.RES_EVT_DELETED_FLD])
|
||||
else:
|
||||
context.session.query(MESDAttribute).filter_by(
|
||||
mesd_id=mesd_id).delete()
|
||||
context.session.delete(mesd_db)
|
||||
|
||||
def get_mesd(self, context, mesd_id, fields=None):
|
||||
mesd_db = self._get_resource(context, MESD, mesd_id)
|
||||
return self._make_mesd_dict(mesd_db)
|
||||
|
||||
def get_mesds(self, context, filters, fields=None):
|
||||
if ('template_source' in filters) and \
|
||||
(filters['template_source'][0] == 'all'):
|
||||
filters.pop('template_source')
|
||||
return self._get_collection(context, MESD,
|
||||
self._make_mesd_dict,
|
||||
filters=filters, fields=fields)
|
||||
|
||||
# reference implementation. needs to be overrided by subclass
|
||||
def create_mes(self, context, mes):
|
||||
LOG.debug('mes %s', mes)
|
||||
mes = mes['mes']
|
||||
tenant_id = self._get_tenant_id_for_create(context, mes)
|
||||
mesd_id = mes['mesd_id']
|
||||
vim_id = mes['vim_id']
|
||||
name = mes.get('name')
|
||||
mes_mapping = mes['mes_mapping']
|
||||
mes_id = uuidutils.generate_uuid()
|
||||
try:
|
||||
with context.session.begin(subtransactions=True):
|
||||
mesd_db = self._get_resource(context, MESD,
|
||||
mesd_id)
|
||||
mes_db = MES(id=mes_id,
|
||||
tenant_id=tenant_id,
|
||||
name=name,
|
||||
description=mesd_db.description,
|
||||
mea_ids=None,
|
||||
status=constants.PENDING_CREATE,
|
||||
mes_mapping=mes_mapping,
|
||||
reused=None,
|
||||
mgmt_urls=None,
|
||||
mesd_id=mesd_id,
|
||||
vim_id=vim_id,
|
||||
error_reason=None,
|
||||
deleted_at=datetime.min)
|
||||
context.session.add(mes_db)
|
||||
except DBDuplicateEntry as e:
|
||||
raise exceptions.DuplicateEntity(
|
||||
_type="mes",
|
||||
entry=e.columns)
|
||||
return self._make_mes_dict(mes_db)
|
||||
|
||||
def create_mes_post(self, context, mes_id,
|
||||
mes_status, error_reason, args):
|
||||
LOG.debug('mes ID %s', mes_id)
|
||||
with context.session.begin(subtransactions=True):
|
||||
mes_db = self._get_resource(context, MES,
|
||||
mes_id)
|
||||
mes_db.update({'status': mes_status})
|
||||
mes_db.update({'error_reason': error_reason})
|
||||
mes_db.update({'updated_at': timeutils.utcnow()})
|
||||
mes_db.update({'reused': args.get("NS")})
|
||||
mes_dict = self._make_mes_dict(mes_db)
|
||||
return mes_dict
|
||||
|
||||
# reference implementation. needs to be overrided by subclass
|
||||
def delete_mes(self, context, mes_id):
|
||||
with context.session.begin(subtransactions=True):
|
||||
mes_db = self._get_mes_db(
|
||||
context, mes_id, _ACTIVE_UPDATE_ERROR_DEAD,
|
||||
constants.PENDING_DELETE)
|
||||
deleted_mes_db = self._make_mes_dict(mes_db)
|
||||
return deleted_mes_db
|
||||
|
||||
def delete_mes_post(self, context, mes_id,
|
||||
error_reason, soft_delete=True, error=False):
|
||||
mes = self.get_mes(context, mes_id)
|
||||
mesd_id = mes.get('mesd_id')
|
||||
with context.session.begin(subtransactions=True):
|
||||
query = (
|
||||
self._model_query(context, MES).
|
||||
filter(MES.id == mes_id).
|
||||
filter(MES.status == constants.PENDING_DELETE))
|
||||
if error:
|
||||
query.update({'status': constants.ERROR})
|
||||
if error_reason:
|
||||
query.update({'error_reason': error_reason})
|
||||
else:
|
||||
if soft_delete:
|
||||
deleted_time_stamp = timeutils.utcnow()
|
||||
query.update({'deleted_at': deleted_time_stamp})
|
||||
|
||||
else:
|
||||
query.delete()
|
||||
template_db = self._get_resource(context, MESD, mesd_id)
|
||||
if template_db.get('template_source') == 'inline':
|
||||
self.delete_mesd(context, mesd_id)
|
||||
|
||||
def get_mes(self, context, mes_id, fields=None):
|
||||
mes_db = self._get_resource(context, MES, mes_id)
|
||||
return self._make_mes_dict(mes_db)
|
||||
|
||||
def get_mess(self, context, filters=None, fields=None):
|
||||
return self._get_collection(context, MES,
|
||||
self._make_mes_dict,
|
||||
filters=filters, fields=fields)
|
||||
|
||||
def _update_mes_pre(self, context, mes_id):
|
||||
with context.session.begin(subtransactions=True):
|
||||
mes_db = self._get_mes_db(context, mes_id, _ACTIVE_UPDATE, constants.PENDING_UPDATE) # noqa
|
||||
return self._make_mes_dict(mes_db)
|
||||
|
||||
def _update_mes_post(self, context, mes_id, error_reason, mes_status, args): # noqa
|
||||
with context.session.begin(subtransactions=True):
|
||||
mes_db = self._get_resource(context, MES, mes_id)
|
||||
mes_db.update({'status': mes_status})
|
||||
mes_db.update({'error_reason': error_reason})
|
||||
mes_db.update({'updated_at': timeutils.utcnow()})
|
||||
mes_db.update({'reused': args.get('NS')})
|
||||
mes_dict = self._make_mes_dict(mes_db)
|
||||
return mes_dict
|
||||
|
||||
def _update_mes_status(self, context, mes_id, new_status):
|
||||
with context.session.begin(subtransactions=True):
|
||||
mes_db = self._get_mes_db(context, mes_id, _ACTIVE_UPDATE, new_status) # noqa
|
||||
return self._make_mes_dict(mes_db)
|
||||
|
||||
def update_mes(self, context, mes_id, mes):
|
||||
self._update_mes_pre(context, mes_id)
|
||||
self._update_mes_post(context, mes_id, constants.ACTIVE, None)
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
# 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 abc
|
||||
import six
|
||||
|
||||
from apmec.common import exceptions
|
||||
from apmec.services import service_base
|
||||
|
||||
|
||||
@six.add_metaclass(abc.ABCMeta)
|
||||
class MESPluginBase(service_base.MECPluginBase):
|
||||
|
||||
@abc.abstractmethod
|
||||
def create_mesd(self, context, mesd):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def delete_mesd(self, context, mesd_id):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mesd(self, context, mesd_id, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mesds(self, context, filters=None, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def create_mes(self, context, mes):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mess(self, context, filters=None, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mes(self, context, mes_id, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def delete_mes(self, context, mes_id):
|
||||
pass
|
||||
|
||||
|
||||
class MESDNotFound(exceptions.NotFound):
|
||||
message = _('MESD %(mesd_id)s could not be found')
|
||||
|
||||
|
||||
class MESNotFound(exceptions.NotFound):
|
||||
message = _('MES %(mes_id)s could not be found')
|
||||
|
|
@ -0,0 +1,320 @@
|
|||
# Copyright 2016 Brocade Communications Systems Inc
|
||||
# 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 abc
|
||||
|
||||
import six
|
||||
|
||||
from apmec._i18n import _
|
||||
from apmec.api import extensions
|
||||
from apmec.api.v1 import attributes as attr
|
||||
from apmec.api.v1 import resource_helper
|
||||
from apmec.common import exceptions
|
||||
from apmec.plugins.common import constants
|
||||
from apmec.services import service_base
|
||||
|
||||
|
||||
class MESDInUse(exceptions.InUse):
|
||||
message = _('MESD %(mesd_id)s is still in use')
|
||||
|
||||
|
||||
class MESInUse(exceptions.InUse):
|
||||
message = _('MES %(mes_id)s is still in use')
|
||||
|
||||
|
||||
class NoTasksException(exceptions.ApmecException):
|
||||
message = _('No tasks to run for %(action)s on %(resource)s')
|
||||
|
||||
|
||||
class MESDNotFound(exceptions.NotFound):
|
||||
message = _('MESD %(mesd_id)s could not be found')
|
||||
|
||||
|
||||
class MESNotFound(exceptions.NotFound):
|
||||
message = _('MES %(mes_id)s could not be found')
|
||||
|
||||
|
||||
class ToscaParserFailed(exceptions.InvalidInput):
|
||||
message = _("tosca-parser failed: - %(error_msg_details)s")
|
||||
|
||||
|
||||
class NSDNotFound(exceptions.NotFound):
|
||||
message = _('NSD template(s) not existed for MESD %(mesd_name)')
|
||||
|
||||
|
||||
class VNFFGDNotFound(exceptions.NotFound):
|
||||
message = _('VNFFGD template(s) not existed for MESD %(mesd_name)')
|
||||
|
||||
|
||||
class MECDriverNotfound(exceptions.NotFound):
|
||||
message = _('MEC driver not specified for the MESD %(mesd_name)')
|
||||
|
||||
|
||||
class NFVDriverNotFound(exceptions.NotFound):
|
||||
message = _('NFV driver is not specified for the MESD %(mesd_name)')
|
||||
|
||||
|
||||
RESOURCE_ATTRIBUTE_MAP = {
|
||||
'mesds': {
|
||||
'id': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'validate': {'type:uuid': None},
|
||||
'is_visible': True,
|
||||
'primary_key': True,
|
||||
},
|
||||
'tenant_id': {
|
||||
'allow_post': True,
|
||||
'allow_put': False,
|
||||
'validate': {'type:string': None},
|
||||
'required_by_policy': True,
|
||||
'is_visible': True,
|
||||
},
|
||||
'name': {
|
||||
'allow_post': True,
|
||||
'allow_put': True,
|
||||
'validate': {'type:string': None},
|
||||
'is_visible': True,
|
||||
},
|
||||
'description': {
|
||||
'allow_post': True,
|
||||
'allow_put': True,
|
||||
'validate': {'type:string': None},
|
||||
'is_visible': True,
|
||||
'default': '',
|
||||
},
|
||||
'mesd_mapping': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'convert_to': attr.convert_none_to_empty_dict,
|
||||
'validate': {'type:dict_or_nodata': None},
|
||||
'is_visible': True,
|
||||
'default': '',
|
||||
},
|
||||
'created_at': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
},
|
||||
'updated_at': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
},
|
||||
'attributes': {
|
||||
'allow_post': True,
|
||||
'allow_put': False,
|
||||
'convert_to': attr.convert_none_to_empty_dict,
|
||||
'validate': {'type:dict_or_nodata': None},
|
||||
'is_visible': True,
|
||||
'default': None,
|
||||
},
|
||||
'template_source': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
'default': 'onboarded'
|
||||
},
|
||||
|
||||
},
|
||||
|
||||
'mess': {
|
||||
'id': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'validate': {'type:uuid': None},
|
||||
'is_visible': True,
|
||||
'primary_key': True,
|
||||
},
|
||||
'tenant_id': {
|
||||
'allow_post': True,
|
||||
'allow_put': False,
|
||||
'validate': {'type:string': None},
|
||||
'required_by_policy': True,
|
||||
'is_visible': True,
|
||||
},
|
||||
'name': {
|
||||
'allow_post': True,
|
||||
'allow_put': True,
|
||||
'validate': {'type:string': None},
|
||||
'is_visible': True,
|
||||
},
|
||||
'description': {
|
||||
'allow_post': True,
|
||||
'allow_put': True,
|
||||
'validate': {'type:string': None},
|
||||
'is_visible': True,
|
||||
'default': '',
|
||||
},
|
||||
'created_at': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
},
|
||||
'updated_at': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
},
|
||||
'mes_mapping': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'convert_to': attr.convert_none_to_empty_dict,
|
||||
'validate': {'type:dict_or_nodata': None},
|
||||
'is_visible': True,
|
||||
'default': '',
|
||||
},
|
||||
'reused': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'convert_to': attr.convert_none_to_empty_dict,
|
||||
'validate': {'type:dict_or_nodata': None},
|
||||
'is_visible': True,
|
||||
'default': '',
|
||||
},
|
||||
'mesd_id': {
|
||||
'allow_post': True,
|
||||
'allow_put': False,
|
||||
'validate': {'type:uuid': None},
|
||||
'is_visible': True,
|
||||
'default': None,
|
||||
},
|
||||
'vim_id': {
|
||||
'allow_post': True,
|
||||
'allow_put': False,
|
||||
'validate': {'type:string': None},
|
||||
'is_visible': True,
|
||||
'default': '',
|
||||
},
|
||||
'status': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
},
|
||||
'error_reason': {
|
||||
'allow_post': False,
|
||||
'allow_put': False,
|
||||
'is_visible': True,
|
||||
},
|
||||
'attributes': {
|
||||
'allow_post': True,
|
||||
'allow_put': False,
|
||||
'convert_to': attr.convert_none_to_empty_dict,
|
||||
'validate': {'type:dict_or_nodata': None},
|
||||
'is_visible': True,
|
||||
'default': None,
|
||||
},
|
||||
'mesd_template': {
|
||||
'allow_post': True,
|
||||
'allow_put': True,
|
||||
'validate': {'type:dict_or_nodata': None},
|
||||
'is_visible': True,
|
||||
'default': None,
|
||||
},
|
||||
},
|
||||
|
||||
}
|
||||
|
||||
|
||||
class Meso(extensions.ExtensionDescriptor):
|
||||
@classmethod
|
||||
def get_name(cls):
|
||||
return 'MEC Service Orchestrator'
|
||||
|
||||
@classmethod
|
||||
def get_alias(cls):
|
||||
return 'MESO'
|
||||
|
||||
@classmethod
|
||||
def get_description(cls):
|
||||
return "Extension for MEC Service Orchestrator"
|
||||
|
||||
@classmethod
|
||||
def get_namespace(cls):
|
||||
return 'http://wiki.openstack.org/Apmec'
|
||||
|
||||
@classmethod
|
||||
def get_updated(cls):
|
||||
return "2015-12-21T10:00:00-00:00"
|
||||
|
||||
@classmethod
|
||||
def get_resources(cls):
|
||||
special_mappings = {}
|
||||
plural_mappings = resource_helper.build_plural_mappings(
|
||||
special_mappings, RESOURCE_ATTRIBUTE_MAP)
|
||||
attr.PLURALS.update(plural_mappings)
|
||||
return resource_helper.build_resource_info(
|
||||
plural_mappings, RESOURCE_ATTRIBUTE_MAP, constants.MESO,
|
||||
translate_name=True)
|
||||
|
||||
@classmethod
|
||||
def get_plugin_interface(cls):
|
||||
return MESOPluginBase
|
||||
|
||||
def update_attributes_map(self, attributes):
|
||||
super(Meso, self).update_attributes_map(
|
||||
attributes, extension_attrs_map=RESOURCE_ATTRIBUTE_MAP)
|
||||
|
||||
def get_extended_resources(self, version):
|
||||
version_map = {'1.0': RESOURCE_ATTRIBUTE_MAP}
|
||||
return version_map.get(version, {})
|
||||
|
||||
|
||||
@six.add_metaclass(abc.ABCMeta)
|
||||
class MESOPluginBase(service_base.MECPluginBase):
|
||||
def get_plugin_name(self):
|
||||
return constants.MESO
|
||||
|
||||
def get_plugin_type(self):
|
||||
return constants.MESO
|
||||
|
||||
def get_plugin_description(self):
|
||||
return 'Apmec MEC service Orchestrator plugin'
|
||||
|
||||
@abc.abstractmethod
|
||||
def create_mesd(self, context, mesd):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def delete_mesd(self, context, mesd_id):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mesd(self, context, mesd_id, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mesds(self, context, filters=None, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def create_mes(self, context, mes):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mess(self, context, filters=None, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_mes(self, context, mes_id, fields=None):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def delete_mes(self, context, mes_id):
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def update_mes(self, context, mes_id, mes):
|
||||
pass
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
# 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 abc
|
||||
|
||||
import six
|
||||
|
||||
from apmec.api import extensions
|
||||
|
||||
|
||||
@six.add_metaclass(abc.ABCMeta)
|
||||
class NfvAbstractDriver(extensions.PluginInterface):
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_type(self):
|
||||
"""Get NFV Driver type
|
||||
|
||||
Return one of predefined types of NFV drivers.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_name(self):
|
||||
"""Get NFV driver name
|
||||
|
||||
Return a symbolic name for the NFV driver.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abc.abstractmethod
|
||||
def get_description(self):
|
||||
pass
|
||||
|
|
@ -0,0 +1,278 @@
|
|||
# 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.
|
||||
|
||||
from keystoneauth1 import identity
|
||||
from keystoneauth1 import session
|
||||
from oslo_config import cfg
|
||||
from oslo_log import log as logging
|
||||
|
||||
from apmec.meso.drivers.nfv_drivers import abstract_driver
|
||||
|
||||
from tackerclient.v1_0 import client as tacker_client
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
CONF = cfg.CONF
|
||||
|
||||
|
||||
class Tacker_Driver(abstract_driver.NfvAbstractDriver):
|
||||
"""Driver for NFV
|
||||
|
||||
OpenStack driver handles interactions with local as well as
|
||||
remote OpenStack instances. The driver invokes keystone service for VIM
|
||||
authorization and validation. The driver is also responsible for
|
||||
discovering placement attributes such as regions, availability zones
|
||||
"""
|
||||
|
||||
def get_type(self):
|
||||
return 'tacker'
|
||||
|
||||
def get_name(self):
|
||||
return 'OpenStack Tacker Driver'
|
||||
|
||||
def get_description(self):
|
||||
return 'OpenStack Tacker Driver'
|
||||
|
||||
def nsd_create(self, auth_attr, nsd_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.nsd_create(nsd_dict)
|
||||
|
||||
def nsd_get_by_name(self, auth_attr, nsd_name):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.nsd_get_by_name(nsd_name)
|
||||
|
||||
def nsd_get(self, auth_attr, nsd_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.nsd_get(nsd_id)
|
||||
|
||||
def ns_create(self, auth_attr, ns_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_create(ns_dict)
|
||||
|
||||
def ns_get_by_name(self, auth_attr, ns_name):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_get(ns_name)
|
||||
|
||||
def ns_get(self, auth_attr, ns_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_get(ns_id)
|
||||
|
||||
def ns_check(self, auth_attr, ns_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_check(ns_id)
|
||||
|
||||
def ns_delete_by_name(self, auth_attr, ns_name):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_delete(ns_name)
|
||||
|
||||
def ns_delete(self, auth_attr, ns_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_delete(ns_id)
|
||||
|
||||
def ns_update(self, auth_attr, ns_id, ns_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_update(ns_id, ns_dict)
|
||||
|
||||
def vnfd_create(self, auth_attr, vnfd_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnfd_create(vnfd_dict)
|
||||
|
||||
def vnf_create(self, auth_attr, vnf_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnf_create(vnf_dict)
|
||||
|
||||
def vnf_get(self, auth_attr, vnf_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnf_get(vnf_id)
|
||||
|
||||
def vnfd_get(self, auth_attr, vnfd_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnfd_get(vnfd_id)
|
||||
|
||||
def vnffgd_get_by_name(self, auth_attr, vnffgd_name):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffgd_get(vnffgd_name)
|
||||
|
||||
def vnffgd_get(self, auth_attr, vnffgd_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffgd_get(vnffgd_id)
|
||||
|
||||
def vnffg_create(self, auth_attr, vnffg_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffg_create(vnffg_dict)
|
||||
|
||||
def vnffg_get_by_name(self, auth_attr, vnffg_name):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffg_get(vnffg_name)
|
||||
|
||||
def vnffg_get(self, auth_attr, vnffg_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffg_get(vnffg_id)
|
||||
|
||||
def vnffg_delete_by_name(self, auth_attr, vnffg_name):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffg_delete(vnffg_name)
|
||||
|
||||
def vnffg_delete(self, auth_attr, vnffg_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffg_delete(vnffg_id)
|
||||
|
||||
def vnffg_check(self, auth_attr, vnffg_id):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.vnffg_check(vnffg_id)
|
||||
|
||||
def vnffg_update(self, auth_attr, vnffg_id, vnffg_dict):
|
||||
tacker_client = TackerClient(auth_attr)
|
||||
return tacker_client.ns_update(vnffg_id, vnffg_dict)
|
||||
|
||||
|
||||
class TackerClient(object):
|
||||
"""Tacker Client class for VNFM and NFVO negotiation"""
|
||||
|
||||
def __init__(self, auth_attr):
|
||||
auth = identity.Password(**auth_attr)
|
||||
sess = session.Session(auth=auth)
|
||||
self.client = tacker_client.Client(session=sess)
|
||||
|
||||
def nsd_create(self, nsd_dict):
|
||||
nsd_instance = self.client.create_nsd(body=nsd_dict)
|
||||
if nsd_instance:
|
||||
return nsd_instance['nsd']['id']
|
||||
else:
|
||||
return None
|
||||
|
||||
def nsd_get_by_name(self, nsd_name):
|
||||
nsd_dict = self.client.list_nsds()
|
||||
nsd_list = nsd_dict['nsds']
|
||||
nsd_dict = None
|
||||
for nsd in nsd_list:
|
||||
if nsd['name'] == nsd_name:
|
||||
nsd_dict = nsd
|
||||
return nsd_dict
|
||||
|
||||
def nsd_get(self, nsd_id):
|
||||
nsd_dict = self.client.show_nsd(nsd_id)
|
||||
return nsd_dict['nsd']
|
||||
|
||||
def ns_create(self, ns_dict):
|
||||
ns_instance = self.client.create_ns(body=ns_dict)
|
||||
if ns_instance:
|
||||
return ns_instance['ns']['id']
|
||||
else:
|
||||
return None
|
||||
|
||||
def ns_get_by_name(self, ns_name):
|
||||
ns_dict = self.client.list_nsds()
|
||||
ns_list = ns_dict['nss']
|
||||
ns_id = None
|
||||
for ns in ns_list:
|
||||
if ns['name'] == ns_name:
|
||||
ns_id = ns['id']
|
||||
return ns_id
|
||||
|
||||
def ns_get(self, ns_id):
|
||||
ns_instance = self.client.show_ns(ns_id)
|
||||
return ns_instance['ns']
|
||||
|
||||
def ns_delete_by_name(self, ns_name):
|
||||
ns_id = self.ns_get_by_name(ns_name)
|
||||
if ns_id:
|
||||
self.client.delete_ns(ns_id)
|
||||
|
||||
def ns_check(self, ns_id):
|
||||
ns_dict = self.client.list_nss()
|
||||
ns_list = ns_dict['nss']
|
||||
check = False
|
||||
for ns in ns_list:
|
||||
if ns['id'] == ns_id:
|
||||
check = True
|
||||
return check
|
||||
|
||||
def ns_delete(self, ns_id):
|
||||
return self.client.delete_ns(ns_id)
|
||||
|
||||
def ns_update(self, ns_id, ns_dict):
|
||||
return self.client.update_ns(ns_id, ns_dict)
|
||||
|
||||
def vnfd_create(self, vnfd_dict):
|
||||
vnfd_instance = self.client.create_vnfd(body=vnfd_dict)
|
||||
if vnfd_instance:
|
||||
return vnfd_instance['vnf']['id']
|
||||
else:
|
||||
return None
|
||||
|
||||
def vnf_create(self, vnf_dict):
|
||||
vnf_instance = self.client.create_vnf(body=vnf_dict)
|
||||
if vnf_instance:
|
||||
return vnf_instance['vnf']['id']
|
||||
else:
|
||||
return None
|
||||
|
||||
def vnf_get(self, vnf_id):
|
||||
vnf_instance = self.client.show_vnf(vnf_id)
|
||||
return vnf_instance['vnf']
|
||||
|
||||
def vnfd_get(self, vnfd_id):
|
||||
vnfd_instance = self.client.show_vnfd(vnfd_id)
|
||||
return vnfd_instance['vnfd']
|
||||
|
||||
def vnffgd_get_by_name(self, vnffgd_name):
|
||||
vnffgd_dict = self.client.list_vnffgds()
|
||||
vnffgd_list = vnffgd_dict['vnffgds']
|
||||
vnffgd_dict = None
|
||||
for vnffgd in vnffgd_list:
|
||||
if vnffgd['name'] == vnffgd_name:
|
||||
vnffgd_dict = vnffgd
|
||||
return vnffgd_dict
|
||||
|
||||
def vnffgd_get(self, vnffgd_id):
|
||||
vnffgd_instance = self.client.show_vnffgd(vnffgd_id)
|
||||
return vnffgd_instance['vnffgd']
|
||||
|
||||
def vnffg_create(self, vnffgd_dict):
|
||||
vnffg_instance = self.client.create_vnffg(body=vnffgd_dict)
|
||||
if vnffg_instance:
|
||||
return vnffg_instance['vnffg']['id']
|
||||
else:
|
||||
return None
|
||||
|
||||
def vnffg_get_by_name(self, vnffg_name):
|
||||
vnffg_dict = self.client.list_vnffgs()
|
||||
vnffg_list = vnffg_dict['vnffgs']
|
||||
vnffg_id = None
|
||||
for vnffg in vnffg_list:
|
||||
if vnffg['name'] == vnffg_name:
|
||||
vnffg_id = vnffg['id']
|
||||
return vnffg_id
|
||||
|
||||
def vnffg_get(self, vnffg_id):
|
||||
vnffg_instance = self.client.show_vnffg(vnffg_id)
|
||||
return vnffg_instance['vnffg']
|
||||
|
||||
def vnffg_delete_by_name(self, vnffg_name):
|
||||
vnffg_id = self.vnffg_get_by_name(vnffg_name)
|
||||
if vnffg_id:
|
||||
self.client.delete_vnffg(vnffg_id)
|
||||
|
||||
def vnffg_delete(self, vnffg_id):
|
||||
return self.client.delete_vnffg(vnffg_id)
|
||||
|
||||
def vnffg_check(self, vnffg_id):
|
||||
vnffg_dict = self.client.list_vnffgs()
|
||||
vnffg_list = vnffg_dict['vnffgs']
|
||||
check = False
|
||||
for vnffg in vnffg_list:
|
||||
if vnffg['id'] == vnffg_id:
|
||||
check = True
|
||||
return check
|
||||
|
||||
def vnffg_update(self, vnffg_id, vnffg_dict):
|
||||
return self.client.update_ns(vnffg_id, vnffg_dict)
|
||||
|
|
@ -0,0 +1,943 @@
|
|||
# Copyright 2016 Brocade Communications System, Inc.
|
||||
# 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 ast
|
||||
import copy
|
||||
import eventlet
|
||||
import random
|
||||
import time
|
||||
import yaml
|
||||
|
||||
from oslo_config import cfg
|
||||
from oslo_log import log as logging
|
||||
from oslo_utils import excutils
|
||||
from oslo_utils import uuidutils
|
||||
|
||||
|
||||
from apmec._i18n import _
|
||||
from apmec.common import driver_manager
|
||||
from apmec.common import log
|
||||
from apmec.common import utils
|
||||
from apmec.db.meso import meso_db
|
||||
from apmec.extensions import common_services as cs
|
||||
from apmec.extensions import meso
|
||||
from apmec import manager
|
||||
|
||||
from apmec.mem import vim_client
|
||||
from apmec.plugins.common import constants
|
||||
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
CONF = cfg.CONF
|
||||
NS_RETRIES = 30
|
||||
NS_RETRY_WAIT = 6
|
||||
MEC_RETRIES = 30
|
||||
MEC_RETRY_WAIT = 6
|
||||
VNFFG_RETRIES = 30
|
||||
VNFFG_RETRY_WAIT = 6
|
||||
|
||||
|
||||
def config_opts():
|
||||
return [('meso', MesoPlugin.OPTS)]
|
||||
|
||||
|
||||
NF_CAP_MAX = 3
|
||||
VNF_LIST = ['VNF1', 'VNF2', 'VNF2', 'VNF3', 'VNF4', 'VNF5', 'VNF6']
|
||||
VM_CAPA = dict()
|
||||
for vnf_name in VNF_LIST:
|
||||
VM_CAPA[vnf_name] = random.randint(1, NF_CAP_MAX)
|
||||
|
||||
|
||||
class MesoPlugin(meso_db.MESOPluginDb):
|
||||
"""MESO reference plugin for MESO extension
|
||||
|
||||
Implements the MESO extension and defines public facing APIs for VIM
|
||||
operations. MESO internally invokes the appropriate VIM driver in
|
||||
backend based on configured VIM types. Plugin also interacts with MEM
|
||||
extension for providing the specified VIM information
|
||||
"""
|
||||
supported_extension_aliases = ['meso']
|
||||
|
||||
OPTS = [
|
||||
cfg.ListOpt(
|
||||
'nfv_drivers', default=['tacker'],
|
||||
help=_('NFV drivers for launching NSs')),
|
||||
]
|
||||
cfg.CONF.register_opts(OPTS, 'meso')
|
||||
|
||||
def __init__(self):
|
||||
super(MesoPlugin, self).__init__()
|
||||
self._pool = eventlet.GreenPool()
|
||||
self._nfv_drivers = driver_manager.DriverManager(
|
||||
'apmec.meso.drivers',
|
||||
cfg.CONF.meso.nfv_drivers)
|
||||
self.vim_client = vim_client.VimClient()
|
||||
|
||||
def get_auth_dict(self, context):
|
||||
auth = CONF.keystone_authtoken
|
||||
return {
|
||||
'auth_url': auth.auth_url + '/v3',
|
||||
'token': context.auth_token,
|
||||
'project_domain_name': auth.project_domain_name or context.domain,
|
||||
'project_name': context.tenant_name
|
||||
}
|
||||
|
||||
def spawn_n(self, function, *args, **kwargs):
|
||||
self._pool.spawn_n(function, *args, **kwargs)
|
||||
|
||||
def _build_vim_auth(self, context, vim_info):
|
||||
LOG.debug('VIM id is %s', vim_info['id'])
|
||||
vim_auth = vim_info['auth_cred']
|
||||
vim_auth['password'] = self._decode_vim_auth(context,
|
||||
vim_info['id'],
|
||||
vim_auth)
|
||||
vim_auth['auth_url'] = vim_info['auth_url']
|
||||
|
||||
# These attributes are needless for authentication
|
||||
# from keystone, so we remove them.
|
||||
needless_attrs = ['key_type', 'secret_uuid']
|
||||
for attr in needless_attrs:
|
||||
if attr in vim_auth:
|
||||
vim_auth.pop(attr, None)
|
||||
return vim_auth
|
||||
|
||||
@log.log
|
||||
def create_mesd(self, context, mesd):
|
||||
mesd_data = mesd['mesd']
|
||||
template = mesd_data['attributes'].get('mesd')
|
||||
if isinstance(template, dict):
|
||||
mesd_data['attributes']['mesd'] = yaml.safe_dump(
|
||||
template)
|
||||
LOG.debug('mesd %s', mesd_data)
|
||||
|
||||
if 'template_source' in mesd_data:
|
||||
template_source = mesd_data.get('template_source')
|
||||
else:
|
||||
template_source = "onboarded"
|
||||
mesd['mesd']['template_source'] = template_source
|
||||
|
||||
self._parse_template_input(context, mesd)
|
||||
return super(MesoPlugin, self).create_mesd(
|
||||
context, mesd)
|
||||
|
||||
def _parse_template_input(self, context, mesd):
|
||||
mesd_dict = mesd['mesd']
|
||||
mesd_yaml = mesd_dict['attributes'].get('mesd')
|
||||
inner_mesd_dict = yaml.safe_load(mesd_yaml)
|
||||
mesd_dict['mesd_mapping'] = dict()
|
||||
LOG.debug('mesd_dict: %s', inner_mesd_dict)
|
||||
# From import we can deploy both NS and MEC Application
|
||||
nsd_imports = inner_mesd_dict['imports'].get('nsds')
|
||||
vnffg_imports = inner_mesd_dict['imports'].get('vnffgds')
|
||||
if nsd_imports:
|
||||
nsd_tpls = nsd_imports.get('nsd_templates')
|
||||
nfv_driver = nsd_imports.get('nfv_driver')
|
||||
if not nsd_tpls:
|
||||
raise meso.NSDNotFound(mesd_name=mesd_dict['name'])
|
||||
if nfv_driver.lower() not in\
|
||||
[driver.lower() for driver in constants.NFV_DRIVER]:
|
||||
raise meso.NFVDriverNotFound(mesd_name=mesd_dict['name'])
|
||||
if isinstance(nsd_tpls, list):
|
||||
mesd_dict['attributes']['nsds'] = '-'.join(nsd_tpls)
|
||||
mesd_dict['mesd_mapping']['NSD'] = nsd_tpls
|
||||
if vnffg_imports:
|
||||
vnffgd_tpls = vnffg_imports.get('vnffgd_templates')
|
||||
nfv_driver = vnffg_imports.get('nfv_driver')
|
||||
if not vnffgd_tpls:
|
||||
raise meso.VNFFGDNotFound(mesd_name=mesd_dict['name'])
|
||||
if nfv_driver.lower() not in \
|
||||
[driver.lower() for driver in constants.NFV_DRIVER]:
|
||||
raise meso.NFVDriverNotFound(mesd_name=mesd_dict['name'])
|
||||
if isinstance(vnffgd_tpls, list):
|
||||
mesd_dict['mesd_mapping']['VNFFGD'] = vnffgd_tpls
|
||||
mesd_dict['attributes']['vnffgds'] = '-'.join(vnffgd_tpls)
|
||||
|
||||
if ('description' not in mesd_dict or
|
||||
mesd_dict['description'] == ''):
|
||||
mesd_dict['description'] = inner_mesd_dict.get(
|
||||
'description', '')
|
||||
if (('name' not in mesd_dict or
|
||||
not len(mesd_dict['name'])) and
|
||||
'metadata' in inner_mesd_dict):
|
||||
mesd_dict['name'] = inner_mesd_dict['metadata'].get(
|
||||
'template_name', '')
|
||||
|
||||
LOG.debug('mesd %s', mesd)
|
||||
|
||||
def _get_mead_id(self, mead_name, onboarded_meads):
|
||||
for mead in onboarded_meads:
|
||||
if mead_name == mead['name']:
|
||||
return mead['id']
|
||||
|
||||
@log.log
|
||||
def create_mes(self, context, mes):
|
||||
"""Create MES and corresponding MEAs.
|
||||
|
||||
:param mes: mes dict which contains mesd_id and attributes
|
||||
This method has 2 steps:
|
||||
step-1: Call MEO API to create MEAs
|
||||
step-2: Call Tacker drivers to create NSs
|
||||
"""
|
||||
mes_info = mes['mes']
|
||||
name = mes_info['name']
|
||||
mes_info['mes_mapping'] = dict()
|
||||
|
||||
if mes_info.get('mesd_template'):
|
||||
mesd_name = utils.generate_resource_name(name, 'inline')
|
||||
mesd = {'mesd': {
|
||||
'attributes': {'mesd': mes_info['mesd_template']},
|
||||
'description': mes_info['description'],
|
||||
'name': mesd_name,
|
||||
'template_source': 'inline',
|
||||
'tenant_id': mes_info['tenant_id']}}
|
||||
mes_info['mesd_id'] = self.create_mesd(context, mesd).get('id')
|
||||
|
||||
mesd = self.get_mesd(context, mes['mes']['mesd_id'])
|
||||
mesd_dict = yaml.safe_load(mesd['attributes']['mesd'])
|
||||
meo_plugin = manager.ApmecManager.get_service_plugins()['MEO']
|
||||
|
||||
region_name = mes.setdefault('placement_attr', {}).get(
|
||||
'region_name', None)
|
||||
vim_res = self.vim_client.get_vim(context, mes['mes']['vim_id'],
|
||||
region_name)
|
||||
# driver_type = vim_res['vim_type']
|
||||
if not mes['mes']['vim_id']:
|
||||
mes['mes']['vim_id'] = vim_res['vim_id']
|
||||
|
||||
##########################################
|
||||
# Detect MANO driver here:
|
||||
# Defined in the Tosca template
|
||||
nfv_driver = None
|
||||
if mesd_dict['imports'].get('nsds'):
|
||||
nfv_driver = mesd_dict['imports']['nsds']['nfv_driver']
|
||||
nfv_driver = nfv_driver.lower()
|
||||
if mesd_dict['imports'].get('vnffgds'):
|
||||
nfv_driver = mesd_dict['imports']['vnffgds']['nfv_driver']
|
||||
nfv_driver = nfv_driver.lower()
|
||||
|
||||
##########################################
|
||||
def _find_vnf_ins(cd_mes):
|
||||
al_ns_id_list = cd_mes['mes_mapping'].get('NS')
|
||||
if not al_ns_id_list:
|
||||
return None, None
|
||||
al_ns_id = al_ns_id_list[0]
|
||||
try:
|
||||
ns_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_get',
|
||||
ns_id=al_ns_id,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
except Exception:
|
||||
return None, None
|
||||
if ns_instance['status'] != 'ACTIVE':
|
||||
return None, None
|
||||
al_vnf = ns_instance['vnf_ids']
|
||||
al_vnf_dict = ast.literal_eval(al_vnf)
|
||||
return ns_instance['id'], al_vnf_dict
|
||||
|
||||
def _run_meso_algorithm(req_vnf_list):
|
||||
is_accepted = False
|
||||
al_mes_list = self.get_mess(context)
|
||||
ns_candidate = dict()
|
||||
for al_mes in al_mes_list:
|
||||
ns_candidate[al_mes['id']] = dict()
|
||||
if al_mes['status'] != "ACTIVE":
|
||||
continue
|
||||
al_ns_id, al_vnf_dict = _find_vnf_ins(al_mes)
|
||||
if not al_ns_id:
|
||||
continue
|
||||
ns_candidate[al_mes['id']][al_ns_id] = dict()
|
||||
for req_vnf_dict in req_vnf_list:
|
||||
for vnf_name, al_vnf_id in al_vnf_dict.items():
|
||||
if req_vnf_dict['name'] == vnf_name:
|
||||
# Todo: remember to change this with VM capacity
|
||||
len_diff =\
|
||||
len([lend for lend in
|
||||
al_mes['reused'][vnf_name]
|
||||
if lend > 0])
|
||||
avail = len_diff - req_vnf_dict['nf_ins']
|
||||
ns_candidate[al_mes['id']][al_ns_id].\
|
||||
update({vnf_name: avail})
|
||||
|
||||
ns_cds = dict()
|
||||
deep_ns = dict()
|
||||
for mesid, ns_data_dict in ns_candidate.items():
|
||||
for nsid, resev_dict in ns_data_dict.items():
|
||||
if len(resev_dict) == len(req_vnf_list):
|
||||
nf_ins_list =\
|
||||
[nf_ins for nf_name, nf_ins in
|
||||
resev_dict.items() if nf_ins >= 0]
|
||||
if len(nf_ins_list) == len(req_vnf_list):
|
||||
total_ins = sum(nf_ins_list)
|
||||
ns_cds[mesid] = total_ins
|
||||
else:
|
||||
extra_nf_ins_list =\
|
||||
[-nf_ins for nf_name, nf_ins in
|
||||
resev_dict.items() if nf_ins < 0]
|
||||
total_ins = sum(extra_nf_ins_list)
|
||||
deep_ns[mesid] = total_ins
|
||||
if ns_cds:
|
||||
selected_mes1 = min(ns_cds, key=ns_cds.get)
|
||||
is_accepted = True
|
||||
return is_accepted, selected_mes1, None
|
||||
if deep_ns:
|
||||
selected_mes2 = min(deep_ns, key=deep_ns.get)
|
||||
is_accepted = True
|
||||
return is_accepted, selected_mes2, ns_candidate[selected_mes2]
|
||||
|
||||
return is_accepted, None, None
|
||||
|
||||
build_nsd_dict = dict()
|
||||
if mesd_dict['imports'].get('nsds'):
|
||||
# For framework evaluation
|
||||
nsd_template = mesd_dict['imports']['nsds']['nsd_templates']
|
||||
if isinstance(nsd_template, dict):
|
||||
if nsd_template.get('requirements'):
|
||||
req_nf_dict = nsd_template['requirements']
|
||||
req_nf_list = list()
|
||||
for vnf_dict in req_nf_dict:
|
||||
# Todo: make the requests more natural
|
||||
req_nf_list.append(
|
||||
{'name': vnf_dict['name'],
|
||||
'nf_ins': int(vnf_dict['vnfd_template'][5])})
|
||||
is_accepted, cd_mes_id, cd_vnf_dict =\
|
||||
_run_meso_algorithm(req_nf_list)
|
||||
if is_accepted:
|
||||
new_mesd_dict = dict()
|
||||
ref_mesd_dict = copy.deepcopy(mesd_dict)
|
||||
ref_mesd_dict['imports']['nsds']['nsd_templates']['requirements'] = \
|
||||
req_nf_list
|
||||
new_mesd_dict['mes'] = dict()
|
||||
new_mesd_dict['mes'] =\
|
||||
{'mesd_template': yaml.safe_dump(ref_mesd_dict)}
|
||||
self.update_mes(context, cd_mes_id, new_mesd_dict)
|
||||
return cd_mes_id
|
||||
else:
|
||||
# Create the inline NS with the following template
|
||||
import_list = list()
|
||||
node_dict = dict()
|
||||
for vnfd in req_nf_dict:
|
||||
import_list.append(vnfd['vnfd_template'])
|
||||
node = 'tosca.nodes.nfv.' + vnfd['name']
|
||||
node_dict[vnfd['name']] = {'type': node}
|
||||
build_nsd_dict['tosca_definitions_version'] =\
|
||||
'tosca_simple_profile_for_nfv_1_0_0'
|
||||
build_nsd_dict['description'] = mes_info['description']
|
||||
build_nsd_dict['imports'] = import_list
|
||||
build_nsd_dict['topology_template'] = dict()
|
||||
build_nsd_dict['topology_template']['node_templates'] =\
|
||||
node_dict
|
||||
|
||||
nsds = mesd['attributes'].get('nsds')
|
||||
mes_info['mes_mapping']['NS'] = list()
|
||||
if nsds:
|
||||
nsds_list = nsds.split('-')
|
||||
for nsd in nsds_list:
|
||||
ns_name = nsd + '-' + name + '-' + uuidutils.generate_uuid() # noqa
|
||||
nsd_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver,
|
||||
'nsd_get_by_name',
|
||||
nsd_name=nsd,
|
||||
auth_attr=vim_res['vim_auth'],)
|
||||
if nsd_instance:
|
||||
ns_arg = {'ns': {'nsd_id': nsd_instance['id'],
|
||||
'name': ns_name}}
|
||||
ns_id = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_create',
|
||||
ns_dict=ns_arg,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
mes_info['mes_mapping']['NS'].append(ns_id)
|
||||
if build_nsd_dict:
|
||||
ns_name = 'nsd' + name + '-' + uuidutils.generate_uuid()
|
||||
ns_arg = {'ns': {'nsd_template': build_nsd_dict,
|
||||
'name': ns_name,
|
||||
'description': mes_info['description'],
|
||||
'vim_id': '',
|
||||
'tenant_id': mes_info['tenant_id'],
|
||||
'attributes': {}}}
|
||||
ns_id = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_create',
|
||||
ns_dict=ns_arg,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
mes_info['mes_mapping']['NS'].append(ns_id)
|
||||
|
||||
vnffgds = mesd['attributes'].get('vnffgds')
|
||||
if mesd_dict['imports'].get('vnffgds'):
|
||||
vnffgds_list = vnffgds.split('-')
|
||||
mes_info['mes_mapping']['VNFFG'] = list()
|
||||
for vnffgd in vnffgds_list:
|
||||
vnffg_name = vnffgds + '-' + name + '-' + uuidutils.generate_uuid() # noqa
|
||||
vnffgd_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffgd_get_by_name',
|
||||
vnffgd_name=vnffgd,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
if vnffgd_instance:
|
||||
vnffg_arg = {'vnffg': {'vnffgd_id': vnffgd_instance['id'], 'name': vnffg_name}} # noqa
|
||||
vnffg_id = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffg_create',
|
||||
vnffg_dict=vnffg_arg,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
mes_info['mes_mapping']['VNFFG'].append(vnffg_id)
|
||||
|
||||
# meca_id = dict()
|
||||
# Create MEAs using MEO APIs
|
||||
try:
|
||||
meca_name = 'meca' + '-' + name + '-' + uuidutils.generate_uuid()
|
||||
# Separate the imports out from template
|
||||
mead_tpl_dict = dict()
|
||||
mead_tpl_dict['imports'] =\
|
||||
mesd_dict['imports']['meads']['mead_templates']
|
||||
mecad_dict = copy.deepcopy(mesd_dict)
|
||||
mecad_dict.pop('imports')
|
||||
mecad_dict.update(mead_tpl_dict)
|
||||
LOG.debug('mesd %s', mecad_dict)
|
||||
meca_arg = {'meca': {'mecad_template': mecad_dict, 'name': meca_name, # noqa
|
||||
'description': mes_info['description'],
|
||||
'tenant_id': mes_info['tenant_id'],
|
||||
'vim_id': mes_info['vim_id'],
|
||||
'attributes': {}}}
|
||||
meca_dict = meo_plugin.create_meca(context, meca_arg)
|
||||
mes_info['mes_mapping']['MECA'] = meca_dict['id']
|
||||
except Exception as e:
|
||||
LOG.error('Error while creating the MECAs: %s', e)
|
||||
# Call Tacker client driver
|
||||
|
||||
mes_dict = super(MesoPlugin, self).create_mes(context, mes)
|
||||
|
||||
def _create_mes_wait(self_obj, mes_id):
|
||||
args = dict()
|
||||
mes_status = "ACTIVE"
|
||||
ns_status = "PENDING_CREATE"
|
||||
vnffg_status = "PENDING_CREATE"
|
||||
mec_status = "PENDING_CREATE"
|
||||
ns_retries = NS_RETRIES
|
||||
mec_retries = MEC_RETRIES
|
||||
vnffg_retries = VNFFG_RETRIES
|
||||
mes_mapping = self.get_mes(context, mes_id)['mes_mapping']
|
||||
# Check MECA
|
||||
meca_id = mes_mapping['MECA']
|
||||
while mec_status == "PENDING_CREATE" and mec_retries > 0:
|
||||
time.sleep(MEC_RETRY_WAIT)
|
||||
mec_status = meo_plugin.get_meca(context, meca_id)['status']
|
||||
LOG.debug('status: %s', mec_status)
|
||||
if mec_status == 'ACTIVE' or mec_status == 'ERROR':
|
||||
break
|
||||
mec_retries = mec_retries - 1
|
||||
error_reason = None
|
||||
if mec_retries == 0 and mec_status == 'PENDING_CREATE':
|
||||
error_reason = _(
|
||||
"MES creation is not completed within"
|
||||
" {wait} seconds as creation of MECA").format(
|
||||
wait=MEC_RETRIES * MEC_RETRY_WAIT)
|
||||
# Check NS/VNFFG status
|
||||
if mes_mapping.get('NS'):
|
||||
ns_list = mes_mapping['NS']
|
||||
while ns_status == "PENDING_CREATE" and ns_retries > 0:
|
||||
time.sleep(NS_RETRY_WAIT)
|
||||
# Todo: support multiple NSs
|
||||
ns_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_get',
|
||||
ns_id=ns_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
ns_status = ns_instance['status']
|
||||
LOG.debug('status: %s', ns_status)
|
||||
if ns_status == 'ACTIVE' or ns_status == 'ERROR':
|
||||
break
|
||||
ns_retries = ns_retries - 1
|
||||
error_reason = None
|
||||
if ns_retries == 0 and ns_status == 'PENDING_CREATE':
|
||||
error_reason = _(
|
||||
"MES creation is not completed within"
|
||||
" {wait} seconds as creation of NS(s)").format(
|
||||
wait=NS_RETRIES * NS_RETRY_WAIT)
|
||||
|
||||
# Determine args
|
||||
ns_cd = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_get',
|
||||
ns_id=ns_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
ns_instance_dict = ns_cd['mgmt_urls']
|
||||
ns_instance_list = ast.literal_eval(ns_instance_dict)
|
||||
args['NS'] = dict()
|
||||
|
||||
for vnf_name, mgmt_url_list in ns_instance_list.items():
|
||||
# Todo: remember to change this with VM capacity
|
||||
vm_capacity = VM_CAPA[vnf_name]
|
||||
orig = [vm_capacity] * len(mgmt_url_list)
|
||||
args['NS'][vnf_name] = [(val - 1) for val in orig]
|
||||
|
||||
if mes_mapping.get('VNFFG'):
|
||||
while vnffg_status == "PENDING_CREATE" and vnffg_retries > 0:
|
||||
time.sleep(VNFFG_RETRY_WAIT)
|
||||
vnffg_list = mes_mapping['VNFFG']
|
||||
# Todo: support multiple VNFFGs
|
||||
vnffg_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffg_get',
|
||||
vnffg_id=vnffg_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
vnffg_status = vnffg_instance['status']
|
||||
LOG.debug('status: %s', vnffg_status)
|
||||
if vnffg_status == 'ACTIVE' or vnffg_status == 'ERROR':
|
||||
break
|
||||
vnffg_retries = vnffg_retries - 1
|
||||
error_reason = None
|
||||
if vnffg_retries == 0 and vnffg_status == 'PENDING_CREATE':
|
||||
error_reason = _(
|
||||
"MES creation is not completed within"
|
||||
" {wait} seconds as creation of VNFFG(s)").format(
|
||||
wait=VNFFG_RETRIES * VNFFG_RETRY_WAIT)
|
||||
if mec_status == "ERROR" or ns_status == "ERROR" or vnffg_status == "ERROR": # noqa
|
||||
mes_status = "ERROR"
|
||||
if error_reason:
|
||||
mes_status = "PENDING_CREATE"
|
||||
|
||||
super(MesoPlugin, self).create_mes_post(context, mes_id, mes_status, error_reason, args) # noqa
|
||||
self.spawn_n(_create_mes_wait, self, mes_dict['id'])
|
||||
return mes_dict
|
||||
|
||||
@log.log
|
||||
def _update_params(self, original, paramvalues):
|
||||
for key, value in (original).items():
|
||||
if not isinstance(value, dict) or 'get_input' not in str(value):
|
||||
pass
|
||||
elif isinstance(value, dict):
|
||||
if 'get_input' in value:
|
||||
if value['get_input'] in paramvalues:
|
||||
original[key] = paramvalues[value['get_input']]
|
||||
else:
|
||||
LOG.debug('Key missing Value: %s', key)
|
||||
raise cs.InputValuesMissing(key=key)
|
||||
else:
|
||||
self._update_params(value, paramvalues)
|
||||
|
||||
@log.log
|
||||
def _process_parameterized_input(self, attrs, mesd_dict):
|
||||
param_vattrs_dict = attrs.pop('param_values', None)
|
||||
if param_vattrs_dict:
|
||||
for node in \
|
||||
mesd_dict['topology_template']['node_templates'].values():
|
||||
if 'get_input' in str(node):
|
||||
self._update_params(node, param_vattrs_dict['mesd'])
|
||||
else:
|
||||
raise cs.ParamYAMLInputMissing()
|
||||
|
||||
@log.log
|
||||
def delete_mes(self, context, mes_id):
|
||||
mes = super(MesoPlugin, self).get_mes(context, mes_id)
|
||||
mesd = self.get_mesd(context, mes['mesd_id'])
|
||||
mesd_dict = yaml.safe_load(mesd['attributes']['mesd'])
|
||||
vim_res = self.vim_client.get_vim(context, mes['vim_id'])
|
||||
mes_mapping = mes['mes_mapping']
|
||||
meca_id = mes_mapping['MECA']
|
||||
meo_plugin = manager.ApmecManager.get_service_plugins()['MEO']
|
||||
try:
|
||||
meca_id = meo_plugin.delete_meca(context, meca_id)
|
||||
except Exception as e:
|
||||
LOG.error('Error while deleting the MECA(s): %s', e)
|
||||
|
||||
if mes_mapping.get('NS'):
|
||||
# Todo: support multiple NSs
|
||||
ns_id = mes_mapping['NS'][0]
|
||||
nfv_driver = None
|
||||
if mesd_dict['imports'].get('nsds'):
|
||||
nfv_driver = mesd_dict['imports']['nsds']['nfv_driver']
|
||||
nfv_driver = nfv_driver.lower()
|
||||
if not nfv_driver:
|
||||
raise meso.NFVDriverNotFound(mesd_name=mesd_dict['name'])
|
||||
try:
|
||||
self._nfv_drivers.invoke(
|
||||
nfv_driver,
|
||||
'ns_delete',
|
||||
ns_id=ns_id,
|
||||
auth_attr=vim_res['vim_auth'])
|
||||
except Exception as e:
|
||||
LOG.error('Error while deleting the NS(s): %s', e)
|
||||
if mes_mapping.get('VNFFG'):
|
||||
# Todo: support multiple VNFFGs
|
||||
vnffg_id = mes_mapping['VNFFG'][0]
|
||||
nfv_driver = None
|
||||
if mesd_dict['imports'].get('vnffgds'):
|
||||
nfv_driver = mesd_dict['imports']['vnffgds']['nfv_driver']
|
||||
nfv_driver = nfv_driver.lower()
|
||||
if not nfv_driver:
|
||||
raise meso.NFVDriverNotFound(mesd_name=mesd_dict['name'])
|
||||
try:
|
||||
self._nfv_drivers.invoke(
|
||||
nfv_driver,
|
||||
'vnffg_delete',
|
||||
vnffg_id=vnffg_id,
|
||||
auth_attr=vim_res['vim_auth'])
|
||||
except Exception as e:
|
||||
LOG.error('Error while deleting the VNFFG(s): %s', e)
|
||||
|
||||
super(MesoPlugin, self).delete_mes(context, mes_id)
|
||||
|
||||
def _delete_mes_wait(mes_id):
|
||||
ns_status = "PENDING_DELETE"
|
||||
vnffg_status = "PENDING_DELETE"
|
||||
mec_status = "PENDING_DELETE"
|
||||
ns_retries = NS_RETRIES
|
||||
mec_retries = MEC_RETRIES
|
||||
vnffg_retries = VNFFG_RETRIES
|
||||
error_reason_meca = None
|
||||
error_reason_ns = None
|
||||
error_reason_vnffg = None
|
||||
# Check MECA
|
||||
while mec_status == "PENDING_DELETE" and mec_retries > 0:
|
||||
time.sleep(MEC_RETRY_WAIT)
|
||||
meca_id = mes_mapping['MECA']
|
||||
meca_list = meo_plugin.get_mecas(context)
|
||||
is_deleted = True
|
||||
for meca in meca_list:
|
||||
if meca_id in meca['id']:
|
||||
is_deleted = False
|
||||
if is_deleted:
|
||||
break
|
||||
mec_status = meo_plugin.get_meca(context, meca_id)['status']
|
||||
LOG.debug('status: %s', mec_status)
|
||||
if mec_status == 'ERROR':
|
||||
break
|
||||
mec_retries = mec_retries - 1
|
||||
if mec_retries == 0 and mec_status == 'PENDING_DELETE':
|
||||
error_reason_meca = _(
|
||||
"MES deletion is not completed within"
|
||||
" {wait} seconds as deletion of MECA").format(
|
||||
wait=MEC_RETRIES * MEC_RETRY_WAIT)
|
||||
# Check NS/VNFFG status
|
||||
if mes_mapping.get('NS'):
|
||||
while ns_status == "PENDING_DELETE" and ns_retries > 0:
|
||||
time.sleep(NS_RETRY_WAIT)
|
||||
ns_list = mes_mapping['NS']
|
||||
# Todo: support multiple NSs
|
||||
is_existed = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_check',
|
||||
ns_id=ns_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
if not is_existed:
|
||||
break
|
||||
ns_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_get',
|
||||
ns_id=ns_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
ns_status = ns_instance['status']
|
||||
LOG.debug('status: %s', ns_status)
|
||||
if ns_status == 'ERROR':
|
||||
break
|
||||
ns_retries = ns_retries - 1
|
||||
if ns_retries == 0 and ns_status == 'PENDING_DELETE':
|
||||
error_reason_ns = _(
|
||||
"MES deletion is not completed within"
|
||||
" {wait} seconds as deletion of NS(s)").format(
|
||||
wait=NS_RETRIES * NS_RETRY_WAIT)
|
||||
if mes_mapping.get('VNFFG'):
|
||||
while vnffg_status == "PENDING_DELETE" and vnffg_retries > 0:
|
||||
time.sleep(VNFFG_RETRY_WAIT)
|
||||
vnffg_list = mes_mapping['VNFFG']
|
||||
# Todo: support multiple VNFFGs
|
||||
is_existed = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffg_check',
|
||||
vnffg_id=vnffg_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
if not is_existed:
|
||||
break
|
||||
vnffg_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffg_get',
|
||||
vnffg_id=vnffg_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
vnffg_status = vnffg_instance['status']
|
||||
LOG.debug('status: %s', vnffg_status)
|
||||
if vnffg_status == 'ERROR':
|
||||
break
|
||||
vnffg_retries = vnffg_retries - 1
|
||||
if vnffg_retries == 0 and vnffg_status == 'PENDING_DELETE':
|
||||
error_reason_vnffg = _(
|
||||
"MES deletion is not completed within"
|
||||
" {wait} seconds as deletion of VNFFG(s)").format(
|
||||
wait=VNFFG_RETRIES * VNFFG_RETRY_WAIT)
|
||||
error = False
|
||||
if mec_status == "ERROR" or ns_status == "ERROR" or vnffg_status == "ERROR": # noqa
|
||||
error = True
|
||||
error_reason = None
|
||||
for reason in [error_reason_meca, error_reason_ns, error_reason_vnffg]: # noqa
|
||||
error_reason = reason if reason else None
|
||||
|
||||
super(MesoPlugin, self).delete_mes_post(
|
||||
context, mes_id, error_reason=error_reason, error=error)
|
||||
self.spawn_n(_delete_mes_wait, mes['id'])
|
||||
return mes['id']
|
||||
|
||||
def update_mes(self, context, mes_id, mes):
|
||||
args = dict()
|
||||
mes_info = mes['mes']
|
||||
old_mes = super(MesoPlugin, self).get_mes(context, mes_id)
|
||||
name = old_mes['name']
|
||||
lftover = dict()
|
||||
# vm_capacity = 3
|
||||
# create inline mesd if given by user
|
||||
|
||||
def _update_nsd_template(req_mesd_dict):
|
||||
build_nsd_dict = dict()
|
||||
if req_mesd_dict['imports'].get('nsds'):
|
||||
args['NS'] = dict()
|
||||
# Todo: Support multiple NSs
|
||||
# For framework evaluation
|
||||
nsd_templates = req_mesd_dict['imports']['nsds']['nsd_templates'] # noqa
|
||||
if isinstance(nsd_templates, dict):
|
||||
if nsd_templates.get('requirements'):
|
||||
old_reused = old_mes['reused']
|
||||
vnf_mapping_list = nsd_templates['requirements']
|
||||
for vnf_mapping_dict in vnf_mapping_list:
|
||||
for old_vnf_name, old_nfins_list in old_reused.items(): # noqa
|
||||
if vnf_mapping_dict['name'] == old_vnf_name:
|
||||
len_diff = len([lend for lend in old_nfins_list if lend > 0]) # noqa
|
||||
diff = len_diff - vnf_mapping_dict['nf_ins'] # noqa
|
||||
if diff < 0:
|
||||
lftover.update({old_vnf_name: -diff})
|
||||
vm_capacity = VM_CAPA[old_vnf_name]
|
||||
old_reused[old_vnf_name].extend([vm_capacity] * (-diff)) # noqa
|
||||
# old_reused[old_vnf_name] = diff
|
||||
temp = vnf_mapping_dict['nf_ins']
|
||||
for index, nfins in enumerate(old_nfins_list): # noqa
|
||||
if nfins > 0:
|
||||
old_nfins_list[index] = old_nfins_list[index] - 1 # noqa
|
||||
temp = temp - 1
|
||||
if temp == 0:
|
||||
break
|
||||
|
||||
formal_req = list()
|
||||
for nf_name, nf_ins in lftover.items():
|
||||
vnfd_name = 'vnfd' + nf_name[3] + str(nf_ins)
|
||||
formal_req.append(vnfd_name)
|
||||
|
||||
if formal_req:
|
||||
build_nsd_dict['tosca_definitions_version'] = 'tosca_simple_profile_for_nfv_1_0_0' # noqa
|
||||
build_nsd_dict['description'] = old_mes['description']
|
||||
build_nsd_dict['imports'] = formal_req
|
||||
build_nsd_dict['topology_template'] = dict()
|
||||
build_nsd_dict['topology_template']['node_templates'] = dict() # noqa
|
||||
for nf_name, nf_ins in lftover.items():
|
||||
node = 'tosca.nodes.nfv.' + nf_name
|
||||
node_dict = dict()
|
||||
node_dict['type'] = node
|
||||
build_nsd_dict['topology_template']['node_templates'].update({nf_name: node_dict}) # noqa
|
||||
return build_nsd_dict
|
||||
|
||||
if mes_info.get('mesd_template'):
|
||||
# Build vnf_dict here
|
||||
mes_name = utils.generate_resource_name(name, 'inline')
|
||||
mesd = {'mesd': {'tenant_id': old_mes['tenant_id'],
|
||||
'name': mes_name,
|
||||
'attributes': {
|
||||
'mesd': mes_info['mesd_template']},
|
||||
'template_source': 'inline',
|
||||
'description': old_mes['description']}}
|
||||
try:
|
||||
mes_info['mesd_id'] = \
|
||||
self.create_mesd(context, mesd).get('id')
|
||||
except Exception:
|
||||
with excutils.save_and_reraise_exception():
|
||||
super(MesoPlugin, self)._update_mes_status(context, mes_id, constants.ACTIVE) # noqa
|
||||
|
||||
mesd = self.get_mesd(context, mes_info['mesd_id'])
|
||||
mesd_dict = yaml.safe_load(mesd['attributes']['mesd'])
|
||||
new_mesd_mapping = mesd['mesd_mapping']
|
||||
region_name = mes.setdefault('placement_attr', {}).get(
|
||||
'region_name', None)
|
||||
vim_res = self.vim_client.get_vim(context, old_mes['vim_id'],
|
||||
region_name)
|
||||
|
||||
if mesd_dict['imports'].get('meads'):
|
||||
# Update MECA
|
||||
meo_plugin = manager.ApmecManager.get_service_plugins()['MEO']
|
||||
# Build the MECA template here
|
||||
mead_tpl_dict = dict()
|
||||
mead_tpl_dict['imports'] =\
|
||||
mesd_dict['imports']['meads']['mead_templates']
|
||||
mecad_dict = copy.deepcopy(mesd_dict)
|
||||
mecad_dict.pop('imports')
|
||||
mecad_dict.update(mead_tpl_dict)
|
||||
mecad_arg = {'meca': {'mecad_template': mecad_dict}}
|
||||
old_meca_id = old_mes['mes_mapping']['MECA']
|
||||
meca_id = meo_plugin.update_meca(context, old_meca_id, mecad_arg) # noqa
|
||||
|
||||
if mesd_dict['imports'].get('nsds'):
|
||||
nfv_driver = None
|
||||
nfv_driver = mesd_dict['imports']['nsds'].get('nfv_driver')
|
||||
if not nfv_driver:
|
||||
raise meso.NFVDriverNotFound(mesd_name=mesd_dict['name'])
|
||||
nfv_driver = nfv_driver.lower()
|
||||
|
||||
req_mesd_dict = yaml.safe_load(mes_info['mesd_template'])
|
||||
new_nsd_template = _update_nsd_template(req_mesd_dict)
|
||||
nsd_template = None
|
||||
if isinstance(new_mesd_mapping.get('NSD'), list):
|
||||
nsd_name = new_mesd_mapping['NSD'][0]
|
||||
nsd_dict = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'nsd_get_by_name',
|
||||
nsd_name=nsd_name,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
nsd_template = yaml.safe_load(nsd_dict['attributes']['nsd'])
|
||||
actual_nsd_template = new_nsd_template if new_nsd_template else nsd_template # noqa
|
||||
if actual_nsd_template:
|
||||
old_ns_id = old_mes['mes_mapping']['NS'][0]
|
||||
ns_arg = {'ns': {'nsd_template': actual_nsd_template}}
|
||||
self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_update',
|
||||
ns_id=old_ns_id,
|
||||
ns_dict=ns_arg,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
|
||||
if mesd_dict['imports'].get('vnffgds'):
|
||||
# Todo: Support multiple VNFFGs
|
||||
nfv_driver = None
|
||||
nfv_driver = mesd_dict['imports']['nsds'].get('nfv_driver')
|
||||
if not nfv_driver:
|
||||
raise meso.NFVDriverNotFound(mesd_name=mesd_dict['name'])
|
||||
nfv_driver = nfv_driver.lower()
|
||||
vnffgd_name = new_mesd_mapping['VNFFGD'][0]
|
||||
vnffgd_dict = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffgd_get_by_name',
|
||||
vnffgd_name=vnffgd_name,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
vnffgd_template = yaml.safe_load(
|
||||
vnffgd_dict['attributes']['vnffgd'])
|
||||
old_vnffg_id = old_mes['mes_mapping']['VNFFG'][0]
|
||||
vnffg_arg = {'vnffg': {'vnffgd_template': vnffgd_template}}
|
||||
self._nfv_drivers.invoke(
|
||||
nfv_driver,
|
||||
'vnffg_update',
|
||||
vnffg_id=old_vnffg_id,
|
||||
vnffg_dict=vnffg_arg,
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
|
||||
mes_dict = super(MesoPlugin, self)._update_mes_pre(context, mes_id)
|
||||
|
||||
def _update_mes_wait(self_obj, mes_id):
|
||||
args = dict()
|
||||
mes_status = "ACTIVE"
|
||||
ns_status = "PENDING_UPDATE"
|
||||
vnffg_status = "PENDING_UPDATE"
|
||||
mec_status = "PENDING_UPDATE"
|
||||
ns_retries = NS_RETRIES
|
||||
mec_retries = MEC_RETRIES
|
||||
vnffg_retries = VNFFG_RETRIES
|
||||
error_reason_meca = None
|
||||
error_reason_ns = None
|
||||
error_reason_vnffg = None
|
||||
# Check MECA
|
||||
if mesd_dict['imports'].get('meads'):
|
||||
while mec_status == "PENDING_UPDATE" and mec_retries > 0:
|
||||
time.sleep(MEC_RETRY_WAIT)
|
||||
meca_id = old_mes['mes_mapping']['MECA']
|
||||
meca_list = meo_plugin.get_mecas(context)
|
||||
is_deleted = True
|
||||
for meca in meca_list:
|
||||
if meca_id in meca['id']:
|
||||
is_deleted = False
|
||||
if is_deleted:
|
||||
break
|
||||
mec_status = meo_plugin.get_meca(context, meca_id)['status'] # noqa
|
||||
LOG.debug('status: %s', mec_status)
|
||||
if mec_status == 'ERROR':
|
||||
break
|
||||
mec_retries = mec_retries - 1
|
||||
if mec_retries == 0 and mec_status == 'PENDING_UPDATE':
|
||||
error_reason_meca = _(
|
||||
"MES update is not completed within"
|
||||
" {wait} seconds as update of MECA").format(
|
||||
wait=MEC_RETRIES * MEC_RETRY_WAIT)
|
||||
# Check NS/VNFFG status
|
||||
if mesd_dict['imports'].get('nsds'):
|
||||
while ns_status == "PENDING_UPDATE" and ns_retries > 0:
|
||||
time.sleep(NS_RETRY_WAIT)
|
||||
ns_list = old_mes['mes_mapping']['NS']
|
||||
# Todo: support multiple NSs
|
||||
is_existed = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_check',
|
||||
ns_id=ns_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
if not is_existed:
|
||||
break
|
||||
ns_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'ns_get',
|
||||
ns_id=ns_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
ns_status = ns_instance['status']
|
||||
LOG.debug('status: %s', ns_status)
|
||||
if ns_status == 'ERROR':
|
||||
break
|
||||
ns_retries = ns_retries - 1
|
||||
if ns_retries == 0 and ns_status == 'PENDING_UPDATE':
|
||||
error_reason_ns = _(
|
||||
"MES update is not completed within"
|
||||
" {wait} seconds as update of NS(s)").format(
|
||||
wait=NS_RETRIES * NS_RETRY_WAIT)
|
||||
|
||||
if mesd_dict['imports'].get('vnffgds'):
|
||||
while vnffg_status == "PENDING_UPDATE" and vnffg_retries > 0:
|
||||
time.sleep(VNFFG_RETRY_WAIT)
|
||||
vnffg_list = old_mes['mes_mapping']['VNFFG']
|
||||
# Todo: support multiple VNFFGs
|
||||
is_existed = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffg_check',
|
||||
vnffg_id=vnffg_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
if not is_existed:
|
||||
break
|
||||
vnffg_instance = self._nfv_drivers.invoke(
|
||||
nfv_driver, # How to tell it is Tacker
|
||||
'vnffg_get',
|
||||
vnffg_id=vnffg_list[0],
|
||||
auth_attr=vim_res['vim_auth'], )
|
||||
vnffg_status = vnffg_instance['status']
|
||||
LOG.debug('status: %s', vnffg_status)
|
||||
if vnffg_status == 'ERROR':
|
||||
break
|
||||
vnffg_retries = vnffg_retries - 1
|
||||
if vnffg_retries == 0 and vnffg_status == 'PENDING_UPDATE':
|
||||
error_reason_vnffg = _(
|
||||
"MES update is not completed within"
|
||||
" {wait} seconds as update of VNFFG(s)").format(
|
||||
wait=VNFFG_RETRIES * VNFFG_RETRY_WAIT)
|
||||
args['NS'] = old_mes['reused']
|
||||
if mec_status == "ERROR" or ns_status == "ERROR" or vnffg_status == "ERROR": # noqa
|
||||
mes_status = "ERROR"
|
||||
error_reason = None
|
||||
for reason in [error_reason_meca, error_reason_ns, error_reason_vnffg]: # noqa
|
||||
if reason:
|
||||
error_reason = reason
|
||||
mes_status = "PENDING_UPDATE"
|
||||
super(MesoPlugin, self)._update_mes_post(context, mes_id, error_reason, mes_status, args) # noqa
|
||||
|
||||
self.spawn_n(_update_mes_wait, self, mes_dict['id'])
|
||||
return mes_dict
|
||||
|
|
@ -4,6 +4,8 @@ wrap_width = 79
|
|||
namespace = apmec.common.config
|
||||
namespace = apmec.wsgi
|
||||
namespace = apmec.service
|
||||
namespace = apmec.meso.meso_plugin
|
||||
namespace = apmec.meso.drivers.nfv_drivers.tacker_driver
|
||||
namespace = apmec.meo.meo_plugin
|
||||
namespace = apmec.meo.drivers.vim.openstack_driver
|
||||
namespace = apmec.keymgr
|
||||
|
|
@ -24,4 +26,4 @@ namespace = oslo.messaging
|
|||
namespace = oslo.db
|
||||
namespace = oslo.log
|
||||
namespace = oslo.policy
|
||||
namespace = oslo.service.service
|
||||
namespace = oslo.service.service
|
||||
|
|
@ -44,7 +44,10 @@ apmec.service_plugins =
|
|||
dummy = apmec.tests.unit.dummy_plugin:DummyServicePlugin
|
||||
mem = apmec.mem.plugin:MEMPlugin
|
||||
meo = apmec.meo.meo_plugin:MeoPlugin
|
||||
meso = apmec.meso.meso_plugin:MesoPlugin
|
||||
commonservices = apmec.plugins.common_services.common_services_plugin:CommonServicesPlugin
|
||||
apmec.meso.drivers =
|
||||
tacker = apmec.meso.drivers.nfv_drivers.tacker_driver:Tacker_Driver
|
||||
apmec.meo.vim.drivers =
|
||||
openstack = apmec.meo.drivers.vim.openstack_driver:OpenStack_Driver
|
||||
apmec.openstack.common.cache.backends =
|
||||
|
|
@ -71,6 +74,8 @@ oslo.config.opts =
|
|||
apmec.service = apmec.service:config_opts
|
||||
apmec.meo.meo_plugin = apmec.meo.meo_plugin:config_opts
|
||||
apmec.meo.drivers.vim.openstack_driver = apmec.meo.drivers.vim.openstack_driver:config_opts
|
||||
apmec.meso.meso_plugin = apmec.meso.meso_plugin:config_opts
|
||||
apmec.mseo.drivers.nfv_drivers.tacker_driver = apmec.meso.drivers.nfv_drivers.tacker_driver:config_opts
|
||||
apmec.keymgr = apmec.keymgr:config_opts
|
||||
apmec.mem.monitor = apmec.mem.monitor:config_opts
|
||||
apmec.mem.plugin = apmec.mem.plugin:config_opts
|
||||
|
|
|
|||
Loading…
Reference in New Issue