coapserver.py

#!/usr/bin/env python
import getopt
import sys
import threading
import _thread
import time
import datetime
import json
import triangulation
from coapthon.server.coap import CoAP
from exampleresources import BleInfoResource, RpNodeInfoResource, RpGraphInfoResource
from pymongo import MongoClient

class CoAPServer(CoAP):
    def __init__(self, host, port, multicast=False): # complete
        CoAP.__init__(self, (host, port), multicast)
        self.add_resource('bleInfoPath/', BleInfoResource())
        self.add_resource('rpNodeInfoPath/', RpNodeInfoResource())
        self.add_resource('rpGraphInfoPath/', RpGraphInfoResource())

        print(("CoAP Server start on " + host + ":" + str(port)))
        print((self.root.dump()))

        try:
            self.conn = MongoClient('mongodb://iotuser:iotsystem@localhost/IoT_System', 27017)
            self.db = self.conn.IoT_System
            self.piNodeCollection = self.db.RpNodeData
            self.userNodeCollection = self.db.UserNodeData
            self.trackingCollection = self.db.TrackingData
            self.usersCollection = self.db.users
            self.updatePeriod = 1.5
            self.limitDistance = 40
        except:
            print("Could not connect to MongoDB")

    def updateUserLocation(self): # complete
        try:
            while True:
                cursor = self.usersCollection.find()
                for c in cursor:
                    positionCalculationThread = threading.Thread(target = self.positionCalculation, args=([c['uuid']]))
                    positionCalculationThread.start()
                time.sleep(self.updatePeriod + 0.1)
                currentTime = time.time()
                trackingCursor = self.trackingCollection.remove({'updateTime': {'$lte' : currentTime - self.updatePeriod}})
        except KeyboardInterrupt:
            print("existing updateUserLocation")
    
    def positionCalculation(self, useruuid): # complete but need to check triangulation.py
        print(useruuid)
        currentTime = time.time()
        trackingCursor = self.trackingCollection.find({'$and':[{'useruuid': useruuid},
        {'updateTime':{'$gt' : currentTime - self.updatePeriod}},{'distance': {'$lt' : self.limitDistance}}]})
        #trackingCursor = self.trackingCollection.find({'$and':[{'useruuid':{'$eq' : useruuid}}]})
        userLocationData =[]

        flag = 0
        for c in trackingCursor:
            for i in userLocationData:
                if i['rpuuid'] == c['rpuuid']:
                    i['sum']+= c['distance']
                    i['count']+=1
                    i['distance'] = i['sum']/i['count']
                    flag = 1
                    break
            if flag == 0:
                userLocationData.append({
                    'rpuuid': c['rpuuid'],
                    'distance': c['distance'],
                    'sum': c['distance'],
                    'count':1
                })
            flag = 0

        userLocationData = sorted(userLocationData, key=lambda k: k['distance'], reverse = False)
        for u in userLocationData:
            print(userLocationData)

        if len(userLocationData) < 3:
            print("userLoicationData < 3")
            return

        nodeList = []
        for i in range(3):
            nodeList.append({
                'x': self.piNodeCollection.find({'rpuuid': userLocationData[i]['rpuuid']})[0]['x'],
                'y': self.piNodeCollection.find({'rpuuid': userLocationData[i]['rpuuid']})[0]['y'],
                'distance': userLocationData[i]['distance']
            })

        triangulationInst = triangulation.Triangulation(nodeList[:3])
        x, y = triangulationInst.doTriangulation()

        if x == None:
            print("no solution")
            return

        dd = datetime.datetime.now()
        dd = dd.replace(hour=dd.hour + 9)
        userNodeData = {
            'rp1': {'rpuuid' : userLocationData[0]['rpuuid'], 'distance': userLocationData[0]['distance']},
            'rp2': {'rpuuid' : userLocationData[1]['rpuuid'], 'distance' : userLocationData[1]['distance']},
            'rp3': {'rpuuid' : userLocationData[2]['rpuuid'], 'distance' : userLocationData[2]['distance']},
            'useruuid': useruuid,
            'x': x,
            'y': y,
            'updateTime': str(dd)
        }
        print(userNodeData)
        self.userNodeCollection.insert_one(userNodeData)

def usage():  # pragma: no cover
    print("coapserver.py -i <ip address> -p <port>")


def main(argv):  # pragma: no cover
    ip = "0.0.0.0"
    port = 5683
    multicast = False
    try:
        opts, args = getopt.getopt(argv, "hi:p:m", ["ip=", "port=", "multicast"])
    except getopt.GetoptError:
        usage()
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            usage()
            sys.exit()
        elif opt in ("-i", "--ip"):
            ip = arg
        elif opt in ("-p", "--port"):
            port = int(arg)
        elif opt in ("-m", "--multicast"):
            multicast = True

    server = CoAPServer(ip, port, multicast)
    try:
        updateUserLocationThread = threading.Thread(target = server.updateUserLocation)
        updateUserLocationThread.start()
        server.listen(10)

    except KeyboardInterrupt:
        print("Server Shutdown")
        server.close()
        print("Exiting...")


if __name__ == "__main__":  # pragma: no cover
    main(sys.argv[1:])