def startCamera(self):
global camera
with picamera.PiCamera(resolution='160x120', framerate=150) as camera:
global output
output = masterStream.StreamingOutput()
#Uncomment the next line to change your Pi's Camera rotation (in degrees)
#camera.rotation = 90
camera.clock_mode = 'raw'
camera.start_recording(output, format='mjpeg')
camera.annotate_background = picamera.Color('black')
camera.annotate_text_size = 14
camera.annotate_text = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
#Setting up the low level interrupts with optional LED vis
GPIO.add_event_detect(on_pin,GPIO.RISING,callback=masterStream.interrupt_on)
try:
global address
address = ('', 8000)
server = masterStream.StreamingServer(address, masterStream.StreamingHandler)
server.serve_forever()
except KeyboardInterrupt:
print('Keyboard interrupt ended stream at address',address)
camera.close()
server.server_close()
GPIO.cleanup()
pass
finally:
camera.close()
server.server_close()
GPIO.cleanup()
def finish(self):
print("end")
if not self.wfile.closed:
self.wfile.flush()
self.wfile.close()
self.rfile.close()
server.server_close()
def httpd():
'''
HTTP server
'''
try:
port = int(os.environ['PORT'])
except KeyError:
port = 8081
RequestHandlerClass = make_request_handler_class()
RequestHandlerClass.server_version = "EPOS Master Server"
RequestHandlerClass.sys_version = str(VERSION)
logging.info("************************************* " +
RequestHandlerClass.server_version + " " +
RequestHandlerClass.sys_version +
"*************************************")
server = ThreadedHTTPServer(("", port), RequestHandlerClass)
logging.info('Server starting %s:%s (level=%s)' % ("", port, ""))
try:
logging.info('Server initialized %s:%s' % ("", port))
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
logging.info('Server stopping %s:%s' % ("", port))
def test_upload_stats(self):
stats = {'stats': {'foo': 'bar', 'baz': 42}}
class Handler(http.server.BaseHTTPRequestHandler):
def do_POST(handler):
try:
self.assertEquals('/upload', handler.path)
self.assertEquals('application/x-www-form-urlencoded', handler.headers['Content-type'])
length = int(handler.headers['Content-Length'])
post_data = parse_qs(handler.rfile.read(length).decode('utf-8'))
decoded_post_data = {k: json.loads(v[0]) for k, v in post_data.items()}
self.assertEquals(stats, decoded_post_data)
handler.send_response(200)
except Exception:
handler.send_response(400) # Ensure the main thread knows the test failed.
raise
server_address = ('', 0)
server = http.server.HTTPServer(server_address, Handler)
host, port = server.server_address
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
self.assertTrue(RunTracker.post_stats('http://{}:{}/upload'.format(host, port), stats))
server.shutdown()
server.server_close()
def run_server(tmpdir, handler_class, stop_event, queue): # pragma: no cover
"""
Runs an HTTP server serving files from given tmpdir in a separate
process. When it's ready, it sends a URL to the server over a
queue so the main process (the HTTP client) can start making
requests of it.
"""
class HTTPRequestHandler(handler_class):
def translate_path(self, path):
path = handler_class.translate_path(self, path)
path = os.path.join(
tmpdir,
os.path.relpath(path, os.getcwd()))
return path
server = socketserver.TCPServer(("127.0.0.1", 0), HTTPRequestHandler)
domain, port = server.server_address
url = "http://{0}:{1}/".format(domain, port)
# Set a reasonable timeout so that invalid requests (which may occur during
# testing) do not cause the entire test suite to hang indefinitely
server.timeout = 0.1
queue.put(url)
# Using server.serve_forever does not work here since it ignores the
# timeout value set above. Having an explicit loop also allows us to kill
# the server from the parent thread.
while not stop_event.isSet():
server.handle_request()
server.server_close()
def run(self):
global runServer
while runServer:
try:
server = http.server.HTTPServer(('', args.port), myHandler)
print ('Starting httpserver on port ' , args.port)
if not args.insecure:
server.socket = ssl.wrap_socket (server.socket, certfile='/etc/ssl/localcerts/doorsserver065.cer', keyfile="/etc/ssl/localcerts/doorsserver065.key", server_side=True)
server.serve_forever()
except KeyboardInterrupt:
print ('Keyboard Interupt')
runServer=False
except Exception as e:
print(e,file=sys.stderr)
try:
server.server_close()
print ('server was stopped at '+ time.asctime( time.localtime(time.time()))+' automatically due to error.')
except Exception as e:
print (e,"\n'server_close()' failed at "+time.asctime( time.localtime(time.time()))+".",file=sys.stderr)
finally:
try:
server = http.server.HTTPServer(('', args.port), myHandler)
if not args.insecure:server.socket = ssl.wrap_socket (server.socket, certfile='/etc/ssl/localcerts/doorsserver065.cer', keyfile="/etc/ssl/localcerts/doorsserver065.key", server_side=True)
print ('Starting httpserver on port ' , args.port," at ", time.asctime( time.localtime(time.time())))
server.serve_forever()
except KeyboardInterrupt:
print ('Keyboard Interupt')
runServer=False
def close_socket():
global server
if server:
logging.info('Stopping server')
server.server_close()
server = None
sys.exit(0)
def signal_handler(signal, frame):
print('Exiting http server (Ctrl+C pressed)')
try:
if (server):
server.server_close()
finally:
sys.exit(0)
def start_stream(stop_thread, camera):
"""Function to start the online and live video stream.
Args:
stop_thread: Stop flag of the tread about terminating it outside of the function's loop.
camera: Camera object from PiCamera.
"""
output = StreamingOutput()
# Uncomment the next line to change your Pi's Camera rotation (in degrees)
# camera.rotation = 90
camera.start_recording(output, format='mjpeg')
try:
address = ('10.42.0.151', 8000)
server = StreamingServer(address, StreamingHandler)
is_server_active = False
while True:
if not is_server_active:
server.serve_forever()
is_server_active = True
if stop_thread():
server.server_close()
break
time.sleep(0.5)
finally:
camera.stop_recording()
def mock_error_server(
uri: str,
err_code: int,
err_msg: str = None,
err_explain: str = None,
host: str = "localhost",
port: int = get_free_port(),
method: HttpMethod = HttpMethod.GET,
):
server = make_mock_error_server(
host=host,
port=port,
uri=uri,
method=method,
err_code=err_code,
err_msg=err_msg,
err_explain=err_explain,
)
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True # stop Python from biting ctrl-C
thread.start()
yield server
server.shutdown()
server.server_close()
def callback(parser):
if not ark.site.home():
sys.exit("Error: cannot locate the site's home directory.")
if not os.path.exists(ark.site.out()):
sys.exit("Error: cannot locate the site's output directory.")
os.chdir(ark.site.out())
try:
server = http.server.HTTPServer((parser['host'], parser['port']),
http.server.SimpleHTTPRequestHandler)
except PermissionError:
sys.exit("Permission error: use 'sudo' to run on a port below 1024.")
address = server.socket.getsockname()
print("-" * 80)
print("Root: %s" % ark.site.out())
print("Host: %s" % address[0])
print("Port: %s" % address[1])
print("Stop: Ctrl-C")
print("-" * 80)
if parser['browser']:
webbrowser.open("http://%s:%s" % (parser['host'], parser['port']))
try:
server.serve_forever()
except KeyboardInterrupt:
print("\n" + "-" * 80 + "Stopping server...\n" + "-" * 80)
server.server_close()
def test_post_json_request(self):
ServerHandler = self.make_http_server_handler("HTTP/1.1")
server = http.server.HTTPServer(("localhost", 8000), ServerHandler)
asyncio.ensure_future(
self.loop.run_in_executor(None, server.serve_forever))
asyncio.ensure_future(
self.get_coro_result(
self.v11_client.post(
"http://localhost:8000/post_test/",
body_args={"a": "b"},
headers={"content-type": "application/json"})))
self.loop.run_forever()
server.shutdown()
server.server_close()
response = self.coro_result
self.assertEqual(response.status_code, 200,
"Wrong Status Code")
self.assertEqual(response.body, b"Hello, World!")
body = self.received_body
if hasattr(body, "getfirst"):
self.assertEqual(body.getfirst("a"), "b")
else:
self.assertEqual(body.get("a"), "b")
def signal_handler(signal, frame):
print('Shutting down NeRFServer(Ctrl+C Pressed)')
try:
if (server):
server.server_close()
finally:
exit(0)
def start_receiver():
"""Start listening to HTTP requests
:param func: the callback to call upon a cloudevents request
:type func: cloudevent -> none
"""
m = marshaller.NewDefaultHTTPMarshaller()
class BaseHttp(http.server.BaseHTTPRequestHandler):
def do_POST(self):
content_type = self.headers.get('Content-Type')
content_len = int(self.headers.get('Content-Length'))
headers = dict(self.headers)
data = self.rfile.read(content_len)
data = data.decode('utf-8')
event = v02.Event()
event = m.FromRequest(event, headers, data, str)
run_event(event)
self.send_response(204)
self.end_headers()
return
class ThreadedCEServer(ThreadingMixIn, http.server.HTTPServer):
"Deal with concurrent requests in a different thread"
server = ThreadedCEServer(('', 8000), BaseHttp)
print('Starting server on port 8000, use <Ctrl-C> to stop')
try:
server.serve_forever()
except:
server.server_close()
def _show_payload(payload):
html = f"<!DOCTYPE html><html><head><title>{type(payload)}</title></head><body>"
if isinstance(payload, Diff):
for old, new in payload:
if old is None:
html += f'<p style="background-color:LightGreen">Added {new}</p>'
elif new is None:
html += f'<p style="background-color:IndianRed">Removed {old}</p>'
else:
html += f'<p style="background-color:Gold">Updated {old} -> {new}</p>'
else:
html += f"<p>{payload}<\p>"
html += "</body></html>"
class ReqHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "text/html; charset=UTF-8")
self.end_headers()
self.wfile.write(html.encode("utf-8"))
self.close_connection = True
server = http.server.HTTPServer(('127.0.0.1', 0), ReqHandler)
webbrowser.open_new(f"http://localhost:{server.server_address[1]}")
server.handle_request()
server.server_close()
def test_server_and_custom_headers(responder, read_method, parquet_engine):
if parquet_engine is not None:
pytest.importorskip(parquet_engine)
if parquet_engine == "fastparquet":
pytest.importorskip("fsspec")
custom_user_agent = "Super Cool One"
df_true = pd.DataFrame({"header": [custom_user_agent]})
# passing 0 for the port will let the system find an unused port
with http.server.HTTPServer(("localhost", 0), responder) as server:
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
port = server.server_port
if parquet_engine is None:
df_http = read_method(
f"http://localhost:{port}",
storage_options={"User-Agent": custom_user_agent},
)
else:
df_http = read_method(
f"http://localhost:{port}",
storage_options={"User-Agent": custom_user_agent},
engine=parquet_engine,
)
server.shutdown()
server.server_close()
server_thread.join()
tm.assert_frame_equal(df_true, df_http)
def run_server(tmpdir, handler_class, stop_event, queue): # pragma: no cover
"""
Runs an HTTP server serving files from given tmpdir in a separate
process. When it's ready, it sends a URL to the server over a
queue so the main process (the HTTP client) can start making
requests of it.
"""
class HTTPRequestHandler(handler_class):
def translate_path(self, path):
path = handler_class.translate_path(self, path)
path = os.path.join(tmpdir, os.path.relpath(path, os.getcwd()))
return path
server = socketserver.TCPServer(("127.0.0.1", 0), HTTPRequestHandler)
domain, port = server.server_address
url = "http://{0}:{1}/".format(domain, port)
# Set a reasonable timeout so that invalid requests (which may occur during
# testing) do not cause the entire test suite to hang indefinitely
server.timeout = 0.1
queue.put(url)
# Using server.serve_forever does not work here since it ignores the
# timeout value set above. Having an explicit loop also allows us to kill
# the server from the parent thread.
while not stop_event.isSet():
server.handle_request()
server.server_close()
def test_server_and_all_custom_headers(responder, read_method):
custom_user_agent = "Super Cool One"
custom_auth_token = "Super Secret One"
storage_options = {
"User-Agent": custom_user_agent,
"Auth": custom_auth_token,
}
# passing 0 for the port will let the system find an unused port
with http.server.HTTPServer(("localhost", 0), responder) as server:
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
port = server.server_port
df_http = read_method(
f"http://localhost:{port}",
storage_options=storage_options,
)
server.shutdown()
server.server_close()
server_thread.join()
df_http = df_http[df_http["0"].isin(storage_options.keys())]
df_http = df_http.sort_values(["0"]).reset_index()
df_http = df_http[["0", "1"]]
keys = list(storage_options.keys())
df_true = pd.DataFrame({
"0": keys,
"1": [storage_options[k] for k in keys]
})
df_true = df_true.sort_values(["0"])
df_true = df_true.reset_index().drop(["index"], axis=1)
tm.assert_frame_equal(df_true, df_http)
def notification_server(server_info, checker=None):
host = None
port = []
if server_info is not None:
host, *port = server_info.split(":")
if not host or not (port and port[0]):
raise ValueError("Notification server host:port configuration is invalid")
else:
raise ValueError("Notification server host:port configuration is invalid")
with PostQueueServer(
(host, int(port[0])), PostQueueRequestHandler, checker
) as server:
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
LOG.success("Notification server started")
try:
yield server
finally:
assert (
server.check_errors() is True
), "Notification server caught malformed notifications"
server.shutdown()
server.server_close()
def run_test_server():
PORT = 8080
Handler = http.server.SimpleHTTPRequestHandler
Handler.extensions_map={
'.manifest': 'text/cache-manifest',
'.html': 'text/html',
'.png': 'image/png',
'.jpg': 'image/jpg',
'.svg': 'image/svg+xml',
'.css': 'text/css',
'.js': 'application/x-javascript',
'': 'application/octet-stream', # Default
}
global server
server = socketserver.TCPServer(("", PORT), Handler)
print("serving at port", PORT)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
def mock_server(
uri: str,
body: str,
host: str = "localhost",
port: int = get_free_port(),
method: HttpMethod = HttpMethod.GET,
match_query: bool = False,
echo: bool = False,
):
server = make_mock_server(
host=host,
port=port,
uri=uri,
body=body,
method=method,
match_query=match_query,
echo=echo,
)
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True # stop Python from biting ctrl-C
thread.start()
yield server
server.shutdown()
server.server_close()
def main(cls, RequestHandlerClass, port=80):
"""Start server with handler on given port.
This static method provides an easy way to start, run, and exit
a HttpServer instance. The server will be executed if possible,
and the computer's web browser will be directed to the address."""
try:
server = cls(('', port), RequestHandlerClass)
active = True
except socket.error:
active = False
else:
addr, port = server.socket.getsockname()
print('Serving HTTP on', addr, 'port', port, '...')
finally:
port = '' if port == 80 else ':' + str(port)
addr = 'http://localhost' + port + '/'
webbrowser.open(addr)
if active:
try:
server.serve_forever()
except KeyboardInterrupt:
print('Keyboard interrupt received: EXITING')
finally:
server.server_close()
def main(cls, RequestHandlerClass, port=80):
"""Start server with handler on given port.
This static method provides an easy way to start, run, and exit
a HttpServer instance. The server will be executed if possible,
and the computer's web browser will be directed to the address."""
server = None
try:
server = cls(('', port), RequestHandlerClass)
active = True
except socket.error:
active = False
else:
addr, port = server.socket.getsockname()
print('Serving HTTP on', addr, 'port', port, '...')
finally:
port = '' if port == 80 else f':{port}'
addr = 'http://localhost' + port + '/'
webbrowser.open(addr)
if active:
try:
server.serve_forever()
except KeyboardInterrupt:
print('Keyboard interrupt received: EXITING')
finally:
server.server_close()
def cmd_serve(parser):
if not site.home():
sys.exit("Error: cannot locate the site's home directory.")
if not os.path.exists(site.out()):
sys.exit("Error: cannot locate the site's output directory.")
os.chdir(site.out())
try:
server = http.server.HTTPServer(
(parser['host'], parser['port']),
http.server.SimpleHTTPRequestHandler
)
except PermissionError:
sys.exit("Permission error: use 'sudo' to run on a port number below 1024.")
address = server.socket.getsockname()
print("-" * 80)
print("Root: %s" % site.out())
print("Host: %s" % address[0])
print("Port: %s" % address[1])
print("Stop: Ctrl-C")
print("-" * 80)
if parser['browser']:
webbrowser.open("http://%s:%s" % (parser['host'], parser['port']))
try:
server.serve_forever()
except KeyboardInterrupt:
print("\n" + "-" * 80 + "Stopping server...\n" + "-" * 80)
server.server_close()
def assert_upload_stats(self, *, response_code) -> None:
stats = {'stats': {'foo': 'bar', 'baz': 42}}
class Handler(http.server.BaseHTTPRequestHandler):
def do_POST(handler):
try:
if handler.path.startswith('/redirect'):
code = int(handler.path[-3:])
handler.send_response(code)
handler.send_header('location', mk_url('/upload'))
handler.end_headers()
else:
self.assertEqual('/upload', handler.path)
self.assertEqual('application/x-www-form-urlencoded',
handler.headers['Content-type'])
length = int(handler.headers['Content-Length'])
post_data = parse_qs(
handler.rfile.read(length).decode())
decoded_post_data = {
k: json.loads(v[0])
for k, v in post_data.items()
}
self.assertEqual(stats, decoded_post_data)
self.assertEqual(handler.headers['User-Agent'],
f"pants/v{VERSION}")
self.assertIn(handler.headers['X-Pants-Stats-Version'],
{"1", "2"})
handler.send_response(response_code)
handler.end_headers()
except Exception:
handler.send_response(
400) # Ensure the main thread knows the test failed.
raise
server_address = ('', 0)
server = http.server.HTTPServer(server_address, Handler)
host, port = server.server_address
def mk_url(path):
return f'http://{host}:{port}{path}'
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
self.context(for_subsystems=[Cookies])
self.assertTrue(
RunTracker.post_stats(mk_url('/upload'), stats, stats_version=1))
self.assertTrue(
RunTracker.post_stats(mk_url('/redirect307'),
stats,
stats_version=1))
self.assertFalse(
RunTracker.post_stats(mk_url('/redirect302'),
stats,
stats_version=2))
server.shutdown()
server.server_close()
def serve():
handler = http.server.SimpleHTTPRequestHandler
server = socketserver.TCPServer(("", PORT), handler)
print("serving at port", PORT)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
def run_server(domain, port, request_handler):
server = http.server.HTTPServer((domain, port), request_handler)
print(time.asctime(), "Wires Server Start!")
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
print(time.asctime(), "Wires Server Stop")
def main():
server_address = ('', 8000)
server = http.server.HTTPServer(server_address, BuildRequestHandler)
print('Start http server on http://0.0.0.0:8000')
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
def main():
parser = argparse.ArgumentParser(
prog='videoboard',
description='A simple http server for visualizing videos and images',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--port', type=int, default=8000, help='port number.')
parser.add_argument('--logdir',
type=str,
default='.',
help='directory where videoboard '
'will look for videos and images.')
parser.add_argument('--height',
type=int,
default=320,
help='maximum height of image/video.')
parser.add_argument('--width',
type=int,
default=320,
help='maximum width of image/video.')
parser.add_argument('--file_name_length',
type=int,
default=30,
help='maximum length of file name.')
parser.add_argument('--recursive',
type=str2bool,
default=True,
choices=[True, False],
help='search files recursively.')
parser.add_argument('--display',
type=str2bool,
default=True,
choices=[True, False],
help='display videos and images.')
args = parser.parse_args()
# Change directory to prevent access to directories other than logdir
os.chdir(args.logdir)
class RequestHandlerWithArgs(RequestHandler):
_logdir = '.'
_max_height = args.height
_max_width = args.width
_max_file_name_length = args.file_name_length
_recursive = args.recursive
_display = args.display
server = http.server.HTTPServer(('', args.port), RequestHandlerWithArgs)
try:
print('Run videoboard server on port %d' % args.port)
server.serve_forever()
except KeyboardInterrupt:
pass
print('Close server')
server.server_close()
def update_image(self, qemu):
# We need to bring up some simple HTTP server for the
# OSTree repo. We cannot get the actual OSTREE_REPO for the
# image here, so we just assume that it is in the usual place.
# For the sake of simplicity we change into that directory
# because then we can use SimpleHTTPRequestHandler.
ostree_repo = os.path.join(get_bb_var('DEPLOY_DIR'), 'ostree-repo')
old_cwd = os.getcwd()
server = None
try:
os.chdir(ostree_repo)
class OSTreeHTTPRequestHandler(http.server.SimpleHTTPRequestHandler
):
def log_message(s, format, *args):
msg = format % args
self.logger.info(msg)
handler = OSTreeHTTPRequestHandler
def create_httpd():
for port in range(9999, 10000):
try:
server = http.server.HTTPServer(('localhost', port),
handler)
return server
except OSError as ex:
if ex.errno != errno.EADDRINUSE:
raise
self.fail('no port available for OSTree HTTP server')
server = create_httpd()
port = server.server_port
self.logger.info('serving OSTree repo %s on port %d' %
(ostree_repo, port))
helper = threading.Thread(name='OSTree HTTPD',
target=server.serve_forever)
helper.start()
with open(self.ostree_netcat.name, 'w') as f:
f.write('''#!/bin/sh
exec netcat 2>>/tmp/ostree.log localhost 9999
#exec socat 2>>/tmp/ostree.log -D -v -d -d -d -d STDIO TCP:localhost:%d
''' % port)
cmd = '''ostree config set 'remote "updates".url' http://%s && refkit-ostree update''' % self.OSTREE_SERVER
status, output = qemu.run_serial(cmd, timeout=600)
self.assertEqual(1, status,
'Failed to run command "%s":\n%s' % (cmd, output))
self.logger.info('Successful (?) update:\n%s' % output)
return True
finally:
os.chdir(old_cwd)
if server:
# server.shutdown() has been seen to hang when handling exceptions,
# so it isn't getting called at the moment.
server.server_close()
def http_server(host_port=9999):
"""
Start a webserver to return all models that registered since this
application started.
"""
server = http.server.HTTPServer(("", host_port), MyServer)
try:
server.serve_forever()
finally:
server.server_close()
def run(self):
server_address = ('', self.port)
server = http.server.HTTPServer(server_address, self.handler_class)
server.timeout = self.timeout
server.running = True
end = time.time() + self.timeout
while time.time() < end and server.running:
server.handle_request()
if not server.running:
server.server_close()
def serve(directory, host, port):
os.chdir(directory)
handler = http.server.SimpleHTTPRequestHandler
server = socketserver.TCPServer((host, port), handler)
print(f'Serving on http://{host}:{port}')
try:
server.serve_forever()
except KeyboardInterrupt:
pass
print('\nClosing server.')
server.server_close()
def signal_handler(signal, frame):
global httpd
global server
global RUN_PATCH
RUN_PATCH = False;
print('shutdown http and WS servers')
httpd.shutdown()
server.server_close()
print("ok")
sys.exit(0)
def main():
parser = argparse.ArgumentParser(description='File download server')
parser.add_argument('port', help='server port', type=int)
args = parser.parse_args()
server = http.server.HTTPServer(('', args.port), FileServerRequestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
def do_local_sso(provider):
ok = False
try:
port, server, th = do_start_local_webserver()
webbrowser.open(env.api.sso + "?redirect=" + env.api.zdmlocalredirect +
provider.lower() + "/" + str(port))
timeout = 120 # must be divisible by 20 to have tic - toc sequence
log("Hello!")
log("In a few seconds a browser will open the login page")
log("Once logged, you can go back to", provider)
while th.is_alive() and timeout > 0:
time.sleep(1)
if timeout % 20 == 0:
log("tic")
elif timeout % 10 == 0:
log("toc")
timeout -= 1
if TokenRequestHandler.result["done"]:
break
if TokenRequestHandler.result[
"done"] and not TokenRequestHandler.result[
"error"] and TokenRequestHandler.result["token"]:
info("Everything seems good!")
ok = True
if not ok:
warning("Something wrong!")
if not TokenRequestHandler.result["done"]:
warning("- never received a login response")
if not th.is_alive():
warning("- webserver not started")
if TokenRequestHandler.result["error"]:
warning("- there was an error:",
TokenRequestHandler.result["error"])
if not TokenRequestHandler.result["token"]:
warning("- login failed")
except Exception as e:
warning("Can't start SSO local web server", e)
try:
# shutdown server
server.server_close()
th.join(timeout=2)
except:
pass
if not ok:
error("Login not successful")
## force exit, there might be non daemon threads waiting in the background
os._exit(1)
else:
os._exit(0)
def main():
host = 'localhost'
port = 8001
url = f"http://{host}:{port}"
server = StoppableHttpServer((host, port), MyHandler)
print(f"contact me at [{url}]")
try:
server.serve_forever()
except KeyboardInterrupt:
print('CTRL+C received, shutting down server')
server.server_close()
def run(self):
SCLogger.init_loggers()
Proxy.cacher = Cacher()
server = ThreadedProxyServer(
(Config.app.bind_address, int(Config.app.bind_port)),
ProxyHandler)
SCLogger.app.info(
'Proxy is on {0}:{1}'.format(Config.app.bind_address, Config.app.bind_port))
try:
server.serve_forever()
except KeyboardInterrupt:
server.server_close()
SCLogger.app.info('Quit')
def start_web_server(self, port):
"""
:rtype : string
"""
server = http.server.HTTPServer(('', port), ScriptCallbackWebServer)
print('Started httpserver on port:', port)
server.now_serving = True
server.callback_code = None
# Wait for incoming http requests
# until a proper result is found
while server.now_serving:
server.handle_request()
server.server_close()
return server.callback_code
def web_loop(self):
port = 4444
print((self.CANEngine.ascii_logo_c))
WebConsole.can_engine = self.CANEngine
server = ThreadingSimpleServer(('', port), WebConsole)
print(("CANtoolz WEB started at port: ", port))
print("\tTo exit CTRL-C...")
try:
sys.stdout.flush()
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
server.server_close()
self.CANEngine.stop_loop()
print("gg bb")
exit()
def web_loop(self, host='127.0.0.1', port=4444):
print((self.CANEngine.ascii_logo_c))
WebConsole.can_engine = self.CANEngine
server = ThreadingSimpleServer((host, port), WebConsole)
print('CANtoolz WEB started and bound to: http://{0}:{1}'.format(host, port))
print("\tTo exit CTRL-C...")
try:
sys.stdout.flush()
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
server.server_close()
print("Please wait... (do not press ctr-c again!)")
self.CANEngine.stop_loop()
self.CANEngine.engine_exit()
print("gg bb")
exit()
def test_v11_get_request(self):
ServerHandler = self.make_http_server_handler("HTTP/1.1")
server = http.server.HTTPServer(("localhost", 8000), ServerHandler)
asyncio.ensure_future(
self.loop.run_in_executor(None, server.serve_forever))
asyncio.ensure_future(
self.get_coro_result(
self.v11_client.get("http://localhost:8000/get_test/")))
self.loop.run_forever()
server.shutdown()
server.server_close()
response = self.coro_result
self.assertEqual(response.status_code, 200,
"Wrong Status Code")
self.assertEqual(response.body, b"Hello, World!")
def test_upload_stats(self):
stats = {'stats': {'foo': 'bar', 'baz': 42}}
class Handler(http.server.BaseHTTPRequestHandler):
def do_POST(handler):
try:
if handler.path.startswith('/redirect'):
code = int(handler.path[-3:])
handler.send_response(code)
handler.send_header('location', mk_url('/upload'))
handler.end_headers()
else:
self.assertEqual('/upload', handler.path)
self.assertEqual('application/x-www-form-urlencoded', handler.headers['Content-type'])
length = int(handler.headers['Content-Length'])
post_data = parse_qs(handler.rfile.read(length).decode('utf-8'))
decoded_post_data = {k: json.loads(v[0]) for k, v in post_data.items()}
self.assertEqual(stats, decoded_post_data)
handler.send_response(200)
handler.end_headers()
except Exception:
handler.send_response(400) # Ensure the main thread knows the test failed.
raise
server_address = ('', 0)
server = http.server.HTTPServer(server_address, Handler)
host, port = server.server_address
def mk_url(path):
return 'http://{}:{}{}'.format(host, port, path)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
self.context(for_subsystems=[Cookies])
self.assertTrue(RunTracker.post_stats(mk_url('/upload'), stats))
self.assertTrue(RunTracker.post_stats(mk_url('/redirect307'), stats))
self.assertFalse(RunTracker.post_stats(mk_url('/redirect302'), stats))
server.shutdown()
server.server_close()
Interpret all HTTP GET requests as requests for server
documentation.
"""
response = self.generate_html_documentation().encode("utf-8")
print("Content-Type: text/html")
print("Content-Length: %d" % len(response))
print()
sys.stdout.flush()
sys.stdout.buffer.write(response)
sys.stdout.buffer.flush()
def __init__(self):
CGIXMLRPCRequestHandler.__init__(self)
XMLRPCDocGenerator.__init__(self)
if __name__ == "__main__":
server = SimpleXMLRPCServer(("localhost", 8000))
server.register_function(pow)
server.register_function(lambda x, y: x + y, "add")
print("Serving XML-RPC on localhost port 8000")
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
server.server_close()
sys.exit(0)
def main(stdscr):
global done, downloads, position, mode, max_x, max_y, scroll, menu_status, menu_results, menu_help, max_display, screen, sub_mode, port
server = None
if port != 0:
ThreadedTCPServer.allow_reuse_address = True
server = ThreadedTCPServer((hostname, port), HttpHandler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
download_thread = threading.Thread(target=process_download_queue)
download_thread.daemon = True
download_thread.start()
subreddit = ""
search = ""
screen = curses.initscr()
curses.curs_set(0)
(max_y, max_x) = screen.getmaxyx()
max_display = max_y - 4
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_RED)
curses.init_pair(3, curses.COLOR_BLUE, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_BLUE, curses.COLOR_RED)
curses.init_pair(5, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(6, curses.COLOR_GREEN, curses.COLOR_RED)
menu_results = curses.newpad(100, 300)
menu_status = curses.newpad(1, 300)
menu_help = curses.newpad(1, 300)
restore_state()
load_downloads()
draw_results()
draw_help()
if server:
set_status("web server started on " + gethostbyname(gethostname()) + ":" + str(port))
curses.doupdate()
while True:
c = screen.getch()
redraw = 0
if c == curses.KEY_RESIZE:
(max_y, max_x) = screen.getmaxyx()
max_display = max_y - 4
menu_results.clear()
redraw = 1
elif c == 6 or c == 338:
# ^F or pagedown
for i in range(0, max_display - 1):
if position >= max_display - 1 and scroll < len(mode_results[mode]) - max_display:
scroll += 1
elif position + scroll < len(mode_results[mode]) - 1:
position += 1
redraw = 1
elif c == 2 or c == 339:
# ^B or pageup
for i in range(0, max_display - 1):
if position <= 0 and scroll > 0:
scroll -= 1
elif position + scroll > 0:
position -= 1
redraw = 1
elif c == 10 or c == ord("c") or c == ord("m"):
if mode == "youtube" and c == ord("c"):
# get input
channel = get_input("channel: ", screen)
# load channel
position = 0
scroll = 0
search = ""
sub_mode = ""
load_youtube(channel, True)
menu_results.erase()
redraw = 1
else:
open_chat = False
if c == ord("c"):
open_chat = True
movie_mode = False
if c == ord("m"):
movie_mode = True
(status, redraw) = handle_selection(open_chat, movie_mode)
if redraw == 1:
menu_results.erase()
position = 0
scroll = 0
elif c == ord("1"):
mode = "downloads"
load_downloads()
menu_results.erase()
position = 0
scroll = 0
redraw = 1
elif c == ord("2"):
mode = "reddit"
menu_results.erase()
position = 0
scroll = 0
set_status(mode_status[mode])
redraw = 1
elif c == ord("3"):
mode = "youtube"
menu_results.erase()
position = 0
scroll = 0
set_status(mode_status[mode])
redraw = 1
elif c == ord("4"):
mode = "twitch"
menu_results.erase()
position = 0
scroll = 0
# load games by default
if len(mode_results[mode]) == 0:
load_twitch_games()
set_status(mode_status[mode])
redraw = 1
elif c == ord("a"):
handle_playall(screen)
elif c == ord("q"):
if server:
server.shutdown()
server.server_close()
break
elif c == ord("d"):
if mode == "downloads":
delete_selection()
menu_results.erase()
load_downloads()
update = len(mode_results[mode]) - (scroll + max_display)
if update < 0 and len(mode_results[mode]) >= max_display:
scroll += update
position -= update
if scroll < 0:
scroll = 0
if position >= len(mode_results[mode]):
position -= 1
redraw = 1
elif c == ord("/"):
if mode == "reddit":
# get input
search = get_input("search /r/" + subreddit + ": ", screen)
# load results
if search != "":
position = 0
scroll = 0
load_subreddit(subreddit, search)
menu_results.erase()
redraw = 1
elif mode == "youtube":
# get input
query = get_input("youtube: ", screen)
# load search results
if query != "":
position = 0
scroll = 0
load_youtube(query)
menu_results.erase()
redraw = 1
elif mode == "downloads":
# get input
mode_query[mode] = get_input("find: ", screen)
# find item
if mode_query[mode] != "":
new_scroll = find_result(mode_query[mode], 0)
if new_scroll == -1:
set_status("not found")
else:
position = 0
scroll = new_scroll
menu_results.erase()
redraw = 1
elif c == ord("t"):
if mode == "youtube":
show_thumbnail()
elif c == ord("n"):
if mode == "downloads":
# find item
if mode_query[mode] != "":
new_scroll = find_result(mode_query[mode], position + scroll + 1)
if new_scroll == -1:
set_status("not found")
else:
position = 0
scroll = new_scroll
menu_results.erase()
redraw = 1
elif c == ord("s"):
if mode == "reddit":
# get input
subreddit = get_input("subreddit: ", screen)
# load new subreddit
position = 0
scroll = 0
search = ""
load_subreddit(subreddit)
menu_results.erase()
redraw = 1
elif c == ord("g"):
if mode == "twitch":
# load twitch games
position = 0
scroll = 0
search = ""
sub_mode = ""
load_twitch_games()
menu_results.erase()
redraw = 1
elif c == ord("r"):
if mode == "reddit":
load_subreddit(subreddit, search, force=1)
menu_results.erase()
redraw = 1
elif mode == "downloads":
menu_results.erase()
load_downloads()
redraw = 1
elif mode == "twitch":
menu_results.erase()
if sub_mode == "":
load_twitch_games()
else:
load_twitch_streams()
redraw = 1
clamp_cursor()
elif c == curses.KEY_UP or c == ord("k"):
if position <= 0 and scroll > 0:
scroll -= 1
elif position + scroll > 0:
position -= 1
redraw = 1
elif c == curses.KEY_DOWN or c == ord("j"):
if position >= max_display - 1 and scroll < len(mode_results[mode]) - max_display:
scroll += 1
elif position + scroll < len(mode_results[mode]) - 1:
position += 1
redraw = 1
if redraw:
draw_results()
draw_help()
curses.doupdate()
curses.endwin()
done = 1
download_thread.join()
