165 lines
6.5 KiB
Python
165 lines
6.5 KiB
Python
# Copyright 2017 Intel Corporation.
|
|
#
|
|
# 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 oslo_log import log as logging
|
|
from oslo_utils import uuidutils
|
|
|
|
from neutron_lib.db import api as db_api
|
|
|
|
from neutron.db import common_db_mixin
|
|
from neutron.objects import base as base_obj
|
|
|
|
from neutron_classifier.common import exceptions
|
|
from neutron_classifier.common import validators
|
|
from neutron_classifier.objects import classifications
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class TrafficClassificationGroupPlugin(common_db_mixin.CommonDbMixin):
|
|
|
|
def __init__(self):
|
|
super(TrafficClassificationGroupPlugin, self).__init__()
|
|
|
|
def create_classification_group(self, context, classification_group):
|
|
details = classification_group['classification_group']
|
|
c_flag = cg_flag = False
|
|
|
|
if 'classification' in details:
|
|
c_flag = True
|
|
validators.check_valid_classifications(context,
|
|
details['classification'])
|
|
|
|
if 'classification_group' in details:
|
|
cg_flag = True
|
|
validators.check_valid_classification_groups(
|
|
context, details['classification_group'])
|
|
details['id'] = uuidutils.generate_uuid()
|
|
mappings = {'c_ids': details['classification'] if c_flag else [],
|
|
'cg_ids': details['classification_group']
|
|
if cg_flag else []}
|
|
db_dict = details
|
|
if 'tenant_id' in details:
|
|
del details['tenant_id']
|
|
cg = classifications.ClassificationGroup(context, **details)
|
|
|
|
with db_api.CONTEXT_WRITER.using(context):
|
|
cg.create()
|
|
db_dict['id'] = cg.id
|
|
|
|
with db_api.CONTEXT_WRITER.using(context):
|
|
if c_flag:
|
|
for cl in mappings['c_ids']:
|
|
cg_c_mapping = classifications.CGToClassificationMapping(
|
|
context,
|
|
container_cg_id=cg.id,
|
|
stored_classification_id=cl)
|
|
cg_c_mapping.create()
|
|
if cg_flag:
|
|
for cg_id in mappings['cg_ids']:
|
|
cg_cg_mapping =\
|
|
classifications.CGToClassificationGroupMapping(
|
|
context,
|
|
container_cg_id=cg.id,
|
|
stored_cg_id=cg_id
|
|
)
|
|
cg_cg_mapping.create()
|
|
db_dict['classification'] = details['classification']\
|
|
if c_flag else []
|
|
db_dict['classification_group'] = details['classification_group']\
|
|
if cg_flag else []
|
|
|
|
return db_dict
|
|
|
|
def delete_classification_group(self, context, classification_group_id):
|
|
if validators.check_can_delete_classification_group(
|
|
context, classification_group_id):
|
|
cg = classifications.ClassificationGroup.get_object(
|
|
context, id=classification_group_id)
|
|
with db_api.CONTEXT_WRITER.using(context):
|
|
cg.delete()
|
|
|
|
def update_classification_group(self, context, classification_group_id,
|
|
fields_to_update):
|
|
fields_to_update = fields_to_update['classification_group']
|
|
field_keys = list(fields_to_update.keys())
|
|
valid_keys = ['name', 'description']
|
|
for key in field_keys:
|
|
if key not in valid_keys:
|
|
raise exceptions.InvalidUpdateRequest()
|
|
with db_api.CONTEXT_WRITER.using(context):
|
|
cg = classifications.ClassificationGroup.update_object(
|
|
context, fields_to_update, id=classification_group_id)
|
|
db_dict = self._make_db_dict(cg)
|
|
return db_dict
|
|
|
|
def _make_db_dict(self, obj):
|
|
db_dict = {'classification_group': {}}
|
|
for key in obj.fields.keys():
|
|
db_dict['classification_group'][key] = obj[key]
|
|
return db_dict
|
|
|
|
def _make_db_dicts(self, cgs):
|
|
db_dict = []
|
|
for cg in cgs:
|
|
cg_dict = self._make_db_dict(cg)
|
|
db_dict.append(cg_dict)
|
|
return db_dict
|
|
|
|
def _make_c_dict(self, c_obj):
|
|
c_dict = {'id': c_obj['id'],
|
|
'name': c_obj['name'],
|
|
'project_id': c_obj['project_id'],
|
|
'description': c_obj['description'],
|
|
'c_type': c_obj['c_type'],
|
|
'negated': c_obj['negated'],
|
|
'shared': c_obj['shared']}
|
|
return c_dict
|
|
|
|
def _make_c_dicts(self, c_objs):
|
|
if not c_objs:
|
|
return []
|
|
ret_list = []
|
|
|
|
for clas in c_objs:
|
|
db_dict = self._make_c_dict(clas)
|
|
db_dict['id'] = clas.get('id', None)
|
|
ret_list.append(db_dict)
|
|
return ret_list
|
|
|
|
def get_classification_group(self, context, classification_group_id,
|
|
fields=None):
|
|
with db_api.CONTEXT_WRITER.using(context):
|
|
cg = classifications.ClassificationGroup.get_object(
|
|
context, id=classification_group_id)
|
|
db_dict = self._make_db_dict(cg)
|
|
mapped_cs = classifications._get_mapped_classifications(context,
|
|
cg)
|
|
mapped_cgs = classifications._get_mapped_classification_groups(
|
|
context, cg)
|
|
c_dict = self._make_c_dicts(mapped_cs)
|
|
cg_dict = self._make_db_dicts(mapped_cgs)
|
|
db_dict['classification_group']['classifications'] = c_dict
|
|
db_dict['classification_group']['classification_groups'] = cg_dict
|
|
return db_dict
|
|
|
|
def get_classification_groups(self, context, sorts=None, limit=None,
|
|
marker=None, page_reverse=False,
|
|
filters=None, fields=None):
|
|
pager = base_obj.Pager(sorts, limit, page_reverse, marker)
|
|
cgs = classifications.ClassificationGroup.get_objects(context,
|
|
_pager=pager)
|
|
db_dict = self._make_db_dicts(cgs)
|
|
return db_dict
|