def _serializeJsonToModel(self, object, json):
# runs if emergency is on
if isinstance(json, EmergencyPost):
object.settype(
RestEnumerations.emergencyTypes[json.getemergencyType()])
object.detail.contact.setcallsign(json.getname())
object.detail.emergency.settype(json.getemergencyType())
if json.getaddress():
locator = Nominatim(user_agent="myGeocoder")
location = locator.geocode(json.getaddress())
object.point.setlon(location.longitude)
object.point.setlat(location.latitude)
else:
object.point.setlon(json.getlongitude())
object.point.setlat(json.getlatitude())
DatabaseController().create_ActiveEmergency(object)
return object
# runs if emergency is off
elif isinstance(json, EmergencyDelete):
object.setuid(json.getuid())
DatabaseController().remove_ActiveEmergency(
query=f'uid == "{object.uid}"')
object.settype('b-a-o-can')
object.detail.emergency.setcancel('true')
return object
class templateSerializer:
def __init__(self, templateFile=None):
self.templatedata = templateFile
def convert_template_to_object(self):
templateObject = templateInstanceContents()
templateDetails = etree.fromstring(self.templatedata)
templateDetails = templateDetails.find('checklistDetails')
templateObject.settimestamp()
templateObject.data.setkeywords(
name=templateDetails.find('name').text,
description=templateDetails.find('description').text,
callsign=templateDetails.find('creatorCallsign').text)
templateObject.setcreatoruid(templateDetails.find('creatorUid').text)
templateObject.data.setname(templateDetails.find('uid').text)
templateObject.data.setuid(templateDetails.find('uid').text)
templateObject.data.sethash(
str(hashlib.sha256(str(self.templatedata).encode()).hexdigest()))
templateObject.data.setsize(len(self.templatedata))
templateObject.data.setfilename()
# TODO: include in DB the submitting user
templateObject.data.setsubmitter('test')
templateObject.data.settool('ExCheck')
templateObject.data.setsubmissionTime()
return templateObject
def convert_DB_to_object(self, DBObject):
templateObject = templateInstanceContents()
templateObject.setcreatoruid(DBObject.creatorUid)
templateObject.data.setname(DBObject.data.uid)
templateObject.data.setuid(DBObject.data.uid)
templateObject.data.sethash(DBObject.data.hash)
templateObject.data.setsize(DBObject.data.size)
templateObject.data.setkeywords(
name=DBObject.data.keywords.name,
description=DBObject.data.keywords.description,
callsign=DBObject.data.keywords.callsign)
templateObject.data.setfilename()
# TODO: include in DB the submitting user
templateObject.data.setsubmitter('test')
templateObject.data.settool('ExCheck')
templateObject.data.setsubmissionTime()
return templateObject
def create_DB_object(self, templateObject):
self.DataBase = DatabaseController()
output = self.DataBase.create_ExCheck(templateObject)
self.DataBase.shutdown_Connection()
return output
def convert_object_to_json(self, DBObject):
templateJsonMessage = template()
templateJsonMessage.data.append(templateInstance())
for content in DBObject:
contentobj = self.convert_DB_to_object(content)
contentobj.data = vars(contentobj.data)
templateJsonMessage.data[0].contents.append(vars(contentobj))
y = vars(templateJsonMessage)
y['data'][0] = vars(y['data'][0])
return y
def testing(self):
"""
function which creates variables for testing
"""
from multiprocessing import Pipe
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
self.dbController = DatabaseController()
self.CoTSharePipe, other = Pipe()
return None
def start(self, IP, CoTPort, Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe):
try:
self.dbController = DatabaseController()
# self.clear_user_table()
os.chdir('../../../')
# create socket controller
self.TCPSocketController = TCPSocketController()
self.TCPSocketController.changeIP(IP)
self.TCPSocketController.changePort(CoTPort)
sock = self.TCPSocketController.createSocket()
pool = ThreadPool(processes=2)
self.pool = pool
clientData = pool.apply_async(ClientReceptionHandler().startup,
(self.clientInformationQueue, ))
receiveConnection = pool.apply_async(ReceiveConnections().listen,
(sock, ))
# instantiate domain model and save process as object
self.mainRunFunction(clientData, receiveConnection, sock, pool,
Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe)
except Exception as e:
logger.error('there has been an exception in the start function '
'of TCPCoTService ' + str(e))
return e
def start(self, pipe, ip, port):
self.db = DatabaseController()
self.pipe = pipe
self._create_context()
self._create_listener(ip, port)
print('started federation server service')
self.main()
def getAllPackages(self):
data = DatabaseController().query_datapackage("Privacy == 0")
package_dict = {"resultCount": len(data), "results": []}
for i in data:
package_dict["results"].append({
"UID":
i.uid,
"Name":
i.Name,
"Hash":
i.Hash,
"PrimaryKey":
i.PrimaryKey,
"SubmissionDateTime":
str(i.SubmissionDateTime.strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
"SubmissionUser":
i.SubmissionUser,
"CreatorUid":
i.CreatorUid,
"Keywords":
i.Keywords,
"MIMEType":
i.MIMEType,
"Size":
i.Size
})
return package_dict
def __init__(self, RawCoT):
if RawCoT.status == 'on':
tempObject = super().Event.emergecyOn()
object = SendEmergency()
object.status = 'on'
self.fill_object(object, tempObject, RawCoT, addToDB=False)
obj = self.getObject()
DatabaseController().create_ActiveEmergency(obj.modelObject)
elif RawCoT.status == 'off':
tempObject = super().Event.emergecyOff()
object = SendEmergency()
object.status = 'off'
self.fill_object(object, tempObject, RawCoT, addToDB=False)
obj = self.getObject()
DatabaseController().remove_ActiveEmergency(
query=f'uid = "{obj.modelObject.uid}"')
def __init__(self, json):
tempObject = event.SimpleCoT()
object = SendSimpleCoT()
object.setModelObject(tempObject)
object.modelObject = self._serializeJsonToModel(object.modelObject, json)
DatabaseController().create_CoT(object.modelObject)
object.setXmlString(XMLCoTController().serialize_model_to_CoT(object.modelObject))
self.setCoTObject(object)
def __init__(self, json):
tempObject = event.SimpleCoT()
object = SendSimpleCoT()
object.setModelObject(tempObject)
object.modelObject = self._serializeJsonToModel(object.modelObject, json)
DatabaseController().create_CoT(object.modelObject)
object.setXmlString(etree.tostring(XmlSerializer().from_fts_object_to_format(object.modelObject)))
self.setCoTObject(object)
def __init__(self):
self.CoTService = None
self.TCPDataPackageService = None
self.UserCommand = None
self.killSwitch = False
self.ReceiveConnectionsReset = None
self.CoTPoisonPill = None
self.ClientDataPipe = None
self.SSLClientDataPipe = None
self.clientArray = []
self.socketCount = 0
self.pipeList = {}
self.FilterGroup = FilterGroup()
self.FTSServiceStartupConfigObject = FTSObj()
self.dbController = DatabaseController()
logger.propagate = True
logger.info('something')
def ExCheckTemplates():
try:
# when no data available
# return b'{"version":"2","type":"Mission","data":[{"name":"exchecktemplates","description":"","chatRoom":"","tool":"ExCheck","keywords":[],"creatorUid":"ExCheck","createTime":"2020-10-19T22:37:39.290Z","externalData":[],"uids":[],"contents":[]}],"nodeId":"TAK-Server-560c34e9"}'
# when data available
return templateSerializer().convert_object_to_json(
DatabaseController().query_ExCheck())
except Exception as e:
print(e)
def systemUsers(empty=None):
systemUserArray = DatabaseController().query_systemUser()
jsondata = {"SystemUsers": []}
for user in systemUserArray:
userjson = {}
userjson['Name'] = user.name
userjson["Group"] = user.group
userjson["Token"] = user.token
userjson["Password"] = user.password
userjson["Certs"] = user.certificate_package_name
userjson["Uid"] = user.uid
jsondata["SystemUsers"].append(userjson)
emit('systemUsersUpdate', json.dumps(jsondata))
def start(self, IP, CoTPort, Event, clientDataPipe, ReceiveConnectionKillSwitch, RestAPIPipe):
try:
self.dbController = DatabaseController()
print('ssl cot service starting')
os.chdir('../../')
# create socket controller
self.SSLSocketController = SSLSocketController()
self.SSLSocketController.changeIP(IP)
self.SSLSocketController.changePort(CoTPort)
sock = self.SSLSocketController.createSocket()
#threadpool is used as it allows the transfer of SSL socket unlike processes
pool = ThreadPool(processes=2)
self.pool = pool
clientData = pool.apply_async(ClientReceptionHandler().startup, (self.clientInformationQueue,))
receiveConnection = pool.apply_async(ReceiveConnections().listen, (sock,))
# instantiate domain model and save process as object
self.mainRunFunction(clientData, receiveConnection, sock, pool, Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe, True)
except Exception as e:
logger.error("there has been an exception thrown in"
" the starting of the ssl service " + str(e))
return e
class FTS:
def __init__(self):
self.CoTService = None
self.TCPDataPackageService = None
self.UserCommand = None
self.killSwitch = False
self.ReceiveConnectionsReset = None
self.CoTPoisonPill = None
self.ClientDataPipe = None
self.SSLClientDataPipe = None
self.clientArray = []
self.socketCount = 0
self.pipeList = {}
self.FilterGroup = FilterGroup()
self.FTSServiceStartupConfigObject = FTSObj()
self.dbController = DatabaseController()
logger.propagate = True
logger.info('something')
def start_restAPI_service(self, StartupObjects):
try:
self.RestAPIPipe = Queue()
restapicommandsthread = Queue()
restapicommandsmain = Queue()
self.RestAPICommandsFTS = QueueManager(restapicommandsmain,
restapicommandsthread)
RestAPICommandsFTS = QueueManager(restapicommandsthread,
restapicommandsmain)
self.receive_Rest_stopper = multiprocessing.Event()
self.receive_Rest_stopper.clear()
self.receive_Rest = threading.Thread(
target=self.receive_Rest_commands,
args=(self.receive_Rest_stopper, ))
self.RestAPIProcess = multiprocessing.Process(
target=RestAPI().startup,
args=(self.RestAPIPipe, RestAPICommandsFTS,
StartupObjects.RestAPIService.RestAPIServiceIP,
StartupObjects.RestAPIService.RestAPIServicePort,
self.StartupTime))
self.receive_Rest.start()
self.RestAPIProcess.start()
self.pipeList['restAPI'] = self.RestAPIPipe
self.FilterGroup.sources.append(self.RestAPIPipe)
return 1
except Exception as e:
logger.error(
'There has been an exception thrown in the startup of the restAPI service '
+ str(e))
return -1
def stop_RestAPI_service(self):
try:
self.RestAPIProcess.terminate()
self.RestAPIProcess.join()
self.receive_Rest_stopper.set()
self.receive_Rest.join()
except Exception as e:
logger.error('an exception has been thrown in RestAPI Startup ' +
str(e))
def start_CoT_service(self, FTSServiceStartupConfigObject):
try:
self.ClientDataPipe = Queue()
TCPCoTServiceThread = Queue()
TCPCoTServiceFTS = Queue()
self.TCPCoTService = QueueManager(TCPCoTServiceThread,
TCPCoTServiceFTS)
TCPCoTService = QueueManager(TCPCoTServiceFTS, TCPCoTServiceThread)
print('event event about to be created')
self.CoTPoisonPill = multiprocessing.Event()
self.CoTPoisonPill.set()
self.ReceiveConnectionsReset = multiprocessing.Event()
self.CoTService = multiprocessing.Process(
target=TCPCoTServiceController().start,
args=(FTSServiceStartupConfigObject.CoTService.CoTServiceIP,
FTSServiceStartupConfigObject.CoTService.CoTServicePort,
self.CoTPoisonPill, self.ClientDataPipe,
self.ReceiveConnectionsReset, TCPCoTService))
self.CoTService.start()
self.pipeList['TCPCoTServiceFTSPipe'] = self.TCPCoTService
self.FilterGroup.receivers.append(self.TCPCoTService)
self.FilterGroup.sources.append(self.TCPCoTService)
print('CoTService started')
return 1
except Exception as e:
logger.error(
'an exception has been thrown in CoT service startup ' +
str(e))
return -1
def stop_CoT_service(self):
try:
# self.ClientDataPipe.close()
self.CoTPoisonPill.clear()
time.sleep(1)
if self.CoTService.is_alive():
self.CoTService.terminate()
self.CoTService.join()
else:
self.CoTService.join()
self.FilterGroup.sources.remove(self.TCPCoTService)
self.FilterGroup.receivers.remove(self.TCPCoTService)
except Exception as e:
logger.error(
"there's been an exception in the stopping of CoT Service " +
str(e))
return -1
return 1
def start_tcp_data_package_service(self, FTSServiceStartupConfigObject):
try:
self.tcp_data_package_service_pipe = Queue()
print('start 213')
self.TCPDataPackageService = multiprocessing.Process(
target=TCPFlaskFunctions().startup,
args=(FTSServiceStartupConfigObject.TCPDataPackageService.
TCPDataPackageServiceIP, FTSServiceStartupConfigObject.
TCPDataPackageService.TCPDataPackageServicePort,
self.tcp_data_package_service_pipe))
print('starting now')
self.TCPDataPackageService.start()
self.pipeList[
'tcp_data_package_service_pipe'] = self.tcp_data_package_service_pipe
self.FilterGroup.sources.append(self.tcp_data_package_service_pipe)
time.sleep(2)
return 1
except Exception as e:
logger.error(
'there has been an exception in the individual starting of the Data Packages Service '
+ str(e))
return -1
def stop_tcp_data_package_service(self):
del self.pipeList['tcp_data_package_service_pipe']
self.FilterGroup.sources.remove(self.tcp_data_package_service_pipe)
try:
self.TCPDataPackageService.terminate()
except Exception as e:
logger.error(
"there's been an exception in the termination of DataPackage Service "
+ str(e))
return -1
try:
self.TCPDataPackageService.join()
except Exception as e:
logger.error(
"there's been an exception in the joining of DataPackage Service "
+ str(e))
return -1
self.tcp_data_package_service_pipe.close()
return 1
def start_ssl_data_package_service(self, FTSServiceStartupConfigObject):
try:
print('start 213')
self.ssl_data_package_service = Queue()
self.SSLDataPackageService = multiprocessing.Process(
target=SSLFlaskFunctions().startup,
args=(FTSServiceStartupConfigObject.SSLDataPackageService.
SSLDataPackageServiceIP, FTSServiceStartupConfigObject.
SSLDataPackageService.SSLDataPackageServicePort,
self.ssl_data_package_service))
print('starting SSL now')
self.SSLDataPackageService.start()
self.pipeList[
'ssl_data_package_service'] = self.ssl_data_package_service
self.FilterGroup.sources.append(self.ssl_data_package_service)
time.sleep(2)
return 1
except Exception as e:
logger.error(
'there has been an exception in the individual starting of the Data Packages Service '
+ str(e))
return -1
def stop_ssl_data_package_service(self):
del (self.pipeList['ssl_data_package_service'])
self.FilterGroup.sources.remove(self.ssl_data_package_service)
try:
self.SSLDataPackageService.terminate()
except Exception as e:
logger.error(
"there's been an exception in the termination of DataPackage Service "
+ str(e))
return -1
try:
self.SSLDataPackageService.join()
except Exception as e:
logger.error(
"there's been an exception in the joining of DataPackage Service "
+ str(e))
return -1
self.ssl_data_package_service.close()
return 1
def start_SSL_CoT_service(self, FTSServiceStartupConfigObject):
try:
self.SSLClientDataPipe = Queue()
SSLCoTServicePipeFTS = Queue()
SSLCoTServicePipeController = Queue()
self.SSLCoTServicePipe = QueueManager(SSLCoTServicePipeController,
SSLCoTServicePipeFTS)
SSLCoTServicePipe = QueueManager(SSLCoTServicePipeFTS,
SSLCoTServicePipeController)
self.SSLCoTPoisonPill = multiprocessing.Event()
self.SSLCoTPoisonPill.set()
self.ReceiveConnectionsReset = multiprocessing.Event()
self.SSLCoTService = multiprocessing.Process(
target=SSLCoTServiceController().start,
args=(FTSServiceStartupConfigObject.SSLCoTService.
SSLCoTServiceIP, FTSServiceStartupConfigObject.
SSLCoTService.SSLCoTServicePort, self.SSLCoTPoisonPill,
self.SSLClientDataPipe, self.ReceiveConnectionsReset,
SSLCoTServicePipe))
self.SSLCoTService.start()
self.pipeList['SSLCoTServiceFTSPipe'] = self.SSLCoTServicePipe
self.FilterGroup.sources.append(self.SSLCoTServicePipe)
self.FilterGroup.receivers.append(self.SSLCoTServicePipe)
print('SSL CoTService started')
return 1
except Exception as e:
logger.error(
'an exception has been thrown in SSL CoT service startup ' +
str(e))
return -1
def stop_SSL_CoT_service(self):
try:
self.SSLClientDataPipe.close()
self.SSLCoTPoisonPill.clear()
time.sleep(0.1)
if self.SSLCoTService.is_alive():
self.SSLCoTService.terminate()
self.SSLCoTService.join()
else:
self.SSLCoTService.join()
del (self.pipeList["SSLCoTServiceFTSPipe"])
self.FilterGroup.sources.remove(self.SSLCoTServicePipe)
self.FilterGroup.receivers.remove(self.SSLCoTServicePipe)
except Exception as e:
logger.error(
"there's been an exception in the stopping of CoT Service " +
str(e))
return -1
return 1
def start_federation_client_service(self, FTSServiceStartupConfigObject):
FederationClientServicePipeFTS = Queue()
FederationClientServicePipe = Queue()
self.FederationClientServicePipeFTS = QueueManager(
FederationClientServicePipeFTS, FederationClientServicePipe)
FederationClientServicePipe = QueueManager(
FederationClientServicePipe, FederationClientServicePipeFTS)
self.FederationClientService = multiprocessing.Process(
target=FederationClientServiceController().start,
args=(FederationClientServicePipe, ))
self.FederationClientService.start()
self.pipeList[
'FederationClientServiceFTSPipe'] = self.FederationClientServicePipeFTS
self.FilterGroup.sources.append(self.FederationClientServicePipeFTS)
self.FilterGroup.receivers.append(self.FederationClientServicePipeFTS)
return 1
def stop_federation_client_service(self):
try:
del (self.pipeList['FederationClientServiceFTSPipe'])
self.FilterGroup.receivers.remove(
self.FederationClientServicePipeFTS)
self.FilterGroup.sources.remove(
self.FederationClientServicePipeFTS)
if self.FederationClientService.is_alive():
self.FederationClientService.terminate()
self.FederationClientService.join()
else:
self.FederationClientService.join()
self.FilterGroup.sources.remove(
self.FederationClientServicePipeFTS)
self.FilterGroup.receivers.remove(
self.FederationClientServicePipeFTS)
return 1
except:
return -1
def start_federation_server_service(self, FTSServiceStartupConfigObject):
try:
ip = FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceIP
port = FTSServiceStartupConfigObject.FederationServerService.FederationServerServicePort
FederationServerServiceFTS = Queue()
FederationServerServiceController = Queue()
self.FederationServerServicePipeFTS = QueueManager(
FederationServerServiceController, FederationServerServiceFTS)
FederationServerServicePipe = QueueManager(
FederationServerServiceFTS, FederationServerServiceController)
self.FederationServerService = multiprocessing.Process(
target=FederationServerService().start,
args=(FederationServerServicePipe, ip, port))
self.FederationServerService.start()
self.pipeList[
'FederationServerServiceFTSPipe'] = self.FederationServerServicePipeFTS
self.FilterGroup.sources.append(
self.FederationServerServicePipeFTS)
self.FilterGroup.receivers.append(
self.FederationServerServicePipeFTS)
return 1
except:
return -1
def stop_federation_server_service(self):
try:
if self.FederationServerService.is_alive():
self.FederationServerService.terminate()
self.FederationServerService.join()
else:
self.FederationServerService.join()
self.FederationServerServicePipeFTS.close()
self.FilterGroup.sources.remove(
self.FederationServerServicePipeFTS)
self.FilterGroup.receivers.remove(
self.FederationServerServicePipeFTS)
return 1
except:
return -1
#change object name to FTSServiceStartupConfigObject
def start_all(self, FTSServiceStartupConfigObject):
import copy
try:
if FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus == 'start':
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus
self.start_tcp_data_package_service(
FTSServiceStartupConfigObject)
if FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort != "":
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort
if FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP != "":
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP
elif FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus == 'stop':
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus
self.stop_tcp_data_package_service()
else:
if FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP != self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP or self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort != FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort:
if FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus == "start" or self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceStatus == "start":
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServicePort
self.stop_tcp_data_package_service()
self.start_tcp_data_package_service(
FTSServiceStartupConfigObject)
else:
self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP = FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP
if FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus == 'start':
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus
self.start_ssl_data_package_service(
FTSServiceStartupConfigObject)
if FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServicePort != "":
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServicePort = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServicePort
if FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP != "":
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP
elif FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus == 'stop':
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus
self.stop_ssl_data_package_service()
else:
if FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServicePort != "":
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServicePort = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServicePort
if FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP != self.FTSServiceStartupConfigObject.TCPDataPackageService.TCPDataPackageServiceIP:
if FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus or self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceStatus:
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP
self.stop_ssl_data_package_service()
self.start_ssl_data_package_service(
FTSServiceStartupConfigObject)
else:
self.FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP = FTSServiceStartupConfigObject.SSLDataPackageService.SSLDataPackageServiceIP
if FTSServiceStartupConfigObject.CoTService.CoTServiceStatus == 'start':
self.FTSServiceStartupConfigObject.CoTService.CoTServiceStatus = FTSServiceStartupConfigObject.CoTService.CoTServiceStatus
self.start_CoT_service(FTSServiceStartupConfigObject)
if FTSServiceStartupConfigObject.CoTService.CoTServicePort != "":
self.FTSServiceStartupConfigObject.CoTService.CoTServicePort = FTSServiceStartupConfigObject.CoTService.CoTServicePort
if FTSServiceStartupConfigObject.CoTService.CoTServiceIP != "":
self.FTSServiceStartupConfigObject.CoTService.CoTServiceIP = FTSServiceStartupConfigObject.CoTService.CoTServiceIP
elif FTSServiceStartupConfigObject.CoTService.CoTServiceStatus == 'stop':
self.FTSServiceStartupConfigObject.CoTService.CoTServiceStatus = FTSServiceStartupConfigObject.CoTService.CoTServiceStatus
self.stop_CoT_service()
else:
pass
if FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceStatus == 'start':
self.FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceStatus = FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceStatus
self.start_SSL_CoT_service(FTSServiceStartupConfigObject)
if FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServicePort != "":
self.FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServicePort = FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServicePort
if FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceIP != "":
self.FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceIP = FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceIP
elif FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceStatus == 'stop':
self.FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceStatus = FTSServiceStartupConfigObject.SSLCoTService.SSLCoTServiceStatus
self.stop_SSL_CoT_service()
else:
pass
if FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceStatus == 'start':
self.FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceStatus = FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceStatus
self.start_federation_client_service(
FTSServiceStartupConfigObject)
if FTSServiceStartupConfigObject.FederationClientService.FederationClientServicePort != "":
self.FTSServiceStartupConfigObject.FederationClientService.FederationClientServicePort = FTSServiceStartupConfigObject.FederationClientService.FederationClientServicePort
if FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceIP != "":
self.FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceIP = FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceIP
elif FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceStatus == 'stop':
self.FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceStatus = FTSServiceStartupConfigObject.FederationClientService.FederationClientServiceStatus
self.stop_federation_client_service()
else:
pass
if FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus == 'start':
self.FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus = FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus
self.start_federation_server_service(
FTSServiceStartupConfigObject)
if FTSServiceStartupConfigObject.FederationServerService.FederationServerServicePort != "":
self.FTSServiceStartupConfigObject.FederationServerService.FederationServerServicePort = FTSServiceStartupConfigObject.FederationServerService.FederationServerServicePort
if FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceIP != "":
self.FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceIP = FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceIP
elif FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus == 'stop' \
and self.FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus != 'stop':
self.FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus = FTSServiceStartupConfigObject.FederationServerService.FederationServerServiceStatus
self.stop_federation_server_service()
else:
pass
return 1
except Exception as e:
logger.error('there has been an exception in FTS start_all ' +
str(e))
return -1
def restart_receive_connection_process(self):
self.ReceiveConnectionsReset.set()
return 1
def receive_data_froCoT_service_thread(self, pipe, clientArray):
found = 0
try:
if not pipe.empty():
data = pipe.get()
self.socketCount = data[2]
if data[0] == 'add':
clientArray.append(data[1])
self.RestAPIPipe.put(data[1])
else:
for client in clientArray:
if client.ID == data[1].ID:
clientArray.remove(client)
found = 1
else:
pass
if found == 0:
for client in clientArray:
if client.IP == data[
1].IP and client.modelObject.detail.contact.callsign == data[
1].modelObject.detail.contact.callsign:
clientArray.remove(client)
found = 1
else:
pass
else:
pass
return self.clientArray
else:
return self.clientArray
except Exception as e:
return self.clientArray
def receive_Rest_commands(self, kill):
while kill.is_set() == False:
try:
command = self.RestAPICommandsFTS.get()
if isinstance(command, tuple):
self.FederationClientServicePipeFTS.put(command)
else:
function = getattr(self, command[0])
if len(command) >= 2:
output = function(command[1])
else:
output = function()
self.RestAPICommandsFTS.put(output)
except Exception as e:
logger.error(
'there has been an exception thrown in processing rest command '
+ str(e))
self.RestAPICommandsFTS.put('500')
def check_server_status(self):
return self.FTSServiceStartupConfigObject
def help(self):
print('start_all: to begin all services type')
print('start_CoT_service: to begin CoT service type')
print(
'start_data_package_service: to begin data package service type')
print('stop_all: to terminate all services type')
print('stop_CoT_service: to terminate CoT service type')
print('stop_data_package_service: to begin data package service type')
print('check_service_status: to check the status of the services type')
print('show_users: to show connected user information type')
print(
'start_federation_client_service: to begin federation with another server'
)
print('kill: to kill the full server type')
def show_users(self):
'''
this method is used only by commands submitted over the rest interface
'''
data = [['', '', '']]
objects = []
output = []
print(self.clientArray)
for client in self.clientArray:
data.append([
client.IP, client.modelObject.detail.contact.callsign,
client.modelObject.detail._group.name
])
for client in data:
simpleClient = SimpleClient()
simpleClient.callsign = client[1]
simpleClient.team = client[2]
simpleClient.ip = client[0]
objects.append(simpleClient)
output.append('total sockets: ' + str(self.socketCount))
print(output)
return objects
def verify_output(self, input, example=None):
try:
if example == None:
if input == None or input == -1:
return False
else:
return True
else:
if isinstance(input, example):
return True
else:
return False
except Exception as e:
logger.error(
'there has been an exception in FTS verifying output ' +
str(e))
return False
def stop_all(self):
try:
DataPackageServiceOutput = self.stop_data_package_service()
if self.verify_output(DataPackageServiceOutput):
pass
else:
raise Exception('error stopping DataPackage Service')
CoTServiceOutput = self.stop_CoT_service()
if self.verify_output(CoTServiceOutput):
pass
else:
raise Exception('error stopping CoT Service')
return 1
except Exception as e:
logger.error('there has been an exception in FTS stop_all ' +
str(e))
return -1
def kill(self):
try:
self.killSwitch = True
return 1
except Exception as e:
logger.error('error in kill function ' + str(e))
def checkPipes(self):
try:
for pipe in self.FilterGroup.sources:
try:
data = AddDataToCoTList().recv(
pipe, timeout=MainConfig.MainLoopDelay / 4000)
except Exception as e:
logger.error('get pipe data failed ' + str(e))
continue
#this runs in the event a new client has connected
try:
if isinstance(data, list):
AddDataToCoTList().send(self.FilterGroup.receivers,
data[0])
for client in self.clientArray:
AddDataToCoTList().send(self.FilterGroup.receivers,
client)
# this runs in all other cases in which data is received
elif data != 0 and data is not None:
AddDataToCoTList().send(self.FilterGroup.receivers,
data)
# this runs when a timeout is triggered
else:
pass
except Exception as e:
logger.error(
'processing received connection data failed ' + str(e))
except Exception as e:
logger.error('exception in checking pipes ' + str(e))
def startup(self,
CoTPort,
CoTIP,
DataPackagePort,
DataPackageIP,
SSLDataPackagePort,
SSLDataPackageIP,
RestAPIPort,
RestAPIIP,
SSLCoTPort,
SSLCoTIP,
AutoStart,
firstStart=False,
UI="False"):
try:
self.dbController.remove_user()
self.FTSServiceStartupConfigObject.RestAPIService.RestAPIServiceStatus = 'start'
self.FTSServiceStartupConfigObject.RestAPIService.RestAPIServicePort = RestAPIPort
self.FTSServiceStartupConfigObject.RestAPIServiceIP = RestAPIIP
if firstStart:
from datetime import datetime as dt
self.StartupTime = dt.now()
else:
pass
if AutoStart == 'False':
StartupObject = FTSObj()
StartupObject.RestAPIService.RestAPIServicePort = RestAPIPort
StartupObject.RestAPIService.RestAPIServiceIP = RestAPIIP
StartupObject.RestAPIService.RestAPIServiceStatus = 'start'
self.start_restAPI_service(StartupObject)
else:
StartupObject = FTSObj()
StartupObject.CoTService.CoTServiceIP = CoTIP
StartupObject.CoTService.CoTServicePort = CoTPort
StartupObject.CoTService.CoTServiceStatus = 'start'
StartupObject.TCPDataPackageService.TCPDataPackageServiceIP = DataPackageIP
StartupObject.TCPDataPackageService.TCPDataPackageServicePort = DataPackagePort
StartupObject.TCPDataPackageService.TCPDataPackageServiceStatus = 'start'
StartupObject.SSLDataPackageService.SSLDataPackageServiceIP = SSLDataPackageIP
StartupObject.SSLDataPackageService.SSLDataPackageServicePort = SSLDataPackagePort
StartupObject.SSLDataPackageService.SSLDataPackageServiceStatus = 'start'
StartupObject.RestAPIService.RestAPIServicePort = RestAPIPort
StartupObject.RestAPIService.RestAPIServiceIP = RestAPIIP
StartupObject.RestAPIService.RestAPIServiceStatus = 'start'
StartupObject.FederationClientService.FederationClientServiceStatus = 'start'
#StartupObject.FederationServerService.FederationServerServiceStatus = ''
StartupObject.SSLCoTService.SSLCoTServiceStatus = 'start'
StartupObject.SSLCoTService.SSLCoTServiceIP = SSLCoTIP
StartupObject.SSLCoTService.SSLCoTServicePort = SSLCoTPort
self.start_restAPI_service(StartupObject)
self.start_all(StartupObject)
while True:
time.sleep(MainConfig.MainLoopDelay / 1000)
try:
self.checkPipes()
except Exception as e:
logger.error("error in core FTS process Data Pipe " +
str(e))
try:
self.clientArray = self.receive_data_froCoT_service_thread(
self.ClientDataPipe, self.clientArray)
except Exception as e:
logger.error(
"error thrown receiving clients from tcp CoT pipe " +
str(e))
try:
self.clientArray = self.receive_data_froCoT_service_thread(
self.SSLClientDataPipe, self.clientArray)
except Exception as e:
logger.error(
"error thrown receiving clients from SSL CoT pipe " +
str(e))
except Exception as e:
logger.error('exception in the startup of FTS ' + str(e))
def addSystemUser(jsondata):
from FreeTAKServer.controllers import certificate_generation
import uuid
for systemuser in json.loads(jsondata)['systemUsers']:
if systemuser["Certs"] == "true":
# create certs
certificate_generation.AtakOfTheCerts().bake(cn=systemuser["Name"])
certificate_generation.generate_zip(
user_filename=systemuser["Name"] + '.p12')
# add DP
import string
import random
from pathlib import PurePath, Path
import hashlib
from lxml import etree
import shutil
import os
dp_directory = str(PurePath(Path(MainConfig.DataPackageFilePath)))
letters = string.ascii_letters
openfile = open(str(
PurePath(
Path(str(MainConfig.clientPackages),
systemuser["Name"] + '.zip'))),
mode='rb')
file_hash = str(hashlib.sha256(openfile.read()).hexdigest())
openfile.close()
newDirectory = str(PurePath(Path(dp_directory), Path(file_hash)))
os.mkdir(newDirectory)
shutil.copy(
str(
PurePath(
Path(str(MainConfig.clientPackages),
systemuser["Name"] + '.zip'))),
str(
PurePath(Path(newDirectory),
Path(systemuser["Name"] + '.zip'))))
fileSize = Path(str(newDirectory),
systemuser["Name"] + '.zip').stat().st_size
dbController.create_datapackage(uid=str(uuid.uuid4()),
Name=systemuser["Name"] + '.zip',
Hash=file_hash,
SubmissionUser='******',
CreatorUid='server-uid',
Size=fileSize,
Privacy=1)
DatabaseController().create_systemUser(
name=systemuser["Name"],
group=systemuser["Group"],
token=systemuser["Token"],
password=systemuser["Password"],
uid=str(uuid.uuid4()),
certificate_package_name=systemuser["Name"] + '.zip')
import datetime as dt
DATETIME_FMT = "%Y-%m-%dT%H:%M:%S.%fZ"
timer = dt.datetime
now = timer.utcnow()
zulu = now.strftime(DATETIME_FMT)
add = dt.timedelta(seconds=600)
stale_part = dt.datetime.strptime(zulu, DATETIME_FMT) + add
stale = stale_part.strftime(DATETIME_FMT)
timer = dt.datetime
now = timer.utcnow()
zulu = now.strftime(DATETIME_FMT)
time = zulu
from FreeTAKServer.controllers.SpecificCoTControllers.SendOtherController import SendOtherController
from FreeTAKServer.model.RawCoT import RawCoT
cot = RawCoT()
clientXML = f'<?xml version="1.0"?><event version="2.0" uid="{str(uuid.uuid4())}" type="b-f-t-r" time="{time}" start="{time}" stale="{stale}" how="h-e"><point lat="43.85570300" lon="-66.10801200" hae="19.55866360" ce="3.21600008" le="nan" /><detail><fileshare filename="{systemuser["Name"]}" senderUrl="{MainConfig.DataPackageServiceDefaultIP}:8080/Marti/api/sync/metadata/{str(file_hash)}/tool" sizeInBytes="{fileSize}" sha256="{str(file_hash)}" senderUid="{"server-uid"}" senderCallsign="{"server"}" name="{systemuser["Name"]+".zip"}" /><ackrequest uid="{uuid.uuid4()}" ackrequested="true" tag="{systemuser["Name"]+".zip"}" /><marti><dest callsign="{systemuser["Name"]}" /></marti></detail></event>'
cot.xmlString = clientXML.encode()
newCoT = SendOtherController(cot)
APIPipe.send(newCoT.getObject())
else:
DatabaseController().create_systemUser(
name=systemuser["Name"],
group=systemuser["Group"],
token=systemuser["Token"],
password=systemuser["Password"],
uid=str(uuid.uuid4()))
from flask_socketio import SocketIO, emit
from flask_cors import CORS
import json
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
from FreeTAKServer.controllers.configuration.MainConfig import MainConfig
from FreeTAKServer.controllers.configuration.RestAPIVariables import RestAPIVariables as vars
functionNames = vars()
functionNames.function_names()
app = Flask(__name__)
CORS(app)
socketio = SocketIO(app, async_handlers=True, async_mode="eventlet")
socketio.init_app(app, cors_allowed_origins="*")
dbController = DatabaseController()
def startup(self, APIPipea, CommandPipea, IP, Port, starttime):
global APIPipe, CommandPipe, StartTime
StartTime = starttime
APIPipe = APIPipea
CommandPipe = CommandPipea
socketio.run(app, host=IP, port=Port)
def socket_auth(session=None):
def innerfunc(x):
def wrapper(*args, **kwargs):
if hasattr(session, 'authenticated') and session.authenticated:
x(*args, **kwargs)
def start(self, pipe):
self.db = DatabaseController()
self.pipe = pipe
self._create_context()
print('started federation federate service')
self.main()
class Orchestrator:
#TODO: fix repeat attempts to add user
# default constructor def __init__(self):
def __init__(self):
log_format = logging.Formatter(loggingConstants.LOGFORMAT)
self.logger = logging.getLogger(loggingConstants.LOGNAME)
self.logger.setLevel(logging.DEBUG)
self.logger.addHandler(
self.newHandler(loggingConstants.DEBUGLOG, logging.DEBUG,
log_format))
self.logger.addHandler(
self.newHandler(loggingConstants.ERRORLOG, logging.ERROR,
log_format))
self.logger.addHandler(
self.newHandler(loggingConstants.INFOLOG, logging.INFO,
log_format))
# create necessary queues
self.clientInformationQueue = []
# this contains a list of all pipes which are transmitting CoT from clients
self.pipeList = []
# Internal Pipe used for CoT generated by the server itself
self.internalCoTArray = []
self.ClientReceptionHandlerEventPipe = ''
# health check events
self.healthCheckEventArray = []
# instantiate controllers
self.ActiveThreadsController = ActiveThreadsController()
self.ClientInformationController = ClientInformationController()
self.ClientInformationQueueController = ClientInformationQueueController(
)
self.ClientSendHandler = ClientSendHandler()
self.DataQueueController = DataQueueController()
self.ReceiveConnections = ReceiveConnections()
self.ReceiveConnectionsProcessController = ReceiveConnectionsProcessController(
)
self.MainSocketController = MainSocketController()
self.XMLCoTController = XMLCoTController()
self.SendClientData = SendClientData()
self.KillSwitch = 0
self.openSockets = 0
self.openSocketsArray = []
def clear_user_table(self):
self.dbController.remove_user()
print('user table cleared')
def testing(self):
"""
function which creates variables for testing
"""
from multiprocessing import Pipe
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
self.dbController = DatabaseController()
self.CoTSharePipe, other = Pipe()
return None
def newHandler(self, filename, log_level, log_format):
handler = RotatingFileHandler(filename,
maxBytes=loggingConstants.MAXFILESIZE,
backupCount=loggingConstants.BACKUPCOUNT)
handler.setFormatter(log_format)
handler.setLevel(log_level)
return handler
def sendUserConnectionGeoChat(self, clientInformation):
# TODO: refactor as it has a proper implementation of a PM to a user generated by the server
'''
function to create and send pm to connecting user
:param clientInformation:
:return:
'''
from FreeTAKServer.controllers.SpecificCoTControllers.SendGeoChatController import SendGeoChatController
from FreeTAKServer.model.RawCoT import RawCoT
from FreeTAKServer.model.FTSModel.Dest import Dest
import uuid
if OrchestratorConstants().DEFAULTCONNECTIONGEOCHATOBJ != None:
ChatObj = RawCoT()
ChatObj.xmlString = f'<event><point/><detail><remarks>{OrchestratorConstants().DEFAULTCONNECTIONGEOCHATOBJ}</remarks><marti><dest/></marti></detail></event>'
classobj = SendGeoChatController(ChatObj, AddToDB=False)
instobj = classobj.getObject()
instobj.modelObject.detail._chat.chatgrp.setuid1(
clientInformation.modelObject.uid)
dest = Dest()
dest.setcallsign(
clientInformation.modelObject.detail.contact.callsign)
instobj.modelObject.detail.marti.setdest(dest)
instobj.modelObject.detail._chat.setchatroom(
clientInformation.modelObject.detail.contact.callsign)
instobj.modelObject.detail._chat.setparent("RootContactGroup")
instobj.modelObject.detail._chat.setid(
clientInformation.modelObject.uid)
instobj.modelObject.detail._chat.setgroupOwner("True")
instobj.modelObject.detail.remarks.setto(
clientInformation.modelObject.uid)
instobj.modelObject.setuid(
'GeoChat.' + 'SERVER-UID.' +
clientInformation.modelObject.detail.contact.callsign + '.' +
str(uuid.uuid1()))
instobj.modelObject.detail._chat.chatgrp.setid(
clientInformation.modelObject.uid)
classobj.reloadXmlString()
SendDataController().sendDataInQueue(None, instobj,
self.clientInformationQueue)
return 1
else:
return 1
def clientConnected(self, rawConnectionInformation):
try:
# temporarily broken
# self.check_for_dead_sockets()
from FreeTAKServer.controllers.DatabaseControllers.EventTableController import EventTableController
clientPipe = None
self.logger.info(loggingConstants.CLIENTCONNECTED)
clientInformation = self.ClientInformationController.intstantiateClientInformationModelFromConnection(
rawConnectionInformation, clientPipe)
if self.checkOutput(clientInformation):
pass
else:
raise Exception('error in the creation of client information')
self.openSockets += 1
#breaks ssl
#self.ClientInformationQueueController.addClientToQueue(clientInformation)
self.clientInformationQueue.append(clientInformation)
try:
if hasattr(clientInformation.socket, 'getpeercert'):
cn = "placeholder"
else:
cn = None
CoTRow = EventTableController().convert_model_to_row(
clientInformation.modelObject)
self.dbController.create_user(
uid=clientInformation.modelObject.uid,
callsign=clientInformation.modelObject.detail.contact.
callsign,
IP=clientInformation.IP,
CoT=CoTRow,
CN=cn)
except Exception as e:
print(e)
self.logger.error(
'there has been an error in a clients connection while adding information to the database '
+ str(e))
#self.logger.info(loggingConstants.CLIENTCONNECTEDFINISHED + str(clientInformation.modelObject.detail.contact.callsign))
sock = clientInformation.socket
clientInformation.socket = None
self.clientDataPipe.put(
['add', clientInformation, self.openSockets])
clientInformation.socket = sock
self.sendUserConnectionGeoChat(clientInformation)
return clientInformation
except Exception as e:
self.logger.warning(loggingConstants.CLIENTCONNECTEDERROR + str(e))
return -1
def check_for_dead_sockets(self):
# fix function
try:
for sock in self.clientInformationQueue:
if sock.is_alive():
pass
else:
self.clientDisconnected(sock)
return 1
except Exception as e:
self.logger.error(
"there has been an exception in checking for dead sockets " +
str(e))
return -1
def emergencyReceived(self, processedCoT):
try:
if processedCoT.status == loggingConstants.ON:
self.internalCoTArray.append(processedCoT)
self.logger.debug(loggingConstants.EMERGENCYCREATED)
elif processedCoT.status == loggingConstants.OFF:
for CoT in self.internalCoTArray:
if CoT.type == "Emergency" and CoT.modelObject.uid == processedCoT.modelObject.uid:
self.internalCoTArray.remove(CoT)
self.logger.debug(loggingConstants.EMERGENCYREMOVED)
except Exception as e:
self.logger.error(loggingConstants.EMERGENCYRECEIVEDERROR + str(e))
def dataReceived(self, RawCoT):
# this will be executed in the event that the use case for the CoT isnt specified in the orchestrator
try:
# this will check if the CoT is applicable to any specific controllers
RawCoT = self.XMLCoTController.determineCoTType(RawCoT)
# the following calls whatever controller was specified by the above function
module = importlib.import_module(
'FreeTAKServer.controllers.SpecificCoTControllers.' +
RawCoT.CoTType)
CoTSerializer = getattr(module, RawCoT.CoTType)
#TODO: improve way in which the dbController is passed to CoTSerializer
RawCoT.dbController = self.dbController
processedCoT = CoTSerializer(RawCoT).getObject()
sender = processedCoT.clientInformation
# this will send the processed object to a function which will send it to connected clients
'''try:
# TODO: method of determining if CoT should be added to the internal array should
# be improved
if processedCoT.type == "Emergency":
self.emergencyReceived(processedCoT)
else:
pass
except Exception as e:
return -1'''
return processedCoT
except Exception as e:
self.logger.error(loggingConstants.DATARECEIVEDERROR + str(e))
return -1
def sendInternalCoT(self, client):
try:
if len(self.internalCoTArray) > 0:
for processedCoT in self.internalCoTArray:
SendDataController().sendDataInQueue(
processedCoT.clientInformation, processedCoT, [client])
else:
pass
self.send_active_emergencys(client)
return 1
except Exception as e:
self.logger.error(
loggingConstants.MONITORRAWCOTERRORINTERNALSCANERROR + str(e))
return -1
def send_active_emergencys(self, client):
"""
this function needs to be cleaned up however it's functionality is as follows
it query's the DB for active emergency's at which point it iterates over all
emergency objects, transforms them into model objects and then xmlStrings
finally the object is sent to the client.
"""
try:
from FreeTAKServer.model.SpecificCoT.SendEmergency import SendEmergency
from lxml import etree
emergencys = self.dbController.query_ActiveEmergency()
for emergency in emergencys:
emergencyobj = SendEmergency()
modelObject = Event.emergecyOn()
filledModelObject = SqlAlchemyObjectController(
).convert_sqlalchemy_to_modelobject(emergency.event,
modelObject)
# emergencyobj.setXmlString(XMLCoTController().serialize_model_to_CoT(filledModelObject))
emergencyobj.setXmlString(
etree.tostring((XmlSerializer().from_fts_object_to_format(
filledModelObject))))
print(emergencyobj.xmlString)
emergencyobj.setModelObject(filledModelObject)
SendDataController().sendDataInQueue(None, emergencyobj,
[client])
except Exception as e:
import traceback
self.logger.error(traceback.format_exc())
self.logger.error(
'an exception has been thrown in sending active emergencies ' +
str(e))
def clientDisconnected(self, clientInformation):
if hasattr(clientInformation, "clientInformation"):
clientInformation = clientInformation.clientInformation
try:
for client in self.clientInformationQueue:
if client.ID == clientInformation.ID:
self.clientInformationQueue.remove(client)
else:
pass
except AttributeError:
for client in self.clientInformationQueue:
if client.ID == clientInformation.clientInformation.ID:
self.clientInformationQueue.remove(client)
else:
pass
except Exception as e:
self.logger.critical("client removal failed " + str(e))
try:
self.ActiveThreadsController.removeClientThread(clientInformation)
self.dbController.remove_user(
query=f'uid = "{clientInformation.modelObject.uid}"')
except Exception as e:
self.logger.critical(
'there has been an error in a clients disconnection while adding information to the database '
+ str(e))
pass
if hasattr(clientInformation, 'clientInformation'):
clientInformation = clientInformation.clientInformation
else:
pass
try:
self.openSockets -= 1
socketa = clientInformation.socket
clientInformation.socket = None
self.clientDataPipe.put(
['remove', clientInformation, self.openSockets])
clientInformation.socket = socketa
try:
clientInformation.socket.shutdown(socket.SHUT_RDWR)
except Exception as e:
self.logger.error(
'error shutting socket down in client disconnection')
pass
try:
clientInformation.socket.close()
except Exception as e:
self.logger.error(
'error closing socket in client disconnection')
pass
self.logger.info(loggingConstants.CLIENTDISCONNECTSTART)
# TODO: remove string
tempXml = RawCoT()
tempXml.xmlString = '<event><detail><link uid="{0}"/></detail></event>'.format(
clientInformation.modelObject.uid).encode()
disconnect = SendDisconnectController(tempXml)
SendDataController().sendDataInQueue(
disconnect.getObject().clientInformation,
disconnect.getObject(), self.clientInformationQueue,
self.CoTSharePipe)
self.logger.info(
loggingConstants.CLIENTDISCONNECTEND +
str(clientInformation.modelObject.detail.contact.callsign))
return 1
except Exception as e:
self.logger.error(loggingConstants.CLIENTCONNECTEDERROR + " " +
str(e))
pass
def monitorRawCoT(self, data):
# this needs to be the most robust function as it is the keystone of the program
# this will attempt to define the type of CoT along with the designated controller
try:
if isinstance(data, int):
return None
else:
CoT = XMLCoTController().determineCoTGeneral(data)
function = getattr(self, CoT[0])
output = function(CoT[1])
return output
except Exception as e:
self.logger.error(loggingConstants.MONITORRAWCOTERRORB + str(e))
return -1
def checkOutput(self, output):
if output != -1 and output != None:
return True
else:
return False
def loadAscii(self):
ascii()
def mainRunFunction(self,
clientData,
receiveConnection,
sock,
pool,
event,
clientDataPipe,
ReceiveConnectionKillSwitch,
CoTSharePipe,
ssl=False):
print('server started')
import datetime
receiveconntimeoutcount = datetime.datetime.now()
lastprint = datetime.datetime.now()
while event.is_set():
self.CoTSharePipe = CoTSharePipe
try:
if ssl == True:
pass
self.clientDataPipe = clientDataPipe
if event.is_set():
try:
if ReceiveConnectionKillSwitch.is_set():
try:
receiveConnection.successful()
except:
pass
ReceiveConnectionKillSwitch.clear()
receiveConnection = pool.apply_async(
ReceiveConnections().listen, (sock, ))
else:
receiveConnectionOutput = receiveConnection.get(
timeout=0.01)
receiveConnection = pool.apply_async(
ReceiveConnections().listen, (
sock,
ssl,
))
receiveconntimeoutcount = datetime.datetime.now()
lastprint = datetime.datetime.now()
CoTOutput = self.handel_connection_data(
receiveConnectionOutput)
except multiprocessing.TimeoutError:
if (datetime.datetime.now() - receiveconntimeoutcount
) > datetime.timedelta(seconds=60) and ssl == True:
from multiprocessing.pool import ThreadPool
try:
pass
print('\n\nresetting\n\n')
pool.terminate()
pool = ThreadPool(processes=2)
self.pool = pool
receiveconntimeoutcount = datetime.datetime.now(
)
lastprint = datetime.datetime.now()
clientData = pool.apply_async(
ClientReceptionHandler().startup,
(self.clientInformationQueue, ))
receiveConnection = pool.apply_async(
ReceiveConnections().listen, (
sock,
ssl,
))
except Exception as e:
print(str(e))
elif ssl == True and (datetime.datetime.now() -
lastprint) > datetime.timedelta(
seconds=30):
print('time since last reset ' +
str(datetime.datetime.now() -
receiveconntimeoutcount))
lastprint = datetime.datetime.now()
else:
pass
except Exception as e:
self.logger.error(
'exception in receive connection within main run function '
+ str(e))
try:
clientDataOutput = clientData.get(timeout=0.01)
if self.checkOutput(clientDataOutput) and isinstance(
clientDataOutput, list):
CoTOutput = self.handel_regular_data(
clientDataOutput)
else:
raise Exception(
'client reception handler has returned data which is not of type list data is '
+ str(clientDataOutput))
clientData = pool.apply_async(
ClientReceptionHandler().startup,
(self.clientInformationQueue, ))
except multiprocessing.TimeoutError:
pass
except Exception as e:
#self.logger.info('exception in receive client data within main run function ' + str(e))
pass
try:
if not CoTSharePipe.empty():
# print('getting share pipe data')
data = CoTSharePipe.get()
CoTOutput = self.handel_shared_data(data)
else:
pass
except Exception as e:
self.logger.error(
'there has been an excepion in the handling of data supplied by the rest API '
+ str(e))
pass
else:
self.stop()
break
except Exception as e:
self.logger.info(
'there has been an uncaught error thrown in mainRunFunction'
+ str(e))
pass
self.stop()
def handel_shared_data(self, modelData):
try:
#print('\n \n handling shared data \n \n')
# print('data received within orchestrator '+str(modelData.xmlString))
if hasattr(modelData, 'clientInformation'):
output = SendDataController().sendDataInQueue(
modelData.clientInformation, modelData,
self.clientInformationQueue)
#
elif modelData.type == "connmessage":
self.internalCoTArray.append(modelData)
# this runs in the event of a new connection
else:
print(modelData)
output = SendDataController().sendDataInQueue(
None, modelData, self.clientInformationQueue)
except Exception as e:
self.logger.error("data base connection error " + str(e))
print(e)
def handel_regular_data(self, clientDataOutput):
try:
for clientDataOutputSingle in clientDataOutput:
try:
print('handling reg data')
if clientDataOutputSingle == -1:
continue
CoTOutput = self.monitorRawCoT(clientDataOutputSingle)
if CoTOutput == 1:
continue
elif self.checkOutput(CoTOutput):
output = SendDataController().sendDataInQueue(
CoTOutput.clientInformation, CoTOutput,
self.clientInformationQueue, self.CoTSharePipe)
if self.checkOutput(output) and isinstance(
output, tuple) == False:
pass
elif isinstance(output, tuple):
self.logger.error(
'issue sending data to client now disconnecting'
)
self.clientDisconnected(output[1])
else:
self.logger.error(
'send data failed in main run function with data '
+ str(CoTOutput.xmlString) + ' from client ' +
CoTOutput.clientInformation.modelObject.detail.
contact.callsign)
else:
raise Exception('error in general data processing')
except Exception as e:
self.logger.info(
'exception in client data, data processing within main run function '
+ str(e) + ' data is ' + str(CoTOutput))
pass
except Exception as e:
self.logger.info(
'exception in client data, data processing within main run function '
+ str(e) + ' data is ' + str(clientDataOutput))
except Exception as e:
self.logger.info(
"there has been an error iterating client data output " +
str(e))
return -1
return 1
def handel_connection_data(self, receiveConnectionOutput):
try:
print('handling conn data')
if receiveConnectionOutput == -1:
return None
CoTOutput = self.monitorRawCoT(receiveConnectionOutput)
if CoTOutput != -1 and CoTOutput != None:
output = SendDataController().sendDataInQueue(
CoTOutput, CoTOutput, self.clientInformationQueue,
self.CoTSharePipe)
if self.checkOutput(output):
self.logger.debug(
'connection data from client ' +
str(CoTOutput.modelObject.detail.contact.callsign) +
' successfully processed')
else:
raise Exception('error in sending data')
else:
pass
except Exception as e:
self.logger.error(
'exception in receive connection data processing within main run function '
+ str(e) + ' data is ' + str(CoTOutput))
return -1
self.sendInternalCoT(CoTOutput)
return 1
def start(self, IP, CoTPort, Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe):
try:
self.db = sqlite3.connect(DPConst().DATABASE)
os.chdir('../../../')
# create socket controller
self.MainSocketController.changeIP(IP)
self.MainSocketController.changePort(CoTPort)
sock = self.MainSocketController.createSocket()
#changed
from multiprocessing.pool import ThreadPool
pool = ThreadPool(processes=2)
self.pool = pool
clientData = pool.apply_async(ClientReceptionHandler().startup,
(self.clientInformationQueue, ))
receiveConnection = pool.apply_async(ReceiveConnections().listen,
(sock, ))
# instantiate domain model and save process as object
self.mainRunFunction(clientData, receiveConnection, sock, pool,
Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe)
except Exception as e:
self.logger.critical(
'there has been a critical error in the startup of FTS' +
str(e))
return -1
def stop(self):
self.clientDataPipe.close()
self.pool.terminate()
self.pool.close()
self.pool.join()
pass
for relationship in SqlAlchemyObject.__mapper__.relationships:
try:
y = str(relationship)
relationship = '.'.join(str(relationship).split('.', 1)[1::])
relationshipObject = getattr(SqlAlchemyObject, relationship)
if relationshipObject != None:
modelObjectInstance = getattr(modelObject, relationship)
setter = getattr(modelObject, 'set' + relationship)
setter(
self.convert_sqlalchemy_to_modelobject(
relationshipObject, modelObjectInstance))
else:
pass
except Exception as e:
print(str(e))
return modelObject
if __name__ == "__main__":
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
contr = DatabaseController().query_ActiveEmergency()
x = contr[0]
from FreeTAKServer.model.FTSModel.Event import Event
modelobj = Event.emergecyOn()
y = SqlAlchemyObjectController().convert_sqlalchemy_to_modelobject(
x.event, modelobj)
1 == 1
def excheck_table():
try:
from os import listdir
from pathlib import PurePath, Path
from datetime import datetime
from flask import request
if request.method == "GET":
jsondata = {"ExCheck": {'Templates': [], 'Checklists': []}}
from FreeTAKServer.controllers.ExCheckControllers.templateToJsonSerializer import templateSerializer
excheckTemplates = DatabaseController().query_ExCheck()
for template in excheckTemplates:
templateData = template.data
templatejson = {
"filename":
templateData.filename,
"name":
templateData.keywords.name,
"submissionTime":
templateData.submissionTime,
"submitter":
str(
dbController.query_user(
query=f'uid == "{template.creatorUid}"',
column=['callsign'])),
"uid":
templateData.uid,
"hash":
templateData.hash,
"size":
templateData.size,
"description":
templateData.keywords.description
}
jsondata["ExCheck"]['Templates'].append(templatejson)
excheckChecklists = DatabaseController().query_ExCheckChecklist()
for checklist in excheckChecklists:
try:
templatename = checklist.template.data.name
except AttributeError:
templatename = "template removed"
checklistjson = {
"filename":
checklist.filename,
"name":
checklist.name,
"startTime":
datetime.strftime(checklist.startTime,
"%Y-%m-%dT%H:%M:%S.%fZ"),
"submitter":
checklist.callsign,
"uid":
checklist.uid,
"description":
checklist.description,
"template":
templatename
}
jsondata["ExCheck"]['Checklists'].append(checklistjson)
return json.dumps(jsondata), 200
elif request.method == "DELETE":
jsondata = request.data
ExCheckArray = json.loads(jsondata)["ExCheck"]
for item in ExCheckArray["Templates"]:
templateitem = DatabaseController().query_ExCheck(
f'ExCheckData.uid == "{item["uid"]}"', verbose=True)[0]
os.remove(
str(
PurePath(Path(MainConfig.ExCheckFilePath),
Path(templateitem.data.filename))))
DatabaseController().remove_ExCheck(
f'PrimaryKey == "{templateitem.PrimaryKey}"')
for item in ExCheckArray["Checklists"]:
checklistitem = DatabaseController().query_ExCheckChecklist(
f'uid == "{item["uid"]}"')[0]
os.remove(
str(
PurePath(Path(MainConfig.ExCheckChecklistFilePath),
Path(checklistitem.filename))))
DatabaseController().remove_ExCheckChecklist(
f'uid == "{item["uid"]}"')
return 'success', 200
elif request.method == "POST":
try:
import uuid
from FreeTAKServer.controllers.ExCheckControllers.templateToJsonSerializer import templateSerializer
xmlstring = f'<?xml version="1.0"?><event version="2.0" uid="{uuid.uuid4()}" type="t-x-m-c" time="2020-11-28T17:45:51.000Z" start="2020-11-28T17:45:51.000Z" stale="2020-11-28T17:46:11.000Z" how="h-g-i-g-o"><point lat="0.00000000" lon="0.00000000" hae="0.00000000" ce="9999999" le="9999999" /><detail><mission type="CHANGE" tool="ExCheck" name="exchecktemplates" authorUid="S-1-5-21-2720623347-3037847324-4167270909-1002"><MissionChanges><MissionChange><contentResource><filename>61b01475-ad44-4300-addc-a9474ebf67b0.xml</filename><hash>018cd5786bd6c2e603beef30d6a59987b72944a60de9e11562297c35ebdb7fd6</hash><keywords>test init</keywords><keywords>dessc init</keywords><keywords>FEATHER</keywords><mimeType>application/xml</mimeType><name>61b01475-ad44-4300-addc-a9474ebf67b0</name><size>1522</size><submissionTime>2020-11-28T17:45:47.980Z</submissionTime><submitter>wintak</submitter><tool>ExCheck</tool><uid>61b01475-ad44-4300-addc-a9474ebf67b0</uid></contentResource><creatorUid>S-1-5-21-2720623347-3037847324-4167270909-1002</creatorUid><missionName>exchecktemplates</missionName><timestamp>2020-11-28T17:45:47.983Z</timestamp><type>ADD_CONTENT</type></MissionChange></MissionChanges></mission></detail></event>'
# this is where the client will post the xmi of a template
from datetime import datetime
from lxml import etree
import hashlib
# possibly the uid of the client submitting the template
authoruid = request.args.get('clientUid')
if not authoruid:
authoruid = 'server-uid'
XMI = request.data.decode()
serializer = templateSerializer(XMI)
object = serializer.convert_template_to_object()
object.timestamp = datetime.strptime(object.timestamp,
"%Y-%m-%dT%H:%M:%S.%fZ")
serializer.create_DB_object(object)
xml = etree.fromstring(XMI)
path = str(
PurePath(Path(MainConfig.ExCheckFilePath),
Path(f'{object.data.uid}.xml')))
with open(path, 'w+') as file:
file.write(XMI)
file.close()
uid = object.data.uid
temp = etree.fromstring(XMI)
cot = etree.fromstring(xmlstring)
cot.find('detail').find('mission').set("authorUid", authoruid)
resources = cot.find('detail').find('mission').find(
'MissionChanges').find('MissionChange').find(
'contentResource')
resources.find('filename').text = temp.find(
'checklistDetails').find('uid').text + '.xml'
resources.findall('keywords')[0].text = temp.find(
'checklistDetails').find('name').text
resources.findall('keywords')[1].text = temp.find(
'checklistDetails').find('description').text
resources.findall('keywords')[2].text = temp.find(
'checklistDetails').find('creatorCallsign').text
resources.find('uid').text = temp.find(
'checklistDetails').find('uid').text
resources.find('name').text = temp.find(
'checklistDetails').find('uid').text
resources.find('size').text = str(len(XMI))
resources.find('hash').text = str(
hashlib.sha256(str(XMI).encode()).hexdigest())
z = etree.tostring(cot)
from FreeTAKServer.model.testobj import testobj
object = testobj()
object.xmlString = z
APIPipe.send(object)
return str(uid), 200
except Exception as e:
print(str(e))
except Exception as e:
return str(e), 500
from FreeTAKServer.controllers.configuration.RestAPIVariables import RestAPIVariables as vars from FreeTAKServer.model.SimpleClient import SimpleClient from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController from FreeTAKServer.controllers.configuration.DatabaseConfiguration import DatabaseConfiguration from FreeTAKServer.controllers.RestMessageControllers.SendChatController import SendChatController import os import shutil import json from flask_cors import CORS from FreeTAKServer.controllers.RestMessageControllers.SendSimpleCoTController import SendSimpleCoTController from FreeTAKServer.controllers.RestMessageControllers.SendPresenceController import SendPresenceController from FreeTAKServer.controllers.RestMessageControllers.SendEmergencyController import SendEmergencyController from FreeTAKServer.controllers.configuration.MainConfig import MainConfig from FreeTAKServer.controllers.JsonController import JsonController dbController = DatabaseController() UpdateArray = [] StartTime = None functionNames = vars() functionNames.function_names() jsonVars = vars() jsonVars.json_vars() restMethods = vars() restMethods.rest_methods() defaultValues = vars() defaultValues.default_values()
def create_DB_object(self, templateObject):
self.DataBase = DatabaseController()
output = self.DataBase.create_ExCheck(templateObject)
self.DataBase.shutdown_Connection()
return output