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()