server.py

# authors: Julien DAVID & Ismail MOUMNI
import socket
import json
import datetime
import os
import sys
sys.path.append(os.path.realpath('../softwares/'))
import database as db

__RDOS_Dict__ = {"parameters": "request"}

# tools List
__RDOS_Tool__ = db.list_generator()


class RdosServer:

    # Function server_conn creates a socket and listens on port 9393
    # Function input address : SERVER IP ADRESS & Port server Port
    # Function output query send from client to server
    def server_conn(address, PORT):
        __RDOS_Tool__ = db.list_generator()
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as serv:
            serv.bind((address, PORT))
            # Listening to 5 CLients
            serv.listen(5)
            while 1:
                # accepting the connection from client and getting client IP
                conn, addr = serv.accept()
                if conn:
                    print('Connexion acceptee depuis l IP : ', addr)
                    # Receiving Data from Client
                    data = conn.recv(4096)
                    query = (json.loads(data.decode('utf-8')))
                    print("Requete reçu : ", query)
                    #query = json_to_dict(req)
                    if(query is not None):
                        # Sending GENERATORS
                        print(query)
                        if (match_query_dict(query, __RDOS_Dict__)):
                            response = db.get_generators()
                            conn.send(bytes(json.dumps(response), "utf-8"))
                            print("database generators ", response)
                            conn.close()
                        # Inserting client query in DATABASE
                        else:
                            print("check", check_and_complete_parameters(query))
                            db_server_insert(conn, query_client(addr, check_and_complete_parameters(query)))
                            print("query received : ", query)
                            conn.send(bytes(json.dumps("{'etat':'inserted'}"), "utf-8"))
                            conn.close()


def query_client(addr, data):
    sa = __RDOS_Tool__.get(list(data.keys())[0])
    lm = list((data.values()))
    s = {"id": "", "idGenerator": "", "IP": "", "timeSubmitted": "", "timeExecuted": "", "timeFinished": "", "status": "", "parametersJSON": "", "directory": "", "url": "", "message": "", "email": ""}
    s["id"] = str(os.getuid())
    s["idGenerator"] = str(sa)
    s["IP"] = str(addr[0])
    s["timeSubmitted"] = (str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
    s["parametersJSON"] = json.dumps(lm[0])
    print(s)
    return s


# Function query_valwid matches the query send from client side
#  with the the parameter dict
# Function input dictionary from client
# Function output boolean true if match else False
def query_valid(data: dict):
    if data != {}:
        print("heyhey", data)
        print(data[parameters])
        if (data["parameters"] == 'response'):
            return True
        else:
            return False
    else:
        raise Exception("Dictionnaire Vide!!")


# Function json_loads changes a json file into a Dict
# Function json_loads returns a dictionary
def json_to_dict(js):
    if js is not None:
        data = json.loads(js)
        return data
    else:
        raise Exception("Dictionnaire Vide!!")


# Function db_req sends a request to get parameters of tools from database
# Function takes a dictionary for input
# Function return a Dict containing tool parameters and default parameters
def db_req(tool: dict):
    if dict is not None:
        tool_dict = db.getParameters(tool)
        return tool_dict
    else:
        raise Exception("Dictionnaire Vide!!")


# Function match_dict returns non existing fields in a dict
# Function input biblio and dict
# Function returns a list containing missing values
def missing_keys(biblio: dict, gen: dict):
    missing = []
    if(biblio is not None and gen is not None):
        for key in biblio:
            if key not in gen:
                missing.append(key)
        return missing
    else:
        raise Exception("Dictionnaire Vide!!")


# Function match_query_dict matches two dictionaries
# Function input takes 2 dictionaries to match
# Function output return trur if dictionaries matches else raise a value error exception
def match_query_dict(biblio: dict, data: dict):
    if biblio is not None and data is not None:
        return biblio.keys() == data.keys()
    else:
        raise ValueError("Error Dict Values ")


# Function check_and_complete_parameters verifies json send from client to server by matching it with database query
# Function input takes a dictionary
# Function output returns query if it matches with database query keys if not it raises an error
def check_and_complete_parameters(data):
    if data is not None:
        tool = list(data.keys())[0]
        s = db.getParameters({tool})
        parameter = {}
        query = {}
        if s is not None:
            gen = s[0]
            parameter = s[1]
            q = data.get(tool)
            if match_query_dict(parameter.get(tool), q):
                check_and_replace(data.get(tool), parameter.get(tool))
                return data
            else:
                raise Exception("Query Doesn't match")
        else:
            raise Exception("Error Database")
    else:
        raise Exception("Dictionnaire Vide!!")


# Function check_and_replace checks query with that and replaces the empty values
# Function input takes 2 dictionaries
# Function output returns matched query
def check_and_replace(query, data):
    if query is not None and data is not None:
        for a, b in query.items():
            if b == '':
                query[a] = data.get(a)
    return query


# Function db_generators returns database generators
# Function takes a dictionary request from client side
# Function returns all database generators or raises an error if request doesn't match
def db_generators(req: dict):
    if req is not None:
        match = {"request": "generators"}
        if(req == match):
            s = db.get_generators()
            return s
        else:
            raise Exception("Dictionnaire non Valid")
    else:
        raise Exception("Dictionnaire Vide!!")


# Function db_insert send a query to insert in database by socket
# Function db_insert takes a socket and dictionary for input
# Function db_insert returns a string if query send
def db_server_insert(s: socket, req: dict):
    if(req is not None):
        ins = db.db_insert(req)
        s.send(bytes(json.dumps(ins), "utf-8"))
        print("Query send")
    else:
        raise Exception("Invalid Query")


if __name__ == '__main__':
    # TEST FOR Docker
    RdosServer.server_conn('127.0.0.1', '9393')