Merge pull request #589 from FreeTAKTeam/581-TCPtoDP

converted tcp and ssl services to proper digitalpy implementations

FreeTAKServer/components/core/abstract_component/cot_node.py

@@ -1,11 +1,16 @@
+import copy
 from digitalpy.core.domain.node import Node
 from FreeTAKServer.model.FTSModel.fts_protocol_object import FTSProtocolObject
 import inspect
+from lxml import etree
 
 
 class CoTNode(Node, FTSProtocolObject):
  def __init__(self, node_type, configuration, model, oid=None):
+ # a dictionary containing the attributes of all cots
  self.cot_attributes = {}
+ # an xml object containing the contents of a given CoT without corresponding domain definition
+ self.xml = etree.Element(self.__class__.__name__)
  self.text = ""
  super().__init__(node_type, configuration, model, oid)
 
@@ -25,3 +30,13 @@ def add_child(self, child):
  child.set_parent(self)
  else:
  raise TypeError("child must be an instance of Node")
+
+ def __getstate__(self):
+ state = self.__dict__
+ state_cp = copy.copy(state)
+ state_cp["xml"] = etree.tostring(self.xml)
+ return state_cp
+
+ def __setstate__(self, state):
+ state["xml"] = etree.fromstring(state["xml"])
+ self.__dict__ = state

FreeTAKServer/components/core/domain/controllers/dict_to_node_controller.py

@@ -1,9 +1,22 @@
 from digitalpy.core.main.controller import Controller
 from digitalpy.core.telemetry.tracer import Tracer
+from digitalpy.core.zmanager.request import Request
+from digitalpy.core.zmanager.response import Response
+from digitalpy.core.zmanager.action_mapper import ActionMapper
+from digitalpy.core.digipy_configuration.configuration import Configuration
 from digitalpy.core.domain.node import Node
-
+from lxml import etree
 
 class DictToNodeController(Controller):
+ def __init__(
+ self,
+ request: Request,
+ response: Response,
+ sync_action_mapper: ActionMapper,
+ configuration: Configuration,
+ ) -> None:
+ super().__init__(request, response, sync_action_mapper, configuration)
+
  def execute(self, method=None):
  return getattr(self, method)(**self.request.get_values())
 
