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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
#!/usr/bin/env python
"""This server runs an XMLRPC server that can be submitted code and tests
and returns the output. It *should* be run as root and will run as the user
'nobody' so as to minimize any damange by errant code. This can be configured
by editing settings.py to run as many servers as desired. One can also
specify the ports on the command line. Here are examples::
$ sudo ./code_server.py
# Runs servers based on settings.py:SERVER_PORTS one server per port given.
or::
$ sudo ./code_server.py 8001 8002 8003 8004 8005
# Runs 5 servers on ports specified.
All these servers should be running as nobody. This will also start a server
pool that defaults to port 50000 and is configurable in
settings.py:SERVER_POOL_PORT. This port exposes a `get_server_port` function
that returns an available server.
"""
import sys
from SimpleXMLRPCServer import SimpleXMLRPCServer
import pwd
import os
import stat
from os.path import isdir, dirname, abspath, join, isfile
import signal
from multiprocessing import Process, Queue
import subprocess
import re
import json
# Local imports.
from settings import SERVER_PORTS, SERVER_POOL_PORT
from language_registry import create_evaluator_instance, unpack_json
MY_DIR = abspath(dirname(__file__))
# Private Protocol ##########
def run_as_nobody():
"""Runs the current process as nobody."""
# Set the effective uid and to that of nobody.
nobody = pwd.getpwnam('nobody')
os.setegid(nobody.pw_gid)
os.seteuid(nobody.pw_uid)
###############################################################################
# `CodeServer` class.
###############################################################################
class CodeServer(object):
"""A code server that executes user submitted test code, tests it and
reports if the code was correct or not.
"""
def __init__(self, port, queue):
self.port = port
self.queue = queue
# Public Protocol ##########
def check_code(self, language, test_case_type, json_data, in_dir=None):
"""Calls relevant EvaluateCode class based on language to check the
answer code
"""
code_evaluator = create_evaluator_instance(language, test_case_type, json_data,
in_dir)
data = unpack_json(json_data)
result = code_evaluator.evaluate(**data)
# Put us back into the server pool queue since we are free now.
self.queue.put(self.port)
return json.dumps(result)
def run(self):
"""Run XMLRPC server, serving our methods."""
server = SimpleXMLRPCServer(("0.0.0.0", self.port))
self.server = server
server.register_instance(self)
self.queue.put(self.port)
server.serve_forever()
# # Private Protocol ##########
# def _create_evaluator_instance(self, language, json_data, in_dir):
# """Create instance of relevant EvaluateCode class based on language"""
# # set_registry()
# registry = get_registry()
# cls = registry.get_class(language)
# instance = cls.from_json(language, json_data, in_dir)
# return instance
###############################################################################
# `ServerPool` class.
###############################################################################
class ServerPool(object):
"""Manages a pool of CodeServer objects."""
def __init__(self, ports, pool_port=50000):
"""Create a pool of servers. Uses a shared Queue to get available
servers.
Parameters
----------
ports : list(int)
List of ports at which the CodeServer's should run.
pool_port : int
Port at which the server pool should serve.
"""
self.my_port = pool_port
self.ports = ports
queue = Queue(maxsize=len(ports))
self.queue = queue
servers = []
for port in ports:
server = CodeServer(port, queue)
servers.append(server)
p = Process(target=server.run)
p.start()
self.servers = servers
# Public Protocol ##########
def get_server_port(self):
"""Get available server port from ones in the pool. This will block
till it gets an available server.
"""
q = self.queue
was_waiting = True if q.empty() else False
port = q.get()
if was_waiting:
print '*'*80
print "No available servers, was waiting but got server \
later at %d." % port
print '*'*80
sys.stdout.flush()
return port
def run(self):
"""Run server which returns an available server port where code
can be executed.
"""
server = SimpleXMLRPCServer(("0.0.0.0", self.my_port))
self.server = server
server.register_instance(self)
server.serve_forever()
###############################################################################
def main(args=None):
run_as_nobody()
if args:
ports = [int(x) for x in args[1:]]
else:
ports = SERVER_PORTS
server_pool = ServerPool(ports=ports, pool_port=SERVER_POOL_PORT)
server_pool.run()
if __name__ == '__main__':
args = sys.argv[1:]
main(args)
|
