def main(argv):
import getopt, imp
def usage():
print('usage: %s [-h host] [-p port] [-n name] module.class' % argv[0])
return 100
try:
(opts, args) = getopt.getopt(argv[1:], 'h:p:n:')
except getopt.GetoptError:
return usage()
host = ''
port = 8080
name = 'WebApp'
for (k, v) in opts:
if k == '-h': host = v
elif k == '-p': port = int(v)
elif k == '-n': name = v
if not args: return usage()
path = args.pop(0)
module = imp.load_source('app', path)
WebAppHandler.APP_CLASS = getattr(module, name)
print('Listening %s:%d...' % (host, port))
httpd = HTTPServer((host, port), WebAppHandler)
httpd.serve_forever()
return
def main(ikey, skey, akey, host, port=8080):
server = HTTPServer(('', port), RequestHandler)
server.ikey = ikey
server.skey = skey
server.akey = akey
server.host = host
print("Visit the root URL with a 'user' argument, e.g.")
print("'http://localhost:%d/?user=myname'." % port)
server.serve_forever()
def start_webserver():
"""Start the webserver.
"""
path = os.path.dirname(__file__)
os.chdir(path)
server_address = ("127.0.0.1", 0)
httpd = HTTPServer(server_address, CGIHTTPRequestHandler)
print("http://127.0.0.1:%d" % httpd.server_port)
httpd.serve_forever()
def HelpServer():
global server
while 1:
try:
server = HTTPServer(('localhost', PORT_NUMBER), HelpHandler)
server.serve_forever( poll_interval = 2 )
except Exception as e:
server = None
time.sleep( 5 )
def main(ikey, skey, akey, host, port=8080):
server = HTTPServer(('', port), RequestHandler)
server.ikey = ikey
server.skey = skey
server.akey = akey
server.host = host
print("Visit the root URL with a 'user' argument, e.g.")
print("'http://localhost:%d/?user=myname'." % port)
server.serve_forever()
class SimpleHTTPService(ServerCustomService):
"""Simple HTTP Honeycomb Service."""
httpd = None
def __init__(self, *args, **kwargs):
super(SimpleHTTPService, self).__init__(*args, **kwargs)
def alert(self, request):
"""Raise an alert."""
params = {
EVENT_TYPE_FIELD_NAME: SIMPLE_HTTP_ALERT_TYPE_NAME,
ORIGINATING_IP_FIELD_NAME: request.client_address[0],
ORIGINATING_PORT_FIELD_NAME: request.client_address[1],
REQUEST_FIELD_NAME: " ".join([request.command, request.path]),
}
self.add_alert_to_queue(params)
def on_server_start(self):
"""Initialize Service."""
os.chdir(os.path.join(os.path.dirname(__file__), "www"))
requestHandler = HoneyHTTPRequestHandler
requestHandler.alert = self.alert
requestHandler.logger = self.logger
#requestHandler.server_version = self.service_args.get("version", DEFAULT_SERVER_VERSION)
port = self.service_args.get("port", DEFAULT_PORT)
threading = self.service_args.get("threading", False)
if threading:
self.httpd = ThreadingHTTPServer(("", port), requestHandler)
else:
self.httpd = HTTPServer(("", port), requestHandler)
self.signal_ready()
self.logger.info("Starting {}Simple HTTP service on port: {}".format(
"Threading " if threading else "", port))
self.httpd.serve_forever()
def on_server_shutdown(self):
"""Shut down gracefully."""
if self.httpd:
self.httpd.shutdown()
self.logger.info("Simple HTTP service stopped")
self.httpd = None
def test(self):
"""Test service alerts and return a list of triggered event types."""
event_types = list()
self.logger.debug("executing service test")
requests.get("http://localhost:{}/".format(
self.service_args.get("port", DEFAULT_PORT)))
event_types.append(SIMPLE_HTTP_ALERT_TYPE_NAME)
return event_types
def __str__(self):
return "Simple HTTP"
class ProxyThread(threading.Thread):
def __init__(self, token):
self.proxy = HTTPServer(('localhost', 0), ProxyHandler)
self.proxy._dcos_auth_token = token
super(ProxyThread, self).__init__()
def run(self):
self.proxy.serve_forever()
def port(self):
return self.proxy.socket.getsockname()[1]
class ProxyThread(threading.Thread):
def __init__(self, token):
self.proxy = HTTPServer(('localhost', 0), ProxyHandler)
self.proxy._dcos_auth_token = token
super(ProxyThread, self).__init__()
def run(self):
self.proxy.serve_forever()
def port(self):
return self.proxy.socket.getsockname()[1]
def main(argv):
args = argparser().parse_args(argv[1:])
httpd = HTTPServer(('localhost', args.port), RestOATaggerHandler)
info('REST-OA tagger service started')
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
info('REST-OA tagger service stopped')
httpd.server_close()
return 0
def run(self):
"""
Runs the server using Python's simple HTTPServer.
TODO: make this multithreaded.
"""
httpd = HTTPServer((self.host, self.port), self._Handler)
sa = httpd.socket.getsockname()
serve_message = "Serving HTTP on {host} port {port} (http://{host}:{port}/) ..."
print(serve_message.format(host=sa[0], port=sa[1]))
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
httpd.shutdown()
def RunFakeServer(cbsd_sas_version, sas_sas_version, is_ecc, crl_index):
FakeSasHandler.SetVersion(cbsd_sas_version, sas_sas_version)
if is_ecc:
assert ssl.HAS_ECDH
server = HTTPServer((HOST, PORT), FakeSasHandler)
ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.options |= ssl.CERT_REQUIRED
# If CRLs were provided, then enable revocation checking.
if crl_index is not None:
ssl_context.verify_flags = ssl.VERIFY_CRL_CHECK_CHAIN
try:
crl_files = ParseCrlIndex(crl_index)
except IOError as e:
print("Failed to parse CRL index file %r: %s" % (crl_index, e))
# https://tools.ietf.org/html/rfc5280#section-4.2.1.13 specifies that
# CRLs MUST be DER-encoded, but SSLContext expects the name of a PEM-encoded
# file, so we must convert it first.
for f in crl_files:
try:
with file(f) as handle:
der = handle.read()
try:
crl = crypto.load_crl(crypto.FILETYPE_ASN1, der)
except crypto.Error as e:
print("Failed to parse CRL file %r as DER format: %s" %
(f, e))
return
with tempfile.NamedTemporaryFile() as tmp:
tmp.write(crypto.dump_crl(crypto.FILETYPE_PEM, crl))
tmp.flush()
ssl_context.load_verify_locations(cafile=tmp.name)
print("Loaded CRL file: %r" % f)
except IOError as e:
print("Failed to load CRL file %r: %s" % (f, e))
return
ssl_context.load_verify_locations(cafile=CA_CERT)
ssl_context.load_cert_chain(
certfile=ECC_CERT_FILE if is_ecc else CERT_FILE,
keyfile=ECC_KEY_FILE if is_ecc else KEY_FILE,
)
ssl_context.set_ciphers(':'.join(ECC_CIPHERS if is_ecc else CIPHERS))
ssl_context.verify_mode = ssl.CERT_REQUIRED
server.socket = ssl_context.wrap_socket(server.socket, server_side=True)
print('Will start server at %s:%d, use <Ctrl-C> to stop.' % (HOST, PORT))
server.serve_forever()
def run(self):
"""
Runs the server using Python's simple HTTPServer.
TODO: make this multithreaded.
"""
httpd = HTTPServer((self.host, self.port), self._Handler)
sa = httpd.socket.getsockname()
serve_message = "Serving HTTP on {host} port {port} (http://{host}:{port}/) ..."
print(serve_message.format(host=sa[0], port=sa[1]))
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
httpd.shutdown()
def run_echo_server():
class Handler(BaseHTTPRequestHandler):
def _do(self):
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
parsed = urlparse(self.path)
query_parameters = parse_qs(parsed.query)
response = {
'path': parsed.path,
'headers': dict(self.headers)
}
if query_parameters:
response['query_params'] = query_parameters
try:
try: # py2
raw_content_len = self.headers.getheader('content-length')
except AttributeError: # py3
raw_content_len = self.headers.get('content-length')
content_len = int(raw_content_len)
except TypeError:
content_len = 0
if content_len:
body = self.rfile.read(content_len)
try: # py3
body = body.decode('UTF-8')
except AttributeError: # py2
pass
if body:
response['body'] = body
print(response)
encoded_json = json.dumps(response)
self.wfile.write(b(encoded_json))
return
do_GET = _do
do_POST = _do
do_PUT = _do
do_HEAD = _do
do_PATCH = _do
do_OPTIONS = _do
do_DELETE = _do
do_TRACE = _do
do_CONNECT = _do
server_address = ('', PORT)
httpd = HTTPServer(server_address, Handler)
httpd.serve_forever()
def runServer():
import six.moves.SimpleHTTPServer
import six.moves.socketserver
PORT = 8000
try:
# Create a web server and define the handler to manage the
# incoming request
server = HTTPServer(('', PORT), myHandler)
print('Started httpserver on port ', PORT)
# Wait forever for incoming htto requests
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down the web server')
server.socket.close()
def run_echo_server():
class Handler(BaseHTTPRequestHandler):
def _do(self):
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
parsed = urlparse(self.path)
query_parameters = parse_qs(parsed.query)
response = {'path': parsed.path, 'headers': dict(self.headers)}
if query_parameters:
response['query_params'] = query_parameters
try:
try: #py2
raw_content_len = self.headers.getheader('content-length')
except AttributeError: #py3
raw_content_len = self.headers.get('content-length')
content_len = int(raw_content_len)
except TypeError:
content_len = 0
if content_len:
body = self.rfile.read(content_len)
try: #py3
body = body.decode('UTF-8')
except AttributeError: #py2
pass
if body:
response['body'] = body
print(response)
encoded_json = json.dumps(response)
self.wfile.write(b(encoded_json))
return
do_GET = _do
do_POST = _do
do_PUT = _do
do_HEAD = _do
do_PATCH = _do
do_OPTIONS = _do
do_DELETE = _do
do_TRACE = _do
do_CONNECT = _do
server_address = ('', PORT)
httpd = HTTPServer(server_address, Handler)
httpd.serve_forever()
def main():
"""Run the HTTP server."""
# Redirect our service output to a log file.
global log
ensure_directory_exists(os.path.dirname(config.bing_test_service.log))
filelog = logging.FileHandler(config.bing_test_service.log)
log.addHandler(filelog)
log.setLevel(logging.DEBUG)
# To support service shutdown we need to create a PID file that is
# understood by the Launchpad services framework.
global service_name
make_pidfile(service_name)
host, port = get_service_endpoint()
server = HTTPServer((host, port), BingRequestHandler)
log.info("Starting HTTP Bing webservice server on port %s", port)
server.serve_forever()
class HttpImageServerThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.keep_running = True
def stop(self):
log.debug("HttpImageServerThread:stop called")
self.keep_running = False
self.server.shutdown()
def run(self):
log.debug("HttpImageServerThread:started")
self.server = HTTPServer(('', PORT_NUMBER), HttpImageHandler)
while self.keep_running:
self.server.serve_forever()
xbmc.sleep(1000)
log.debug("HttpImageServerThread:exiting")
def main(argv):
import getopt, imp
def usage():
print ('usage: %s [-h host] [-p port] [-n name] module.class' % argv[0])
return 100
try:
(opts, args) = getopt.getopt(argv[1:], 'h:p:n:')
except getopt.GetoptError:
return usage()
host = ''
port = 8080
name = 'WebApp'
for (k, v) in opts:
if k == '-h': host = v
elif k == '-p': port = int(v)
elif k == '-n': name = v
if not args: return usage()
path = args.pop(0)
module = imp.load_source('app', path)
WebAppHandler.APP_CLASS = getattr(module, name)
print ('Listening %s:%d...' % (host,port))
httpd = HTTPServer((host,port), WebAppHandler)
httpd.serve_forever()
return
call_request_reader = ipc.FramedReader(self.rfile)
call_request = call_request_reader.read_framed_message()
resp_body = self.responder.respond(call_request)
self.send_response(200)
self.send_header('Content-Type', 'avro/binary')
self.end_headers()
resp_writer = ipc.FramedWriter(self.wfile)
resp_writer.write_framed_message(resp_body)
if __name__ == '__main__':
if (len(sys.argv) <= 1):
raise ValueError("Usage: mock_tether_parent command")
cmd = sys.argv[1].lower()
if (sys.argv[1] == 'start_server'):
if (len(sys.argv) == 3):
port = int(sys.argv[2])
else:
raise ValueError("Usage: mock_tether_parent start_server port")
SERVER_ADDRESS = (SERVER_ADDRESS[0], port)
print("mock_tether_parent: Launching Server on Port: {0}".format(
SERVER_ADDRESS[1]))
# flush the output so it shows up in the parent process
sys.stdout.flush()
parent_server = HTTPServer(SERVER_ADDRESS, MockParentHandler)
parent_server.allow_reuse_address = True
parent_server.serve_forever()
self.wfile.write(b'no auth header received')
if DEBUG_LOG:
print('no auth header received')
elif self.get_header('Authorization') == ('Basic ' + encoded_password):
self.do_HEAD()
self.wfile.write(self.get_header('Authorization').encode('utf-8'))
self.wfile.write(b'authenticated!')
self.get_file("web_files", "adsl_modem.html")
if DEBUG_LOG:
print('auth header was correct:',
self.get_header('Authorization'))
else:
self.do_AUTHHEAD()
self.wfile.write(self.get_header('Authorization').encode('utf-8'))
self.wfile.write(b'not authenticated')
if DEBUG_LOG:
print('auth header was wrong:',
self.get_header('Authorization'), 'expected',
encoded_password)
if __name__ == "__main__":
server_address = ('127.0.0.1', 8080)
httpd = HTTPServer(server_address, TestWebServerHandler)
httpd.serve_forever()
raise Exception("%s failed to start" % (appname, ))
# Nothing failed, let's say we've started and then signal we're up by
# serving the webserver.
_print("Synapse started!")
class WebHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write("OK")
return
PORT_NUMBER = int(args["--addr"].split(":")[1])
server = HTTPServer(('', PORT_NUMBER), WebHandler)
server.serve_forever()
except KeyboardInterrupt:
pass
except BaseException as e:
# Log a traceback for debug
import traceback
traceback.print_exc()
# If we get told to shut down, log it
_print("Told to quit because %s" % (repr(e)))
# Otherwise, something bad has happened.
sys.exit(1)
finally:
subprocess.run(["pkill", "-9", "-f", "synapse.app"])
import textwrap
from six.moves.BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
class HelloRequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
if self.path != '/':
self.send_error(404, "Object Not Found")
return
self.send_response(200)
self.send_header('Content-type', 'text/html; charset=utf-8')
self.end_headers()
response_text = textwrap.dedent('''\
<!DOCTYPE html>
<head>
<title>Hello World</title>
</head>
<body>
<h2>Hello World</h2>
</body>
</html>
''')
self.wfile.write(response_text.encode('utf-8'))
server_address = ('', 8000)
http = HTTPServer(server_address, HelloRequestHandler)
http.serve_forever()
class OAuthHelper(object):
params = OAuthHandler.params
def __init__(self, reddit, term, config):
self.term = term
self.reddit = reddit
self.config = config
# Wait to initialize the server, we don't want to reserve the port
# unless we know that the server needs to be used.
self.server = None
self.reddit.set_oauth_app_info(self.config['oauth_client_id'],
self.config['oauth_client_secret'],
self.config['oauth_redirect_uri'])
# Reddit's mobile website works better on terminal browsers
if not self.term.display:
if '.compact' not in self.reddit.config.API_PATHS['authorize']:
self.reddit.config.API_PATHS['authorize'] += '.compact'
def authorize(self):
self.params.update(state=None, code=None, error=None)
# If we already have a token, request new access credentials
if self.config.refresh_token:
with self.term.loader('Logging in'):
try:
self.reddit.refresh_access_information(
self.config.refresh_token)
except (HTTPException, OAuthException) as e:
# Reddit didn't accept the refresh-token
# This appears to throw a generic 400 error instead of the
# more specific invalid_token message that it used to send
if isinstance(e, HTTPException):
if e._raw.status_code != 400:
# No special handling if the error is something
# temporary like a 5XX.
raise e
# Otherwise we know the token is bad, so we can remove it.
_logger.exception(e)
self.clear_oauth_data()
raise InvalidRefreshToken(
' Invalid user credentials!\n'
'The cached refresh token has been removed')
return
state = uuid.uuid4().hex
authorize_url = self.reddit.get_authorize_url(
state, scope=self.config['oauth_scope'], refreshable=True)
if self.server is None:
address = ('', self.config['oauth_redirect_port'])
self.server = HTTPServer(address, OAuthHandler)
if self.term.display:
# Open a background browser (e.g. firefox) which is non-blocking.
# The server will block until it responds to its first request,
# at which point we can check the callback params.
OAuthHandler.shutdown_on_request = True
with self.term.loader('Opening browser for authorization'):
self.term.open_browser(authorize_url)
self.server.serve_forever()
if self.term.loader.exception:
# Don't need to call server.shutdown() because serve_forever()
# is wrapped in a try-finally that doees it for us.
return
else:
# Open the terminal webbrowser in a background thread and wait
# while for the user to close the process. Once the process is
# closed, the iloop is stopped and we can check if the user has
# hit the callback URL.
OAuthHandler.shutdown_on_request = False
with self.term.loader('Redirecting to reddit', delay=0):
# This load message exists to provide user feedback
time.sleep(1)
thread = threading.Thread(target=self.server.serve_forever)
thread.daemon = True
thread.start()
try:
self.term.open_browser(authorize_url)
except Exception as e:
# If an exception is raised it will be seen by the thread
# so we don't need to explicitly shutdown() the server
_logger.exception(e)
self.term.show_notification('Browser Error', style='Error')
else:
self.server.shutdown()
finally:
thread.join()
if self.params['error'] == 'access_denied':
self.term.show_notification('Denied access', style='Error')
return
elif self.params['error']:
self.term.show_notification('Authentication error', style='Error')
return
elif self.params['state'] is None:
# Something went wrong but it's not clear what happened
return
elif self.params['state'] != state:
self.term.show_notification('UUID mismatch', style='Error')
return
with self.term.loader('Logging in'):
info = self.reddit.get_access_information(self.params['code'])
if self.term.loader.exception:
return
message = 'Welcome {}!'.format(self.reddit.user.name)
self.term.show_notification(message)
self.config.refresh_token = info['refresh_token']
if self.config['persistent']:
self.config.save_refresh_token()
def clear_oauth_data(self):
self.reddit.clear_authentication()
self.config.delete_refresh_token()
def serve_forever(self, *args, **kwargs):
self.listening_event.set()
return HTTPServer.serve_forever(self, *args, **kwargs)
def start_mock_server():
server_address = ('127.0.0.1', 8545)
httpd = HTTPServer(server_address, MockedTestrpc)
httpd.serve_forever()
print('served internal')
def serve_forever(self, *args, **kwargs):
self.listening_event.set()
return HTTPServer.serve_forever(self, *args, **kwargs)
class IPCamTrendnetTvIp100Service(ServerCustomService):
"""IP Cam TRENDnet TV-IP100 Service."""
httpd = None
def alert(self, request, event):
"""Raise an alert."""
params = {
EVENT_TYPE_FIELD_NAME: event,
ORIGINATING_IP_FIELD_NAME: request.client_address[0],
ORIGINATING_PORT_FIELD_NAME: request.client_address[1],
REQUEST_FIELD_NAME: " ".join([request.command, request.path]),
}
self.add_alert_to_queue(params)
def on_server_start(self):
"""Initialize Service."""
os.chdir(os.path.join(os.path.dirname(__file__), "www"))
requestHandler = TrendnetTVIP100CamRequestHandler
requestHandler.alert = self.alert
requestHandler.logger = self.logger
requestHandler.server_version = self.service_args.get("version", DEFAULT_SERVER_VERSION)
requestHandler.image_src_url = self.service_args.get("image_src_url", None)
requestHandler.image_src_path = self.service_args.get("image_src_path", None)
if requestHandler.image_src_path and requestHandler.image_src_url:
raise ValueError("cannot process both image_src_path and image_src_url")
if not requestHandler.image_src_path and not requestHandler.image_src_url:
raise ValueError("image_src_path or image_src_url must be provided")
port = self.service_args.get("port")
threading = self.service_args.get("threading", False)
if threading:
self.httpd = ThreadingHTTPServer(("", port), requestHandler)
else:
self.httpd = HTTPServer(("", port), requestHandler)
self.signal_ready()
self.logger.info(
"Starting {}IP Cam TRENDnet TV-IP100 service on port: {}".format("Threading " if threading else "", port))
self.httpd.serve_forever()
def on_server_shutdown(self):
"""Shut down gracefully."""
if self.httpd:
self.httpd.shutdown()
self.logger.info("IP Cam TRENDnet TV-IP100 service stopped")
self.httpd = None
def test(self):
"""Test service alerts and return a list of triggered event types."""
event_types = list()
self.logger.debug("executing service test")
# basic screen
requests.get("http://localhost:{}".format(self.service_args.get("port")))
# camera shot
requests.get("http://localhost:{}{}".format(self.service_args.get("port"), CAMERA_IMAGE_PATH))
# Invalid url
requests.get("http://localhost:{}/asdasdad.html".format(self.service_args.get("port")))
# / redirect
requests.get("http://localhost:{}/".format(self.service_args.get("port")))
# One alert for authorization attempt
requests.get("http://localhost:{}/content.html".format(self.service_args.get("port")),
headers={"Authorization": "username=\"test\""})
event_types.append(TRENDNET_ADMIN_ACCESS_EVENT)
# And for POST
requests.post("http://localhost:{}/content.html".format(self.service_args.get("port")), data={})
event_types.append(TRENDNET_ADMIN_POST_ATTEMPT)
return event_types
def __str__(self):
return "IP Cam TRENDnet TV-IP100"
raise Exception("%s failed to start" % (appname, ))
# Nothing failed, let's say we've started and then signal we're up by
# serving the webserver.
_print("Synapse started!")
class WebHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.end_headers()
self.wfile.write("OK")
return
PORT_NUMBER = int(args["--addr"].split(":")[1])
server = HTTPServer(('', PORT_NUMBER), WebHandler)
server.serve_forever()
except KeyboardInterrupt:
pass
except BaseException as e:
# Log a traceback for debug
import traceback
traceback.print_exc()
# If we get told to shut down, log it
_print("Told to quit because %s" % (repr(e)))
# Otherwise, something bad has happened.
sys.exit(1)
finally:
subprocess.run(["pkill", "-9", "-f", "synapse.app"])
resp_data['primary_calendar_events'] = (
primary_calendar_events.data)
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
self.wfile.write(json.dumps(resp_data).encode('utf8'))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('app_id', type=str,
help='You can access app_id via https://developers.klo'
'udless.com/applications/*/details')
parser.add_argument('api_key', type=str,
help='You can access api_key via https://developers.klo'
'udless.com/applications/*/details')
parser.add_argument('--port', type=int, default=8020,
help='Port number to run the server, default to 8020')
args = parser.parse_args()
app_id = args.app_id
api_key = args.api_key
port = args.port
print('Listening on localhost:%s' % port)
httpd = HTTPServer(('', port), RequestHandler)
httpd.serve_forever()
def _multiproc_serve_path_via_http(hostname, path_to_serve_from,
queue): # pragma: no cover
chpwd(path_to_serve_from)
httpd = HTTPServer((hostname, 0), SilentHTTPHandler)
queue.put(httpd.server_port)
httpd.serve_forever()
def _multiproc_serve_path_via_http(hostname, path_to_serve_from, queue): # pragma: no cover
chpwd(path_to_serve_from)
httpd = HTTPServer((hostname, 0), SilentHTTPHandler)
queue.put(httpd.server_port)
httpd.serve_forever()