@@ -23,17 +36,14 @@ def convert_dict_to_node(
  tracer (Tracer, optional): a tracer object used for logging which should be passed by the facade. Defaults to None.
  """
  with tracer.start_as_current_span("convert_dict_to_node") as span:
- try:
- span.add_event(
- "serializing " + str(dictionary) + " to node " + str(model_object)
- )
- self.response.set_value(
- "model_object",
- self.serialize(dictionary[object_class_name.lower()], model_object),
- )
- span.add_event("serialization completed successfully")
- except Exception as ex:
- span.record_exception(ex)
+ span.add_event(
+ "serializing " + str(dictionary) + " to node " + str(model_object)
+ )
+ self.response.set_value(
+ "model_object",
+ self.serialize(dictionary[object_class_name.lower()], model_object),
+ )
+ span.add_event("serialization completed successfully")
 
  def serialize(self, dictionary, node):
  """recursively serialize a single layer of the given dictionary
@@ -44,12 +54,49 @@ def serialize(self, dictionary, node):
 
  def add_value_to_node(self, key, value, node):
  """add a value to a node object"""
+ if key == "#text":
+ setattr(node, "INTAG", value)
 
- if isinstance(value, dict):
+ elif not hasattr(node, key.strip("@")):
+ self.handle_missing_attribute(key, value, node)
+
+ # this and ensures that the value is absoloutly a Node type instead of an expected list with only value, ex. a pm to one user would be a single object in the dict representation
+ # however it's expected to be a list
+ elif isinstance(value, dict) and isinstance(getattr(node, key, None), Node):
  self.serialize(value, getattr(node, key))
 
- elif isinstance(value, list):
+ elif isinstance(value, list) and isinstance(getattr(node, key, None), list):
  for l_item in value:
  self.add_value_to_node(key, l_item, node)
+
+ elif isinstance(getattr(node, key, None), list):
+ self.serialize(value, getattr(node, key)[0])
+
  else:
  setattr(node, key.strip("@"), value)
+
+ def handle_missing_attribute(self, key, value, node):
+ """given the dynamic and expanding domain of the CoT standard there is always a risk of undocumented or new attributes or tags 
+ appearing in a given cot which does not yet exist in the domain, in these cases the keys and values will be converted to xml strings
+ and added to the cot_node
+
+ Args:
+ key (str): attribute or tag
+ value (Union[str, dict, List]): object or objects of the attribute/tag
+ node (str): model object to store xml_string
+ """
+ # this if case handles undefined nested objects
+ if isinstance(value, dict):
+ self.request.set_value("xml_dict", {key: value})
+ response = self.execute_sub_action("DictToXML")
+ elem = etree.fromstring(response.get_value("xml").encode())
+ node.xml.append(elem)
+ elif isinstance(value, list):
+ for l_item in value:
+ self.add_value_to_node(key, l_item, node)
+ response = self.execute_sub_action("DictToXML")
+ elem = etree.Element(key, response.get_value("message"))
+ node.xml.append(elem)
+
+ elif value is not None:
+ node.xml.attrib[key] = value

FreeTAKServer/components/core/domain/controllers/serialization/xml_serialization/xml_serialization_orchestrator.py

@@ -8,22 +8,27 @@
 from .xml_serializer import XmlSerializer
 from .xml_element import ExtendedElement
 from FreeTAKServer.model.FTSModel.fts_protocol_object import FTSProtocolObject
-
+from ...domain import Domain
 
 class XMLSerializationOrchestrator(Controller):
  def __init__(
  self,
  request: Request,
  response: Response,
- action_mapper: ActionMapper,
+ sync_action_mapper: ActionMapper,
  configuration: Configuration,
  ):
  super().__init__(
  request=request,
  response=response,
- action_mapper=action_mapper,
+ action_mapper=sync_action_mapper,
  configuration=configuration,
  )
+ self.domain_controller = Domain(request, response, sync_action_mapper, configuration)
+
+ def initialize(self, request, response):
+ super().initialize(request, response)
+ self.domain_controller.initialize(request, response)
 
  def execute(self, method=None):
  getattr(self, method)(**self.request.get_values())
@@ -49,11 +54,7 @@ def xml_to_node(self, message, model_object, **kwargs):
  self.response.set_value("model_object", model_object)
 
  def _get_parent(self, node, type=""):
- self.request.set_value("node", node)
- self.request.set_context(type)
- sub_response = self.execute_sub_action("GetNodeParent")
- return sub_response.get_value("parent")
-
+ return self.domain_controller.get_parent(node)
 
 class TargetXMLToModel_object:
  def __init__(self, model_object, parent_getter):

FreeTAKServer/components/core/domain/domain/_event.py

@@ -5,6 +5,7 @@
 import datetime
 from FreeTAKServer.components.core.abstract_component.cot_node import CoTNode
 from FreeTAKServer.components.core.abstract_component.cot_property import CoTProperty
+from lxml import etree
 
 DATETIME_FMT = "%Y-%m-%dT%H:%M:%S.%fZ"
 DEFAULT_STALE_TIME = 60
@@ -27,6 +28,9 @@ class Event(CoTNode):
  def __init__(self, configuration: Configuration, model, oid=None):
 
  super().__init__(self.__class__.__name__, configuration, model, oid)
+ # modify the xml object to be event instead of Event
+ self.xml = etree.Element(self.__class__.__name__.lower())
+
  self.cot_attributes["version"] = None
  self.cot_attributes["uid"] = None
  self.cot_attributes["type"] = None

FreeTAKServer/components/core/domain/domain/_marti.py

@@ -26,8 +26,8 @@ def __init__(self, configuration: Configuration, model):
 
  @CoTProperty
  def dest(self):
- return self.cot_attributes["dest"]
+ return self.get_children_ex(children_type="dest")
 
  @dest.setter
  def dest(self, dest):
- self.cot_attributes["dest"].append(dest)
+ self.add_child(dest)

FreeTAKServer/components/core/domain/domain_facade.py

@@ -6,6 +6,9 @@
  INTERNAL_ACTION_MAPPING_PATH,
  MANIFEST_PATH,
 )
