def main(): global values parser = argparse.ArgumentParser(description='MEW HTTP Server') parser.add_argument('-i', '--input', type=argparse.FileType('r'), help='Variable names', required=True) parser.add_argument('-a', '--answer', type=argparse.FileType('r'), help='Variable values', required=True) params = parser.parse_args() variables_list = get_file_tokens(params.input) if len(variables_list) != 4: print('Expected 4 variable names found %d names' % len(variables_list)) sys.exit(1) params.input.close() values_list = get_file_tokens(params.answer) if len(values_list) != 4: print('Expected 4 values found %d values' % len(values_list)) params.answer.close() values = {} for i in range(4): values[variables_list[i]] = values_list[i] server = hs.HTTPServer(('127.0.0.1', 7777), MyHTTPHandler) server.serve_forever()
def run(): """ runs the http server """ ip_address = 'localhost' port = 3280 handler = generate_handler() srv = server.HTTPServer((ip_address, port), handler) sys.stdout.flush() def start_browser(): """ opens the browser """ return webbrowser.open('http://{}:{}'.format(ip_address, port)) threading.Thread(target=start_browser).start() try: srv.serve_forever() except (KeyboardInterrupt, SystemExit): print('stopped server') srv.server_close()
def setUp(self): self['request_handler'] = self.request_handler self['httpd'] = http_server.HTTPServer( (self.host, self.port), self.request_handler) self['httpd_thread'] = threading.Thread( target=self['httpd'].serve_forever) self['httpd_thread'].daemon = True self['httpd_thread'].start() # Wait as it sometimes takes a while to get the server started. # XXX this is a little kludgy time.sleep(0.001) port = self['httpd'].server_port self['http_host'] = self.host self['http_port'] = port self['http_address'] = f'{self.host}:{port}' # XXX copy&paste from gocept.httpserverlayer.wsgi orig_flush = self['_orig_handler_flush'] = ( wsgiref.handlers.SimpleHandler._flush) def silent_flush(self): try: orig_flush(self) except OSError as e: if e.args[0] != 32: raise wsgiref.handlers.SimpleHandler._flush = silent_flush
def concrete_server_factory( request_handler_class: typing.Type[httpserver.BaseHTTPRequestHandler], ) -> typing.Tuple[str, int]: """ Create web server with given request handler. The web server is also started automatically in a thread. The thread automatically stops when the parent stops. Parameters ---------- request_handler_class: typing.Type[httpserver.BaseHTTPRequestHandler] Request handler which handles the requests send to the web server. Returns ------- typing.Tuple[str, int] typing.Tuple containing the servers domain ("localhost") and the port it is listening on. """ mock_server_domain = "localhost" mock_server_port = free_port mock_server = httpserver.HTTPServer( (mock_server_domain, mock_server_port), request_handler_class, ) mock_server_thread = threading.Thread(target=mock_server.serve_forever) mock_server_thread.setDaemon(True) mock_server_thread.start() return mock_server_domain, mock_server_port
def run(): if len(sys.argv) != 1: print(__doc__) sys.exit(1) server_address = ('', 9885) httpd = server.HTTPServer(server_address, Handler) httpd.serve_forever()
def main(): # Terminate process when Kubernetes sends SIGTERM. signal.signal(signal.SIGTERM, lambda *_: sys.exit(0)) server_address = ('', 8000) httpd = server.HTTPServer(server_address, MyRequestHandler) httpd.serve_forever()
def __init__(self, host="0.0.0.0", port=80, log_function=None, staticdir="static", staticindex="index.html", include_fp=['{staticdir}/*'], exclude_fp=[], error_404_page_func=None): self.host = host self.port = port self.log_function = log_function self.staticdir = staticdir self.staticindex = staticindex self.include_fp = include_fp self.exclude_fp = exclude_fp self.error_404_page_func = error_404_page_func self.request_handler_class = self.WebRequestHandler self.resource_dict = {} self.set_default_handler("GET", self.default_GET_handler) setattr(self.request_handler_class, 'log_string', classmethod(self.log_string)) setattr(self.request_handler_class, 'get_404_page', classmethod(self.get_404_page)) self.httpd = http_server.HTTPServer((self.host, self.port), self.request_handler_class)
def load_in_default_browser(html): """ Opens the html content in the default web browser by temporarily launching a http get server and providing the CCOBRA html output. Parameters ---------- html : str Html content to serve. """ class RequestHandler(httpserver.BaseHTTPRequestHandler): """ CCOBRA html request handler. """ def do_GET(self): """ Implement the get request handler responding with the html content. """ self.protocol_version = 'HTTP/1.0' self.send_response(200) self.send_header('Content-type', 'text/html') self.send_header('Content-length', len(html)) self.end_headers() buffer_size = 1024 ** 2 for idx in range(0, len(html), buffer_size): self.wfile.write(html[idx:idx+buffer_size]) server = httpserver.HTTPServer(('127.0.0.1', 0), RequestHandler) webbrowser.open('http://127.0.0.1:{}'.format(server.server_port)) server.handle_request()
def start(path: str, ip: str, port: int): '''Starts the server Args: path (str): The path to the files being served ip (str): The ip address or localhost port (int): The port number ''' log.info("Server starting up\n") global homeFiles homeFiles = path print(ip + ":" + str(port)) log.info("Server on: " + ip + ":" + str(port)) t = http.HTTPServer((ip, port), handleRequest) try: t.serve_forever() except KeyboardInterrupt: pass finally: print("Server shutting down\n") log.info("Server shutting down\n") logging.shutdown()
def oauth_desktop_login(self, ruri=None): """ Log into FamilySearch using OAuth2 Authentication. This is primarily a convenience function for desktop apps. Not normally intended for production apps, but should work while waiting for approval for password login. Default Redirect URI is "http://localhost:63342/fslogin", but you can set your own as a paramater. """ if ruri is None: ruri = "http://localhost:63342/fslogin" self.logged_in = False self.cookies.clear() url = self.root_collection['response']['collections'][0]['links']\ ['http://oauth.net/core/2.0/endpoint/authorize']['href'] url = self._add_query_params( url, { 'response_type': 'code', 'client_id': self.dev_key, 'redirect_uri': ruri, }) webbrowser.open(url) server.HTTPServer(('', 63342), Getter).handle_request() # Now that we have the authentication token, grab the access token. self.oauth_code_login(qs)
def __init__(self, port, certfile, keyfile): """ Parameters ---------- port : int Port to run the local server on. certfile : str keyfile : str """ self.httpd = None if not certfile or not keyfile: certfile, keyfile = create_localhost_cert() if not certfile or not keyfile: Logger.error( '[LocalServerHTTPS.__init__] No certfile and/or no keyfile. Cannot start HTTPS server.' ) return if hasattr(server, 'ThreadingHTTPServer'): self.httpd = server.ThreadingHTTPServer(('', port), APIRequestHandler) else: Logger.warn('http.server.ThreadingHTTPServer not available. ' 'Using fallback to http.server.HTTPServer instead.') self.httpd = server.HTTPServer(('', port), APIRequestHandler) self.httpd.socket = ssl.wrap_socket(self.httpd.socket, certfile=certfile, keyfile=keyfile, server_side=True)
def __init__(self): super(WebappsQmlContentHttpServer, self).__init__() self.server = http.HTTPServer(("", 0), RequestHandler) self.server.allow_reuse_address = True self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.start() logging.info("now serving on port {}".format(self.server.server_port))
def build_httpd(secure=None): """ build an http daemon Builds an HTTP server instance on a random local port which can be used to verify HTTP/HTTPS request handling for various releng-tool features. By default, an HTTP is spawned with `secure` set to `False`. When building a "secure" HTTP server, key/cert. files are used from the assets folder. Args: secure (optional): whether or not a secure http server should be made Returns: the http server """ LOCAL_RANDOM_PORT = ('127.0.0.1', 0) httpd = http_server.HTTPServer(LOCAL_RANDOM_PORT, MockServerRequestHandler) httpd.req = {} httpd.rsp = [] if secure: keyfile, certfile = fetch_cert_files() context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) context.load_cert_chain(certfile, keyfile=keyfile) httpd.socket = context.wrap_socket(httpd.socket, server_side=True) return httpd
def run(self): self.exited = False self.httpd = server.HTTPServer(self.server_address, self.server_handler_class) while self.should_continue: self.httpd.handle_request() self.exited = True
def start_http_server(image_id, image_data): def _get_http_handler_class(fixture): class StaticHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(self): self.send_response(200) self.send_header('Content-Length', str(len(fixture))) self.end_headers() self.wfile.write(fixture) return def do_HEAD(self): self.send_response(200) self.send_header('Content-Length', str(len(fixture))) self.end_headers() return def log_message(self, *args, **kwargs): # Override this method to prevent debug output from going # to stderr during testing return return StaticHTTPRequestHandler server_address = ('127.0.0.1', 0) handler_class = _get_http_handler_class(image_data) httpd = BaseHTTPServer.HTTPServer(server_address, handler_class) port = httpd.socket.getsockname()[1] pid = os.fork() if pid == 0: httpd.serve_forever() else: return pid, port
def main(): httpd = http.HTTPServer(('0.0.0.0', 8000), Request_Handler) try: print("Receive running on port 8000") httpd.serve_forever() except KeyboardInterrupt: httpd.server_close() print("Done")
def run_server(): server_address = ('', 8000) httpd = _hs.HTTPServer(server_address, RequestHandler) trace('server is starting...') global server_keeps_running while server_keeps_running: httpd.handle_request() trace('server has stopped')
def run(port=8080): server_address, handler = ('', port), RequestHandler httpd = server.HTTPServer(server_address, handler) print(("Server running on port http://localhost:{}.".format( server_address[1]))) print("Press CTRL+C to Quit.") httpd.serve_forever()
def __init__(self, *args): super().__init__() self.port = args[0] self.logger = args[1] self.ip = self.getIP() self.print_name = "Webserver" self.httpd = webserver.HTTPServer(('', 80), webserver.BaseHTTPRequestHandler)
def __init__(self): # port == 0 will assign a random free port self.handler = HTTPRequestHandler self.server = http.HTTPServer(("", 0), self.handler) self.server.allow_reuse_address = True self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.start() logging.info("now serving on port {}".format(self.server.server_port))
def api_server(api_server_port): mock_server = server.HTTPServer( ("localhost", api_server_port), api_mock.MockApiServer ) mock_server_thread = threading.Thread(target=mock_server.serve_forever) mock_server_thread.setDaemon(True) mock_server_thread.start() return mock_server
def main(): serverAddress = ('', 8080) se = server.HTTPServer(serverAddress, RequestHandler) try: se.serve_forever() except KeyboardInterrupt: pass se.server_close()
def run(): port = 8081 if 'port' in options: port = int(options['port']) local_server = server_class.HTTPServer(('localhost', port), instance_for(captured_scope)) print('Serving on http://localhost:8081') local_server.serve_forever(0.1)
def __init__(self, port: int, work_dir: str, certfile: str, keyfile: str): self.work_dir = work_dir self._ssl = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) # openssl req -new -x509 -days 3650 -nodes -out mycertfile.pem -keyout mykeyfile.pem self._ssl.load_cert_chain(certfile, keyfile) self.httpd = server.HTTPServer(('localhost', port), HTTPRequest) self.httpd.socket = self._ssl.wrap_socket(self.httpd.socket, server_side=True)
def login_server(login_server_port): mock_server = server.HTTPServer( ("localhost", login_server_port), login_mock.MockLoginServer ) mock_server_thread = threading.Thread(target=mock_server.serve_forever) mock_server_thread.setDaemon(True) mock_server_thread.start() return mock_server
def setUpClass(cls): cls.server = server.HTTPServer(('', 27489), MockBugzillaServer) cls.bugzillaProvider = BugzillaProvider({ 'General': {'env': 'dev'}, 'apikey': 'bob', 'url': 'http://localhost:27489/', }) cls.bugzillaProvider.update_config(SimpleLoggerConfig)
def main(args): try: port = int(args[1]) except IndexError: port = 8000 server_address = ('', port) httpd = BaseHTTPServer.HTTPServer(server_address, LoggingProxyHTTPHandler) httpd.serve_forever()
def serve(host=HOST, port=PORT, open_browser=False): server_address = (HOST, port) SimpleHTTPRequestHandler.protocol_version = "HTTP/1.0" os.chdir(ROOT_DST_PATH) httpd = BaseHTTPServer.HTTPServer(server_address, SimpleHTTPRequestHandler) print("Serving HTTP on %s port %d ..." % server_address) if open_browser: webbrowser.open_new_tab("http://%s:%d" % server_address) httpd.serve_forever()
def serve(html, ip='127.0.0.1', port=8888, n_retries=50, files=None, ipython_warning=False, open_browser=True, http_server=None): """Start a server serving the given HTML, and (optionally) open a browser Parameters ---------- html : string HTML to serve ip : string (default = '127.0.0.1') ip address at which the HTML will be served. port : int (default = 8888) the port at which to serve the HTML n_retries : int (default = 50) the number of nearby ports to search if the specified port is in use. files : dictionary (optional) dictionary of extra content to serve ipython_warning : bool (optional) if True (default), then print a warning if this is used within IPython open_browser : bool (optional) if True (default), then open a web browser to the given HTML http_server : class (optional) optionally specify an HTTPServer class to use for showing the figure. The default is Python's basic HTTPServer. """ port = find_open_port(ip, port, n_retries) Handler = generate_handler(html, files) if http_server is None: srvr = server.HTTPServer((ip, port), Handler) else: srvr = http_server((ip, port), Handler) if ipython_warning: print(IPYTHON_WARNING) # Start the server print("Serving to http://{0}:{1}/ [Ctrl-C to exit]".format(ip, port)) sys.stdout.flush() if open_browser: # Use a thread to open a web browser pointing to the server b = lambda: webbrowser.open('http://{0}:{1}'.format(ip, port)) threading.Thread(target=b).start() try: srvr.serve_forever() except (KeyboardInterrupt, SystemExit): print("\nstopping Server...") srvr.server_close()
def mcpi_central_server(id, secret, client, db_url): handler = APIServer(id, secret, client, db_url) server = http.HTTPServer(("0.0.0.0", int(environ.get("PORT"))), handler) try: server.serve_forever() except KeyboardInterrupt: handler.db.close() print() return 0