~azzar1/unity/add-show-desktop-key

#!/usr/bin/python

# usage:

#   python-console <port> <magic>

import sys

import web

import md5

import codeop

import cjson

import cgi

import cStringIO

import signal

import Queue

from threading import Thread

class StdinFromWeb(object):

    def __init__(self, cmdQ, lineQ):

        self.cmdQ = cmdQ

        self.lineQ = lineQ

    def readline(self):

        # stop the clock!

        signal.alarm(0)

        self.cmdQ.put({"input":None})

        l = self.lineQ.get()

        # restart the clock:

        # Some of our 5 seconds may have elapsed, but

        # never mind.

        signal.alarm(5)

        return l

class PythonRunner(Thread):

    def __init__(self, cmdQ, lineQ):

        self.cmdQ = cmdQ

        self.lineQ = lineQ

        Thread.__init__(self)

    def run(self):

        self.init_state()

        compiler = codeop.CommandCompiler()

        while True:

            l = self.lineQ.get()

            if self.curr_cmd == '':

                self.curr_cmd = l

            else:

                self.curr_cmd = self.curr_cmd + '\n' + l

            try:

                cmd = compiler(self.curr_cmd)

                if cmd is None:

                    # The command was incomplete,

                    # so send back a None, so the

                    # client can print a '...'

                    self.cmdQ.put({"more":None})

                else:

                    # The command was complete,

                    # so evaluate it!

                    sys.stdin = StdinFromWeb(self.cmdQ, self.lineQ)

                    out = cStringIO.StringIO()

                    sys.stdout = out

                    sys.stderr = out

                    signal.alarm(5)

                    res = eval(cmd, globs, locls)

                    signal.alarm(0)

                    self.cmdQ.put({"okay":(out.getvalue(),res)})

                    curr_cmd = ''

            except Exception, exc:

                signal.alarm(0)

                self.cmdQ.put({"exc":str(exc)})

                curr_cmd = ''

    def init_state(self):

        self.globs = {}

        self.globs['__builtins__'] = globals()['__builtins__']

        self.locls = {}

        self.curr_cmd = ''

urls = (

    '/',            'index',

    '/index.html',  'index',

    '/(.*\.js)',    'jscript',

    '/(.*\.css)',   'style',

    '/chat',        'chat')

# The global 'magic' is the secret that the client and server share

# which is used to create and md5 digest to authenticate requests.

# It is assigned a real value at startup.

magic = ''

class index:

    def GET(self):

        inp = web.input()

        # Authenticate

        digest = md5.new('hello' + magic).digest().encode('hex')

        if inp.digest != digest:

            web.ctx.status = '401 Unauthorized'

            return

        # Okay, so the authentication succeeded,

        # so all we need to do is send back the static

        # HTML for the console app.

        web.output(file("index.html", "r").read())

class jscript:

    def GET(self, name):

        web.output(file(name, "r").read())

class style:

    def GET(self, name):

        web.output(file(name, "r").read())

class chat:

    def POST(self):

        inp = web.input()

        # Authenticate

        digest = md5.new(inp.text + magic).digest().encode('hex')

        if inp.digest != digest:

            web.output("401 Unauthorized")

            web.ctx.status = '401 Unauthorized'

            return

        # Okay, so the authentication succeeded,

        # so now we have the trivial matter of actually

        # executing the python....

        lineQ.put(inp.text)

        r = cmdQ.get()

        sys.__stderr__.write(cjson.encode(r) + "\n")

        web.output(cjson.encode(r))

cmdQ = Queue.Queue()

lineQ = Queue.Queue()

interpThread = PythonRunner(cmdQ, lineQ)

if __name__ == "__main__":

    magic = sys.argv[2]

    interpThread.setDaemon(True)

    interpThread.start()

    web.run(urls, globals())