+
+from .controllers.dict_to_node_controller import DictToNodeController
+from .controllers.domain import Domain as DomainController
 from . import base
 
 config = MainConfig.instance()
@@ -18,7 +21,7 @@ class Domain(DefaultFacade):
 
  def __init__(
  self,
- domain_action_mapper,
+ sync_action_mapper,
  request,
  response,
  configuration,
@@ -34,7 +37,7 @@ def __init__(
  # the package containing the base classes
  base=base,
  # the component specific action mapper (passed by constructor)
- action_mapper=domain_action_mapper,
+ action_mapper=sync_action_mapper,
  # the request object (passed by constructor)
  request=request,
  # the response object (passed by constructor)
@@ -48,3 +51,35 @@ def __init__(
  # the path to the manifest file
  manifest_path=MANIFEST_PATH,
  )
+ self.dict_to_node_controller = DictToNodeController(request, response, sync_action_mapper, configuration)
+ self.domain_controller = DomainController(request, response, sync_action_mapper, configuration)
+
+ def initialize(self, request, response):
+ super().initialize(request, response)
+ self.dict_to_node_controller.initialize(request, response)
+ self.domain_controller.initialize(request, response)
+
+ def execute(self, method):
+ try:
+ if hasattr(self, method):
+ getattr(self, method)(**self.request.get_values())
+ else:
+ self.request.set_value("logger", self.logger)
+ self.request.set_value("config_loader", self.config_loader)
+ self.request.set_value("tracer", self.tracer)
+ response = self.execute_sub_action(self.request.get_action())
+ self.response.set_values(response.get_values())
+ except Exception as e:
+ self.logger.fatal(str(e))
+
+ @DefaultFacade.public
+ def convert_dict_to_node(self, *args, **kwargs):
+ self.dict_to_node_controller.convert_dict_to_node(*args,**kwargs)
+
+ @DefaultFacade.public
+ def create_node(self, *args, **kwargs):
+ self.domain_controller.create_node(*args, **kwargs)
+
+ @DefaultFacade.public
+ def get_node_parent(self, *args, **kwargs):
+ self.domain_controller.get_parent(*args, **kwargs)

FreeTAKServer/components/core/xml_serializer/configuration/external_action_mapping.ini

@@ -7,6 +7,14 @@
 ; dict (Dict): dictionary representation of the xml string message
 ??XMLToDict = FreeTAKServer.components.core.xml_serializer.xml_serializer_facade.XmlSerializer.XMLToDict
 
+; converts the provided dictionary to an xml string
+; Args:
+; xml_dict (Dict): dictionary representation of the xml string message
+;
+; Returns:
+; message (str): dictionary in form of xml string
+??DictToXML = FreeTAKServer.components.core.xml_serializer.xml_serializer_facade.XmlSerializer.DictToXML
+
 ;this action converts the provided node to an xml string
 ;Args:
 ; node (Node): the node to be serialized to xml

FreeTAKServer/components/core/xml_serializer/configuration/internal_action_mapping.ini

@@ -3,6 +3,8 @@ ComponentName??Type = absolute.path.to.xml_serializer.controllers.xml_serializer
 
 ??XMLToDict = FreeTAKServer.components.core.xml_serializer.controllers.xml_serialization_controller.XMLSerializationController.convert_xml_to_dict
 
+??DictToXML = FreeTAKServer.components.core.xml_serializer.controllers.xml_serialization_controller.XMLSerializationController.convert_dict_to_xml
+
 ??BroadcastComponentName = absolute.path.to.xml_serializer.controllers.xml_serializer_sender_controller.ComponentNameSenderController.broadcast_xml_serializer
 
 ??ParseComponentName = absolute.path.to.xml_serializer.controllers.xml_serializer_controller.ComponentNameController.parse_xml_serializer

FreeTAKServer/components/core/xml_serializer/controllers/xml_serialization_controller.py

@@ -27,6 +27,14 @@ def convert_xml_to_dict(self, message: str, **kwargs):
  """
  self.response.set_value("dict", xmltodict.parse(message))
 
+ def convert_dict_to_xml(self, xml_dict: dict, **kwargs) -> str:
+ """converts the provided dictionary to an xml string
+
+ Args:
+ xml_dict (dict): a dictionary parsed by xmltodict
+ """
+ self.response.set_value("xml", xmltodict.unparse(xml_dict))
+
  def convert_node_to_xml(self, node, **kwargs):
  """converts the provided node to an xml string
 
@@ -51,7 +59,7 @@ def _serialize_node(
  Union[str, Element]: the original call to this method returns a string representing the xml
  the Element is only returned in the case of recursive calls
  """
- xml = Element(tag_name)
+ xml = node.xml
  # handles text data within tag
  if hasattr(node, "text"):
  xml.text = node.text
@@ -61,7 +69,7 @@ def _serialize_node(
  value = getattr(node, attribName)
  if hasattr(value, "__dict__"):
  tagElement = self._serialize_node(value, attribName, level=level + 1)
- # TODO: modify so double underscores are handled differently
+ # T2ODO: modify so double underscores are handled differently
  try:
  if attribName[0] == "_":
  tagElement.tag = "_" + tagElement.tag

FreeTAKServer/components/extended/emergency/controllers/emergency_api_controller.py

@@ -3,7 +3,7 @@
 from flask_httpauth import HTTPTokenAuth
 from digitalpy.core.main.object_factory import ObjectFactory
 
-from FreeTAKServer.services.rest_api_service.views.base_view import BaseView
+from FreeTAKServer.services.rest_api_service.views.base_view_controller import BaseViewController
 from FreeTAKServer.core.configuration.LoggingConstants import LoggingConstants
 from FreeTAKServer.core.configuration.CreateLoggerController import CreateLoggerController
 from FreeTAKServer.core.parsers.JsonController import JsonController
@@ -15,7 +15,7 @@
 loggingConstants = LoggingConstants(log_name="FTS-ManageEmergencyView")
 logger = CreateLoggerController("FTS-ManageEmergencyView", logging_constants=loggingConstants).getLogger()
 
-class ManageEmergency(BaseView):
+class ManageEmergency(BaseViewController):
 
  def __init__(self, request, response, action_mapper, configuration) -> None:
  endpoints = {

FreeTAKServer/controllers/services/FTS.py

@@ -287,11 +287,11 @@ def start_cot_service(self, FTSServiceStartupConfigObject):
  self.TCPCoTService, ServiceTypes.TCPCOTSERVICE
  )
  self.FilterGroup.add_source(self.TCPCoTService, ServiceTypes.TCPCOTSERVICE)
- print("CoTService started")
+ logger.info("CoT Service Started")
  return 1
- except Exception as e:
+ except Exception as ex:
  logger.error(
- "an exception has been thrown in CoT service startup " + str(e)
+ "an exception has been thrown in CoT service startup " + str(ex)
  )
  return -1
 

FreeTAKServer/core/configuration/MainConfig.py

@@ -9,12 +9,12 @@
 
 # the version information of the server (recommended to leave as default)
 
-FTS_VERSION = "FreeTAKServer-2.0.21"
+FTS_VERSION = "FreeTAKServer-2.0.66"
 API_VERSION = "3.0"
 ROOTPATH = "/"
 MAINPATH = Path(__file__).parent.parent.parent
 USERPATH = rf"{ROOTPATH}usr/local/lib/"
-PERSISTENCE_PATH = r'C:\Users\Natha Paquette\work\FreeTakServer\persistence'
+PERSISTENCE_PATH = r'/opt/fts'
 
 class MainConfig:
  """

FreeTAKServer/core/configuration/ReceiveConnectionsConstants.py

@@ -9,3 +9,4 @@ def __init__(self):
  self.LISTEN_COUNT = 2000
  # ssl socket timeout
  self.SSL_SOCK_TIMEOUT = 60
+ self.MAX_RECEPTION_ITERATIONS = 4

FreeTAKServer/core/cot_management/configuration/cot_management_constants.py

@@ -11,6 +11,8 @@
 
 DELETE_GEO_OBJECT = "deletegeoobject"
 
+BASE_OBJECT = "base_object"
+
 CONFIGURATION_PATH_TEMPLATE = Template(
  str(
  pathlib.PurePath(