1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#   name: Application server
#   type: Node

import re
import cgi
import sys
import json
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
from SocketServer import ThreadingMixIn, ForkingMixIn

# dummy function
def dummy_func(): return 'dummy function'

# url patterns
url_patterns = (
    (r'', dummy_func),
)

# Application server type
THREADED_SERVER = 0
FORKED_SERVER = 1

class ThreadedApplicationServer(ThreadingMixIn, HTTPServer):
    ''' Handle requests in separate thread '''

class ForkedApplicationServer(ForkingMixIn, HTTPServer):
    ''' Handle requests in separate process '''
    
class ApplicationHandler(BaseHTTPRequestHandler):

    def handle_request(self):
        ''' handle GET and POST requests '''
        result = {}
        kargs = {}
        
        if self.command == 'POST':
            form = cgi.FieldStorage(fp=self.rfile, headers=self.headers,
                                    environ={'REQUEST_METHOD':'POST',
                                    'CONTENT_TYPE':self.headers['Content-Type'],
                                    })
            
            for k in form.keys(): kargs[k] = form[k].value
            
        for p in url_patterns:
            m = re.search(p[0], self.path, re.I) 
            if m:
                if len(m.groupdict()) <> 0: 
                    for k in m.groupdict().keys(): kargs[k] = m.group(k)
                result = p[1](**kargs)
                break
        
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(result))
    
    def do_GET(self):
        self.handle_request()
    
    def do_POST(self):
        self.handle_request()
        
def run_server(port=8080, server_type=THREADED_SERVER):
    if server_type == THREADED_SERVER:
        server = ThreadedApplicationServer(('', port), ApplicationHandler)
        print "ThreadedApplicationServer started"
        try:
            server.serve_forever()        
        except KeyboardInterrupt:
            server.socket.close()
            print "ThreadedApplicationServer stopped"
            
    elif server_type == FORKED_SERVER:
        server = ForkedApplicationServer(('', port), ApplicationHandler)
        print "ForkedApplicationServer started"
        try:
            server.serve_forever()        
        except KeyboardInterrupt:
            server.socket.close()
            print "ForkedApplicationServer stopped"
    else:
        print >> sys.stderr, 'Error! Unknown application server type'

if __name__ == '__main__':
    from optparse import OptionParser
    
    parser = OptionParser()
    parser.add_option("-t", "--threaded", action='store_true', dest="threaded", 
                        default=False, help="run as ThreadedApplicationServer")
    parser.add_option("-f", "--forked", action='store_true', dest="forked", 
                        default=False, help="run as ForkedApplicationServer")

    (options, args) = parser.parse_args()
    
    if options.threaded:
        run_server(server_type=THREADED_SERVER)
    elif options.forked:
        run_server(server_type=FORKED_SERVER)
    else:
        print >> sys.stderr, 'Error! Unknown application server type'
        sys.exit()