guest_worker/server_test.py

import argparse
import json
import logging
import os
import tornado.ioloop
import tornado.web
import tornado.websocket
from urllib.parse import urlparse
import uuid

import coloredlogs
import glob

from pyaxidraw import axidraw   # import module
from threading import Thread
from queue import Queue, Empty
import threading



logger = logging.getLogger("drawing")

argParser = argparse.ArgumentParser(description='Start up the server to have non-Mechanical Turks draw their sketches.')
argParser.add_argument(
        '--port',
        '-p',
        default=8888,
        help='The port for the server to listen'
    )
argParser.add_argument(
        '--verbose',
        '-v',
        action="store_true",
    )

generated_image_dir = os.path.join('www','generated')

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 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):
    CORS_ORIGINS = ['localhost', '.mturk.com', 'here.rubenvandeven.com']
    connections = set()
    
    def initialize(self, draw_q: Queue):
        self.draw_q = draw_q

    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)
        logger.info(f"New client connected: {self.request.remote_ip}")
        self.strokes = []
#         self.write_message("hello!")

    # the client sent the message
    def on_message(self, message):
        logger.debug(f"recieve: {message}")
        try:
            msg = json.loads(message)
            # TODO: sanitize input: min/max, limit strokes
            if msg['action'] == 'move':
                # TODO: min/max input
                point = [float(msg['direction'][0]),float(msg['direction'][1]), bool(msg['mouse'])]
                self.strokes.append(point)
                self.draw_q.put(point)
                
            elif msg['action'] == 'up':
                logger.info(f'up: {msg}')
                point = [msg['direction'][0],msg['direction'][1], 1]
                self.strokes.append(point)
                
            elif msg['action'] == 'submit':
                logger.info(f'up: {msg}')
                id = self.submit_strokes()
                if not id:
                    self.write_message(json.dumps('error'))
                    return
                
                self.write_message(json.dumps({
                    'action': 'submitted',
                    'msg': f"Submission ok, please refer to your submission as: {id}"
                    }))
            elif msg['action'] == 'down':
                # not used, implicit in move?
                pass
            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}")
    
    def submit_strokes(self):
        if len(self.strokes) < 1:
            return False
        
        d = strokes2D(self.strokes)
        svg = f"""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
        <svg viewBox="0 0 600 600"
       xmlns:dc="http://purl.org/dc/elements/1.1/"
       xmlns:cc="http://creativecommons.org/ns#"
       xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
       xmlns:svg="http://www.w3.org/2000/svg"
       xmlns="http://www.w3.org/2000/svg"
       version="1.1"
        >
        <path d="{d}" style="stroke:black;stroke-width:2;fill:none;" />
        </svg>
        """
        
        id = uuid.uuid4().hex
        
        filename = os.path.join(generated_image_dir , id+'.svg')
        with open(filename, 'w') as fp:
            logger.info(f"Wrote {filename}")
            fp.write(svg)
        
        return id

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


class LatestImageHandler(tornado.web.RequestHandler):
    def get(self):
        self.set_header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
        self.set_header("Content-Type", "image/svg+xml")
        
        list_of_files = glob.glob(os.path.join(generated_image_dir,'*.svg'))
        latest_file = max(list_of_files, key=os.path.getctime)
        with open(latest_file, 'r') as fp:
            self.write(fp.read())

def axiDrawCueListener(q: Queue, isRunning: threading.Event):
    ad = axidraw.AxiDraw()
    
    try:
        ad.interactive()
        
        ad.connect()
        ad.options.units = 1 # set to use centimeters instead of inches
        ad.options.accel = 100;
        ad.options.speed_penup = 100
        ad.options.speed_pendown = 100
        ad.options.model = 2 # A3, set to 1 for A4
        
        ad.moveto(0,0)
        
        plotterWidth = 22
        plotterHeight = 18 # 16?
            
        while isRunning.is_set():
            # TODO: set timeout on .get() with catch block, so we can escape if no moves come in
            try:
                move = draw_q.get(True, 1)
            except Empty as e:
                logger.log(5, "Empty queue.")
            else:
                ad.moveto(move[0]* plotterWidth, move[1]*plotterHeight)
                print('handler!',move)
    except Exception as e:
        logger.exception(e)
    finally:
        logger.warning("Close Axidraw connection")
        ad.moveto(0,0)
        ad.disconnect()

if __name__ == "__main__":
    args = argParser.parse_args()
    
    coloredlogs.install(
        level=logging.DEBUG if args.verbose else logging.INFO,
    )
    
    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(
        'mt_server.log',
        maxBytes=1024*512,
        backupCount=5
    )
    logFileHandler.setFormatter(formatter)
    logger.addHandler(
        logFileHandler
    )
    
    draw_q = Queue()
    isRunning = threading.Event()
    isRunning.set()
    
    thread = Thread(target = axiDrawCueListener, args = (draw_q, isRunning))
    thread.start()

    try:
        application = tornado.web.Application([
            (r"/ws(.*)", WebSocketHandler, {'draw_q': draw_q}),
            (r"/latest.svg", LatestImageHandler), # TODO: have js request the right image, based on a 'start' button. This way we can trace the history of a drawing
            (r"/(.*)", StaticFileWithHeaderHandler,
                {"path": 'www', "default_filename": 'index.html'}),
        ], debug=True)
        application.listen(args.port)
        tornado.ioloop.IOLoop.current().start()
    finally:
        isRunning.clear()