# ============LICENSE_START===================================================
-# Copyright (C) 2019-2020 Nordix Foundation.
+# Copyright (C) 2020-2021 Nordix Foundation.
# ============================================================================
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# SPDX-License-Identifier: Apache-2.0
# ============LICENSE_END=====================================================
-from sqlalchemy import Column, Integer, String, ForeignKey
+from sqlalchemy import Column, Integer, String, ForeignKey, JSON
from sqlalchemy.orm import relationship
from mod import db
class SubscriptionModel(db.Model):
__tablename__ = 'subscriptions'
id = Column(Integer, primary_key=True, autoincrement=True)
- subscription_name = Column(String(100), unique=True)
+ subscription_name = Column(String(100), unique=True, nullable=False)
status = Column(String(20))
nfs = relationship(
cascade='all, delete-orphan',
backref='subscription')
+ network_filter = relationship(
+ 'NetworkFunctionFilterModel',
+ cascade='all, delete-orphan',
+ backref='subscription')
+
+ measurement_groups = relationship(
+ 'MeasurementGroupModel',
+ cascade='all, delete-orphan',
+ backref='subscription')
+
def __init__(self, subscription_name, status):
self.subscription_name = subscription_name
self.status = status
__tablename__ = 'network_functions'
id = Column(Integer, primary_key=True, autoincrement=True)
nf_name = Column(String(100), unique=True)
- ip_address = Column(String(50))
+ ipv4_address = Column(String(50))
+ ipv6_address = Column(String(50))
model_invariant_id = Column(String(100))
model_version_id = Column(String(100))
model_name = Column(String(100))
cascade='all, delete-orphan',
backref='nf')
- def __init__(self, nf_name, ip_address, model_invariant_id,
+ def __init__(self, nf_name, ipv4_address, ipv6_address, model_invariant_id,
model_version_id, model_name, sdnc_model_name,
sdnc_model_version, retry_count=0):
self.nf_name = nf_name
- self.ip_address = ip_address
+ self.ipv4_address = ipv4_address
+ self.ipv6_address = ipv6_address
self.model_invariant_id = model_invariant_id
self.model_version_id = model_version_id
self.model_name = model_name
return NetworkFunction(sdnc_model_name=self.sdnc_model_name,
sdnc_model_version=self.sdnc_model_version,
**{'nf_name': self.nf_name,
- 'ip_address': self.ip_address,
+ 'ipv4_address': self.ipv4_address,
+ 'ipv6_address': self.ipv6_address,
'model_invariant_id': self.model_invariant_id,
'model_version_id': self.model_version_id})
NetworkFunctionModel.nf_name == self.nf_name).one_or_none()
db.session.remove()
return {'nf_name': self.nf_name,
- 'ip_address': nf.ip_address,
+ 'ipv4_address': nf.ipv4_address,
+ 'ipv6_address': nf.ipv6_address,
'nf_sub_status': self.nf_sub_status,
'model_invariant_id': nf.model_invariant_id,
'model_version_id': nf.model_version_id,
'model_name': nf.model_name,
'sdnc_model_name': nf.sdnc_model_name,
'sdnc_model_version': nf.sdnc_model_version}
+
+
+class NetworkFunctionFilterModel(db.Model):
+ __tablename__ = 'nf_filter'
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ subscription_name = Column(
+ String,
+ ForeignKey(SubscriptionModel.subscription_name, ondelete='cascade', onupdate='cascade'),
+ unique=True
+ )
+ nf_names = Column(String(100))
+ model_invariant_ids = Column(String(100))
+ model_version_ids = Column(String(100))
+ model_names = Column(String(100))
+
+ def __init__(self, subscription_name, nf_names, model_invariant_ids, model_version_ids,
+ model_names):
+ self.subscription_name = subscription_name
+ self.nf_names = nf_names
+ self.model_invariant_ids = model_invariant_ids
+ self.model_version_ids = model_version_ids
+ self.model_names = model_names
+
+ def __repr__(self):
+ return f'subscription_name: {self.subscription_name}, ' \
+ f'nf_names: {self.nf_names}, model_invariant_ids: {self.model_invariant_ids}' \
+ f'model_version_ids: {self.model_version_ids}, model_names: {self.model_names}'
+
+ def serialize(self):
+ return {'subscription_name': self.subscription_name, 'nf_names': self.nf_names,
+ 'model_invariant_ids': self.model_invariant_ids,
+ 'model_version_ids': self.model_version_ids, 'model_names': self.model_names}
+
+
+class MeasurementGroupModel(db.Model):
+ __tablename__ = 'measurement_group'
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ subscription_name = Column(
+ String,
+ ForeignKey(SubscriptionModel.subscription_name, ondelete='cascade', onupdate='cascade')
+ )
+ measurement_group_name = Column(String(100), unique=True)
+ administrative_state = Column(String(20))
+ file_based_gp = Column(Integer)
+ file_location = Column(String(100))
+ measurement_type = Column(JSON)
+ managed_object_dns_basic = Column(JSON)
+
+ def __init__(self, subscription_name, measurement_group_name,
+ administrative_state, file_based_gp, file_location,
+ measurement_type, managed_object_dns_basic):
+ self.subscription_name = subscription_name
+ self.measurement_group_name = measurement_group_name
+ self.administrative_state = administrative_state
+ self.file_based_gp = file_based_gp
+ self.file_location = file_location
+ self.measurement_type = measurement_type
+ self.managed_object_dns_basic = managed_object_dns_basic
+
+ def __repr__(self):
+ return f'subscription_name: {self.subscription_name}, ' \
+ f'measurement_group_name: {self.measurement_group_name},' \
+ f'administrative_state: {self.administrative_state},' \
+ f'file_based_gp: {self.file_based_gp},' \
+ f'file_location: {self.file_location},' \
+ f'measurement_type: {self.measurement_type}' \
+ f'managed_object_dns_basic: {self.managed_object_dns_basic}'
+
+ def serialize(self):
+ return {'subscription_name': self.subscription_name,
+ 'measurement_group_name': self.measurement_group_name,
+ 'administrative_state': self.administrative_state,
+ 'file_based_gp': self.file_based_gp,
+ 'file_location': self.file_location,
+ 'measurement_type': self.measurement_type,
+ 'managed_object_dns_basic': self.managed_object_dns_basic}
+
+
+class NfMeasureGroupRelationalModel(db.Model):
+ __tablename__ = 'nf_to_measure_grp_rel'
+ __mapper_args__ = {
+ 'confirm_deleted_rows': False
+ }
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ measurement_grp_name = Column(
+ String,
+ ForeignKey(MeasurementGroupModel.measurement_group_name, ondelete='cascade',
+ onupdate='cascade')
+ )
+ nf_name = Column(
+ String,
+ ForeignKey(NetworkFunctionModel.nf_name, ondelete='cascade', onupdate='cascade')
+ )
+ nf_measure_grp_status = Column(String(20))
+ retry_count = Column(Integer)
+
+ def __init__(self, measurement_grp_name, nf_name, nf_measure_grp_status=None,
+ retry_count=0):
+ self.measurement_grp_name = measurement_grp_name
+ self.nf_name = nf_name
+ self.nf_measure_grp_status = nf_measure_grp_status
+ self.retry_count = retry_count
+
+ def __repr__(self):
+ return f'measurement_grp_name: {self.measurement_grp_name}, ' \
+ f'nf_name: {self.nf_name}, nf_measure_grp_status: {self.nf_measure_grp_status}'
def __init__(self, sdnc_model_name=None, sdnc_model_version=None, **kwargs):
""" Object representation of the NetworkFunction. """
self.nf_name = kwargs.get('nf_name')
- self.ip_address = kwargs.get('ip_address')
+ self.ipv4_address = kwargs.get('ipv4_address')
+ self.ipv6_address = kwargs.get('ipv6_address')
self.model_invariant_id = kwargs.get('model_invariant_id')
self.model_version_id = kwargs.get('model_version_id')
self.model_name = kwargs.get('model_name')
@classmethod
def nf_def(cls):
- return cls(nf_name=None, ip_address=None, model_invariant_id=None,
- model_version_id=None, model_name=None,
+ return cls(nf_name=None, ipv4_address=None, ipv6_address=None,
+ model_invariant_id=None, model_version_id=None, model_name=None,
sdnc_model_name=None, sdnc_model_version=None)
def __str__(self):
return f'nf-name: {self.nf_name}, ' \
- f'ipaddress-v4-oam: {self.ip_address}, ' \
+ f'ipaddress-v4-oam: {self.ipv4_address}, ' \
+ f'ipaddress-v6-oam: {self.ipv6_address}, ' \
f'model-invariant-id: {self.model_invariant_id}, ' \
f'model-version-id: {self.model_version_id}, ' \
f'model-name: {self.model_name}, ' \
def __eq__(self, other):
return \
self.nf_name == other.nf_name and \
- self.ip_address == other.ip_address and \
+ self.ipv4_address == other.ipv4_address and \
+ self.ipv6_address == other.ipv6_address and \
self.model_invariant_id == other.model_invariant_id and \
self.model_version_id == other.model_version_id and \
self.model_name == other.model_name and \
self.sdnc_model_version == other.sdnc_model_version
def __hash__(self):
- return hash((self.nf_name, self.ip_address, self.model_invariant_id,
- self.model_version_id, self.model_name,
+ return hash((self.nf_name, self.ipv4_address, self.ipv6_address,
+ self.model_invariant_id, self.model_version_id, self.model_name,
self.sdnc_model_name, self.sdnc_model_version))
def create(self):
if existing_nf is None:
new_nf = NetworkFunctionModel(nf_name=self.nf_name,
- ip_address=self.ip_address,
+ ipv4_address=self.ipv4_address,
+ ipv6_address=self.ipv6_address,
model_invariant_id=self.model_invariant_id,
model_version_id=self.model_version_id,
model_name=self.model_name,
Code Review / dcaegen2 / services.git / commitdiff