chronodiagram/webserver.py

import json
import logging
import os
import tornado.ioloop
import tornado.web
import tornado.websocket
from urllib.parse import urlparse
import uuid
import datetime
import html
import argparse
import coloredlogs
import glob
import csv




class DateTimeEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, datetime.datetime):
            return o.isoformat(timespec='milliseconds')

        return super().default(self, o)

class StaticFileWithHeaderHandler(tornado.web.StaticFileHandler):
    def set_extra_headers(self, path):
        """For subclass to add extra headers to the response"""
        if path[-5:] == '.html':
            self.set_header("Access-Control-Allow-Origin", "*")
        if path[-4:] == '.svg':
            self.set_header("Content-Type", "image/svg+xml")


class WebSocketHandler(tornado.websocket.WebSocketHandler):
    """
    Websocket from the workers
    """
    # CORS_ORIGINS = ['localhost']
    connections = set()

    def initialize(self, config):
        self.config = config
        self.strokes = []
        self.hasWritten = False
        self.dimensions = [None, None]

    # def check_origin(self, origin):
    #     parsed_origin = urlparse(origin)
    #     # parsed_origin.netloc.lower() gives localhost:3333
    #     valid = any([parsed_origin.hostname.endswith(origin) for origin in self.CORS_ORIGINS])
    #     return valid

    # the client connected
    def open(self, p = None):
        self.__class__.connections.add(self)
        self.strokes = []
        self.prefix = datetime.datetime.now().strftime('%Y-%m-%d-')
        self.filename = self.prefix + str(self.check_filenr()) + '-' + uuid.uuid4().hex[:6]
        print(self.filename)
        self.write_message(json.dumps({
            "filename": self.filename
        }))

    def check_filenr(self):
        files = glob.glob(os.path.join(self.config.storage, self.prefix +'*'))
        return len(files) + 1
        

    # the client sent the message
    def on_message(self, message):
        logger.info(f"recieve: {message}")

        try:
            msg = json.loads(message)
            if msg['action'] == 'stroke':
                print('stroke!')
                self.strokes.append([msg['color'], msg['points']])

                with open(os.path.join(self.config.storage,self.filename +'.csv'), 'a') as fp:
                    writer = csv.writer(fp, delimiter=';')
                    if not self.hasWritten:
                        #metadata to first row, but only on demand
                        writer.writerow([datetime.datetime.now().strftime("%Y-%m-%d %T"), self.dimensions[0], self.dimensions[1]])
                        self.hasWritten = True

                    # first column is color, rest is points
                    writer.writerow([msg['color']] +[coordinate for point in msg['points'] for coordinate in point[:4]])


            elif msg['action'] == 'dimensions':
                self.dimensions = [int(msg['width']), int(msg['height'])]
                logger.info(f"{self.dimensions=}")


            else:
                # self.send({'alert': 'Unknown request: {}'.format(message)})
                logger.warn('Unknown request: {}'.format(message))

        except Exception as e:
            # self.send({'alert': 'Invalid request: {}'.format(e)})
            logger.exception(e)

    # client disconnected
    def on_close(self):
        self.__class__.rmConnection(self)
            
        logger.info(f"Client disconnected: {self.request.remote_ip}")
        

    @classmethod
    def rmConnection(cls, client):
        if client not in cls.connections:
            return
        cls.connections.remove(client)
        
    @classmethod
    def hasConnection(cls, client):
        return client in cls.connections
        

class AnimationHandler(tornado.web.RequestHandler):
    def initialize(self, config):
        self.config = config

    def get(self, filename):
        self.set_header("Content-Type", "application/json")
        # filename = self.get_argument("file", None)
        if filename == '':
            names = sorted([f"/files/{name[:-4]}" for name in os.listdir(self.config.storage) if name not in ['.gitignore']])
            self.write(json.dumps(names))
        else:
            path = os.path.join(self.config.storage,os.path.basename(filename)+".csv")
            drawing = {
                "shape": []
            }
            with open(path, 'r') as fp:
                strokes = csv.reader(fp,delimiter=';')
                for i, stroke in enumerate(strokes):
                    if i == 0:
                        # metadata on first line
                        drawing['time'] = stroke[0]
                        drawing['dimensions'] = [stroke[1], stroke[2]]
                        continue
                    color = stroke.pop(0)
                    points = []
                    for i in range(int(len(stroke) / 4)):
                        p =  stroke[i*4:i*4+4]
                        points.append([float(p[0]), float(p[1]), int(p[2]), float(p[3])])
                    drawing['shape'].append({
                        'color': color,
                        'points': points
                    }) 
            self.write(json.dumps(drawing))

def strokes2D(strokes):
    # strokes to a d attribute for a path
    d = "";
    last_stroke = None;
    cmd = "";
    for stroke in strokes:
        if not last_stroke:
            d += f"M{stroke[0]},{stroke[1]} "
            cmd = 'M'
        else:
            if  last_stroke[2] == 1:
                d += " m"
                cmd = 'm'
            elif cmd != 'l':
                d+=' l '
                cmd = 'l'

            rel_stroke = [stroke[0] - last_stroke[0], stroke[1] - last_stroke[1]];
            d += f"{rel_stroke[0]},{rel_stroke[1]} "
        last_stroke = stroke;
    return d;

class Server:
    """
    Server for HIT -> plotter events
    As well as for the Status interface
    """
    loop = None

    def __init__(self, config, logger):
        self.config = config
        self.logger = logger

        #self.config['server']['port']
        self.web_root = os.path.join('www')


    def start(self):
            application = tornado.web.Application([
                (r"/ws(.*)", WebSocketHandler, {
                    'config': self.config,
                }),
                
                (r"/files/(.*)", AnimationHandler,
                    {'config': self.config}),
                (r"/(.*)", StaticFileWithHeaderHandler,
                    {"path": self.web_root}),
            ], debug=True, autoreload=True)
            application.listen(self.config.port)
            tornado.ioloop.IOLoop.current().start()
           

if __name__ == "__main__":
    argParser = argparse.ArgumentParser(
            description='Start up the vector animation server')
    # argParser.add_argument(
    #     '--config',
    #     '-c',
    #     required=True,
    #     type=str,
    #     help='The yaml config file to load'
    # )
    argParser.add_argument(
        '--port',
        type=int,
        default=7890,
        help='Port'
    )
    argParser.add_argument(
        '--storage',
        type=str,
        default='files',
        help='directory name for output files'
    )
    argParser.add_argument(
        '--verbose',
        '-v',
        action='count', default=0
    )

    args = argParser.parse_args()

    loglevel = logging.NOTSET if args.verbose > 1 else logging.DEBUG if args.verbose > 0  else logging.INFO

    coloredlogs.install(
        level=loglevel,
#       default: "%(asctime)s %(hostname)s %(name)s[%(process)d] %(levelname)s %(message)s"
        fmt="%(asctime)s %(hostname)s %(name)s[%(process)d,%(threadName)s] %(levelname)s %(message)s"
    )

    # File logging
    formatter = logging.Formatter(fmt='%(asctime)s %(module)s:%(lineno)d %(levelname)8s | %(message)s',
                                        datefmt='%Y/%m/%d %H:%M:%S') # %I:%M:%S %p AM|PM format
    logFileHandler = logging.handlers.RotatingFileHandler(
        'log/draw_log.log',
        maxBytes=1024*512,
        backupCount=5
    )
    logFileHandler.setFormatter(formatter)

    logger = logging.getLogger("sorteerhoed")
    logger.addHandler(
        logFileHandler
    )
    logger.info("Start server")
    
    server = Server(args, logger)
    server.start()