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 start_local_http_server(port, handler=RequestHandler):
server = HTTPServer(("127.0.0.1", port), handler)
server.allow_reuse_address = True
server.auth_code = None
server.auth_token_form = None
server.error = None
return server
def fakeServer(actions, port=55555):
""" helper to set up and activate a fake http server used for testing
purposes; <actions> must be a list of handler functions, which will
receive the base handler as their only argument and are used to
process the incoming requests in turn; returns a thread that should
be 'joined' when done """
class Handler(BaseHTTPRequestHandler):
def do_POST(self):
action = actions.pop(0) # get next action
action(self) # and process it...
def do_GET(self):
action = actions.pop(0) # get next action
action(self) # and process it...
def log_request(*args, **kw):
pass
def runner():
while actions:
server.handle_request()
server = HTTPServer(("", port), Handler)
thread = Thread(target=runner)
thread.start()
return thread
def __init__(self, *args, **kwds):
super(AuthServer, self).__init__(*args, **kwds)
self.server = HTTPServer(('127.0.0.1', 0), RequestHandler)
self.port = self.server.server_port
self.server.timeout = 1
self.server.response = self.response
self.running = True
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 start_http_server(port, path):
logger.info('Starting local http server')
handler = partial(PathHTTPHandler, serve_path=path)
thread = Thread(target=HTTPServer(('', port), handler).serve_forever)
thread.daemon = True
thread.start()
logger.info('Local http server serving at port: %s', port)
def mirror_server(mirrors_dict):
mirror_file_path = '/mirrors.json'
mirror_corrupt_file_path = '/corrupt_mirrors.json'
mirror_json_varname = 'ci_repos'
mirror_data = {mirror_json_varname: mirrors_dict}
mirror_json = json.dumps(mirror_data).encode('utf8')
class MirrorRequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
if self.path == mirror_file_path:
self.send_response(200)
self.send_header("Content-type", 'application/json')
self.end_headers()
self.wfile.write(mirror_json)
elif self.path == mirror_corrupt_file_path:
self.send_response(200)
self.send_header("Content-type", 'application/json')
self.end_headers()
self.wfile.write('{"this": "is", "bad": "json"')
else:
self.send_error(404)
for attempt in range(0, 20):
server_address = ('127.0.0.1', randrange(8765, 8876))
try:
server = HTTPServer(server_address, MirrorRequestHandler)
except socket.error as e:
if e.errno == 98:
continue
raise
break
else:
raise RuntimeError("Failed to allocate port for mirror_server fixture")
server_url = 'http://{0}:{1}'.format(*server_address)
sthread = Thread(target=server.serve_forever)
sthread.start()
try:
# Wait for http server to start
sleep(0.1)
# ensure we won't implictly try to use proxies to access local server
old_env = dict(((k, environ.pop(k))
for k in ('http_proxy', 'HTTP_PROXY') if k in environ))
try:
yield dict(
mirror_url=urljoin(server_url, mirror_file_path),
json_varname=mirror_json_varname,
bad_path_url=urljoin(server_url, '/bad_file'),
bad_port_url=urljoin(
'http://{0}:8764'.format(server_address[0]),
mirror_file_path),
corrupt_url=urljoin(server_url, mirror_corrupt_file_path),
)
finally:
environ.update(old_env)
finally:
server.shutdown()
sthread.join()
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()
def __init__(self, context):
super(ExhibitorController, self).__init__(context, False)
port = 8181
exhibitor = HTTPServer(('', port), MockExhibitor)
exhibitor.daemon_thread = True
exhibitor_thread = threading.Thread(target=exhibitor.serve_forever)
exhibitor_thread.daemon = True
exhibitor_thread.start()
os.environ.update({'PATRONI_EXHIBITOR_HOSTS': 'localhost', 'PATRONI_EXHIBITOR_PORT': str(port)})
def test(self):
server = HTTPServer(("", 0), FetcherTestHandler)
import threading
server_thread = threading.Thread(target=server.serve_forever)
server_thread.setDaemon(True)
server_thread.start()
run_fetcher_tests(server)
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 run_server_test():
global server_thread
if server_thread is not None:
return
server = HTTPServer((HOST, PORT), HTTPTestHandler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.setDaemon(True)
server_thread.start()
def oauth_server():
# Start the OAuth server on a random port in the background
server = HTTPServer(('', 0), OAuthHandler)
server.url = 'http://{0}:{1}/'.format(*server.server_address)
thread = threading.Thread(target=server.serve_forever)
thread.start()
try:
yield server
finally:
server.shutdown()
thread.join()
server.server_close()
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 __init__(self, domain):
port = random.randint(10000, 15000)
self.url = 'http://{}:{}'.format(domain, port)
mkpdirs(self.tmp_folder)
logger.info('Start http server in local')
httpd = HTTPServer(('', port),
partial(PathHTTPHandler,
serve_path=self.tmp_folder))
thread = Thread(target=httpd.serve_forever)
thread.daemon = True
thread.start()
logger.info('Serving at port: %s', port)
self._client = docker.from_env(timeout=360)
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 http_server():
"""
Yields an HTTP server object, which stores JSON data from received POST
requests in a .post_data queue.
"""
PostHandler.post_data = []
server = HTTPServer(("", 0), PostHandler)
start_thread = threading.Thread(target=server.serve_forever)
start_thread.daemon = True
start_thread.start()
yield server
server.shutdown()
start_thread.join()
def start(self):
class _RequestHandler(BaseHTTPRequestHandler):
def do_GET(inner_self):
inner_self.send_response(200)
response_string = json.dumps(self.registry.get_stats())
inner_self.send_header('Content-Type', 'application/json')
inner_self.send_header('Content-Length', len(response_string))
inner_self.end_headers()
inner_self.wfile.write(response_string.encode('utf-8'))
server_address = '', self.port
self.httpd = HTTPServer(server_address, _RequestHandler)
self.thread = Thread(target=self.httpd.serve_forever)
self.thread.start()
def __init__(self, host=DEFAULT_HOST, port=DEFAULT_PORT):
self.stop_serving = False
host = host
port = port
while True:
try:
self.server = HTTPServer(
(host, port), HtmlOnlyHandler)
self.host = host
self.port = port
break
except socket.error:
log.debug("port %d is in use, trying to next one" % port)
port += 1
self.thread = threading.Thread(target=self._run_web_server)
def setUp(self):
if LIVE_CAMERA:
multicast_ip = pysony.SSDP_ADDR
else:
multicast_ip = '224.0.0.111'
self.ssdp_server = SSDPServer(multicast_ip)
self.ssdp_server.register(
manifestation=None,
usn=uuid1().urn,
st=pysony.SSDP_ST,
location='http://127.0.0.1:64321/dd.xml',
)
FileRequestHandler.FILE = DD_FILE
self.http = HTTPServer(('localhost', 64321), FileRequestHandler)
threading.Thread(target=self.ssdp_server.run).start()
threading.Thread(target=self.http.serve_forever).start()
self.cp = pysony.ControlPoint(multicast_ip)
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 init_mock_server():
# Get port
s = socket.socket(socket.AF_INET, type=socket.SOCK_STREAM)
s.bind(('localhost', 0))
address, port = s.getsockname()
s.close()
# Start server
mock_server = HTTPServer(('localhost', port), MockServerRequestHandler)
mock_server_thread = Thread(target=mock_server.serve_forever)
mock_server_thread.setDaemon(True)
mock_server_thread.start()
# Override production server
server = 'http://localhost:{}'.format(port)
os.environ['HYPERDASH_SERVER'] = server
return handle_request_cache
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 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()
def start_pprof_server(host='localhost', port=8080):
'''Start a pprof server at the given host:port in a background thread.
After calling this function, the pprof endpoints should be available
at /debug/pprof/profile, etc.
Returns the underlying HTTPServer. To stop the server, call shutdown().
'''
# WallProfiler's registers a Python signal handler, which must be done
# on the main thread. So do it now before spawning the background thread.
# As a result, starting the pprof server has the side effect of registering the
# wall-clock profiler's SIGALRM handler, which may conflict with other uses.
_wall_profiler.register_handler()
server = HTTPServer((host, port), PProfRequestHandler)
bg_thread = threading.Thread(target=server.serve_forever)
bg_thread.daemon = True
bg_thread.start()
return server
def mirror_server(mirrors_dict):
mirror_file_path = '/mirrors.json'
mirror_json_varname = 'ci_repos'
mirror_data = {mirror_json_varname: mirrors_dict}
mirror_json = json.dumps(mirror_data).encode('utf8')
class MirrorRequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
if self.path == mirror_file_path:
self.send_response(200)
self.send_header("Content-type", 'application/json')
self.end_headers()
self.wfile.write(mirror_json)
else:
self.send_error(404)
server_address = ('127.0.0.1', 8765)
server_url = 'http://{0}:{1}'.format(*server_address)
server = HTTPServer(server_address, MirrorRequestHandler)
sthread = Thread(target=server.serve_forever)
sthread.start()
try:
# Wait for http server to start
sleep(0.1)
# ensure we won't implictly try to use proxies to access local server
old_env = dict(((k, environ.pop(k))
for k in ('http_proxy', 'HTTP_PROXY') if k in environ))
try:
yield dict(
mirror_url=urljoin(server_url, mirror_file_path),
json_varname=mirror_json_varname,
bad_path_url=urljoin(server_url, '/bad_file'),
bad_port_url=urljoin(
'http://{0}:8766'.format(server_address[0]),
mirror_file_path),
)
finally:
environ.update(old_env)
finally:
server.shutdown()
sthread.join()
def _zero_instance_app_through_http():
class JSONRequestHandler(BaseHTTPRequestHandler):
def do_GET(self): # noqa: N802
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
self.wfile.write(
open('tests/data/marathon/apps/zero_instance_sleep.json',
'rb').read())
host = 'localhost'
port = 12345
server = HTTPServer((host, port), JSONRequestHandler)
thread = threading.Thread(target=server.serve_forever)
thread.setDaemon(True)
thread.start()
with app('http://{}:{}'.format(host, port), 'zero-instance-app'):
try:
yield
finally:
server.shutdown()
