handling ADM upload and report printing

Author: David Linko

.env

@@ -52,3 +52,5 @@ RENDERER_HOST_PORT=${DOCKER_CTR_PREFIX}grafana-image-renderer:${RENDERER_PORT}
 ION_MGR_PORT=8089
 HTTP_PORT:80
 SOCKDIR=/var/tmp/nm
+
+ADM_PATH=deps/dtnma-ace/tests/adms

anms-core/anms/components/schemas/ARIs/rpt_entry.py

@@ -29,21 +29,11 @@
 
 # Shared properties
 class RptEntryBase(BaseModel):
-    time: Optional[int] = None
+    reference_time: Optional[str] = None
     agent_id: Optional[str] = None
-    report_name: Optional[str] = None
-    ADM: Optional[str] = None
-    report_id: Optional[int] = None
-    string_values: Optional[str] = None
-    uint_values: Optional[str] = None
-    int_values: Optional[str] = None
-    real32_values: Optional[str] = None
-    real64_values: Optional[str] = None
-    uvast_values: Optional[str] = None
-    vast_values: Optional[str] = None
-    object_id_values: Optional[str] = None
-    AC_id_values: Optional[str] = None
-    TNVC_id_values: Optional[str] = None
+    correlator_nonce: Optional[str] = None
+    report_list: Optional[str] = None
+    ari_rptset_id: Optional[int] = None
 
 
 class RptEntryBaseInDBBase(RptEntryBase):

anms-core/anms/components/schemas/adm.py

@@ -25,9 +25,11 @@
 
 from pydantic import BaseModel
 
-class NamespaceViewSchema(BaseModel):
+class DataModelSchema(BaseModel):
+    data_model_id: int
+    namespace_type: str
+    name: str
     enumeration: int
-    data_model_name: str
-    name_string: Optional[str]
-    version_name: Optional[str]
-    use_desc: Optional[str]
+    namespace: Optional[str] = ""
+    version_name: Optional[str] = "0.0.0"
+    use_desc: Optional[str] = ""

…models/relational/adms/namespace_view.py …odels/relational/adms/data_model_view.pyanms-core/anms/models/relational/adms/namespace_view.py renamed to anms-core/anms/models/relational/adms/data_model_view.py anms-core/anms/models/relational/adms/namespace_view.py renamed to anms-core/anms/models/relational/adms/data_model_view.py

@@ -23,7 +23,7 @@
 #
 from typing import Any, Dict, Optional
 
-from sqlalchemy import (Column, Integer, String, select)
+from sqlalchemy import (Column, Integer, String, select, and_)
 from sqlalchemy import exc
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -34,14 +34,16 @@
 logger = OpenSearchLogger(__name__).logger
 config = ConfigBuilder.get_config()
 
-class Namespace(Model):
-    __tablename__ = 'namespace'
+class DataModel(Model):
+    __tablename__ = 'data_model'
     data_model_id = Column(Integer, unique=True, primary_key=True)
     namespace_type = Column(String)
-    issuing_org = Column(String)
-    name_string = Column(String)
+    name = Column(String)
+    enumeration = Column(Integer)
+    namespace = Column(String)
     version_name = Column(String)
-
+    use_desc = Column(String)
+    
     def __repr__(self) -> str:
         return self.as_dict().__repr__()
 
@@ -51,21 +53,10 @@ def as_dict(self) -> Dict[str, Any]:
         }
         return dict_obj
 
-
-
-
-class NamespaceView(Model):
-    __tablename__ = 'vw_namespace'
-    enumeration = Column(Integer, unique=True, primary_key=True)
-    data_model_name = Column(String)
-    name_string = Column(String)
-    version_name = Column(String)
-    use_desc = Column(String)
-
     @classmethod
     async def getall(
             cls, session: AsyncSession = None
-    ) -> Optional["NamespaceView"]:
+    ) -> Optional["DataModel"]:
         '''
         Retrieve all adms
 
@@ -78,37 +69,37 @@ async def getall(
                 async with get_async_session() as session:
                     result = await session.execute(stmt)
         except exc.SQLAlchemyError as e:
-            logger.error(f"NamespaceView::getall SQLAlchemyError: {str(e.args)}")
+            logger.error(f"DataModel::getall SQLAlchemyError: {str(e.args)}")
             return None
 
-        namespace_view_rows = result.all()
-        namespace_views = None
-        if namespace_view_rows != None:
-            namespace_views = [row['NamespaceView'] for row in namespace_view_rows]
+        data_model_view_rows = result.all()
+        data_model_views = None
+        if data_model_view_rows != None:
+            data_model_views = [row['DataModel'] for row in data_model_view_rows]
 
-        return namespace_views
+        return data_model_views
 
     @classmethod
     async def get(
-            cls, enumeration: Integer,  session: AsyncSession = None
-    ) -> Optional["NamespaceView"]:
+            cls, enumeration: Integer,  namespace: String, session: AsyncSession = None
+    ) -> Optional["DataModel"]:
         '''
         Retrieve all adms
 
         '''
-        stmt = select(cls).where(cls.enumeration == enumeration)
+        stmt = select(cls).where(and_(cls.enumeration == enumeration, cls.namespace == namespace))
         try:
             if session:
                 result = await session.execute(stmt)
             else:
                 async with get_async_session() as session:
                     result = await session.execute(stmt)
         except exc.SQLAlchemyError as e:
-            logger.error(f"NamespaceView::get SQLAlchemyError: {str(e.args)}")
+            logger.error(f"DataModel::get SQLAlchemyError: {str(e.args)}")
             return None 
 
-        namespace_view_row = result.scalar_one_or_none()
-        return namespace_view_row
+        data_model_view_row = result.scalar_one_or_none()
+        return data_model_view_row
 
     def __repr__(self) -> str:
         return self.as_dict().__repr__()

anms-core/anms/models/relational/ari.py

@@ -81,45 +81,6 @@ def as_dict(self) -> Dict[str, Any]:
         return dict_obj
 
 
-class ADM(Model):
-    __tablename__ = 'adm'
-    data_model_id = Column(Integer, primary_key=True)
-    data_model_name = Column(String)
-    enumeration = Column(Integer)
-    namespace_type = Column(String)
-    use_desc = Column(String)
-
-    def __repr__(self) -> str:
-        return self.as_dict().__repr__()
-
-    def as_dict(self) -> Dict[str, Any]:
-        dict_obj = {
-            c.name: getattr(self, c.name) for c in self.__table__.columns
-        }
-
-        return dict_obj
-
-    @classmethod
-    async def get(
-            cls, enumeration: Integer, session: AsyncSession = None
-    ) -> Optional["adm"]:
-        '''
-        Retrieve all adms
-
-        '''
-        stmt = select(cls).where(cls.enumeration == enumeration)
-        try:
-            if session:
-                result = await session.execute(stmt)
-            else:
-                async with get_async_session() as session:
-                    result = await session.execute(stmt)
-        except exc.SQLAlchemyError as e:
-            logger.error(f"ADM::get SQLAlchemyError: {str(e.args)}")
-            return None
-
-        adm_row = result.scalar_one_or_none()
-        return adm_row
 
 
 class ObjMetadata(Model):

anms-core/anms/models/relational/execution_set.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2023 The Johns Hopkins University Applied Physics
+# Laboratory LLC.
+#
+# This file is part of the Asynchronous Network Management System (ANMS).
+#
+# 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 work was performed for the Jet Propulsion Laboratory, California
+# Institute of Technology, sponsored by the United States Government under
+# the prime contract 80NM0018D0004 between the Caltech and NASA under
+# subcontract 1658085.
+#
+from typing import Any
+from typing import Dict
+
+from anms.models.relational import Model
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import String
+from sqlalchemy import LargeBinary
+
+
+# class for vw_ctrl_definition used for build ari
+class ExecutionSet(Model):
+    __tablename__ = 'vw_execution_set'
+    execution_set_id = Column(Integer, primary_key=True)
+    correlator_nonce = Column(Integer)
+    use_desc = Column(String)
+    agent_id = Column(String)
+    num_entries = Column(Integer)
+    entries	 = Column(LargeBinary)
+
+    def __repr__(self) -> str:
+        return self.as_dict().__repr__()
+
+    def as_dict(self) -> Dict[str, Any]:
+        dict_obj = {
+                    'execution_set_id': getattr(self, 'execution_set_id'),
+                    'correlator_nonce': getattr(self, 'correlator_nonce'),        
+                    'use_desc': getattr(self, 'use_desc'),
+                    'agent_id': getattr(self, 'agent_id'),
+                    'num_entries': getattr(self, 'num_entries'),
+                    'entries': getattr(self, 'entries')       
+                    }
+
+        return dict_obj

anms-core/anms/models/relational/report.py

@@ -33,24 +33,24 @@
 
 # class for vw_ctrl_definition used for build ari
 class Report(Model):
-    __tablename__ = 'ari_rpt_set'
-    reference_time = Column(Integer, nullable=False)
-    correlator_nonce = Column(Integer)
-    agent_id = Column(String)
+    __tablename__ = 'ari_rptset'
     ari_rptset_id = Column(Integer, primary_key=True)
+    correlator_nonce = Column(Integer)
+    reference_time = Column(Integer)
     report_list	= Column(String)
     report_list_cbor = Column(LargeBinary)
-
+    agent_id = Column(String)
     def __repr__(self) -> str:
         return self.as_dict().__repr__()
 
     def as_dict(self) -> Dict[str, Any]:
-        dict_obj = {'ari_rpt_set.reference_time': getattr(self, 'reference_time'),
-                    'ari_rpt_set.correlator_nonce': getattr(self, 'correlator_nonce'),        
-                    'ari_rpt_set.agent_id': getattr(self, 'agent_id'),        
-                    'ari_rpt_set.ari_rptset_id': getattr(self, 'ari_rptset_id'),
-                    'ari_rpt_set.report_list': getattr(self, 'report_list'),
-                    'ari_rpt_set.report_list_cbor': getattr(self, 'report_list_cbor'),
+        dict_obj = {
+                    'ari_rptset.ari_rptset_id': getattr(self, 'ari_rptset_id'),
+                    'ari_rptset.correlator_nonce': getattr(self, 'correlator_nonce'),        
+                    'ari_rptset.reference_time': getattr(self, 'reference_time'),
+                    'ari_rptset.report_list': getattr(self, 'report_list'),
+                    # 'ari_rptset.report_list_cbor': getattr(self, 'report_list_cbor'),
+                    'ari_rptset.agent_id': getattr(self, 'agent_id')       
                     }
 
         return dict_obj