def main(args=None, default_port=8000): """ Run the echo HTTP server. """ args = build_arg_parser().parse_args(args) port = args.port if port is None: port = default_port bound = False while not bound: try: httpd = BaseHTTPServer.HTTPServer((args.address, port), EchoHTTPRequestHandler) except socket.error: port += 1 if port > 65535: raise ValueError("No available port found") else: bound = True else: httpd = BaseHTTPServer.HTTPServer((args.address, int(port)), EchoHTTPRequestHandler) print("httpd-echo, Copyright © 2017 rpatterson, 2021 Greg Werbin") print("This program comes with ABSOLUTELY NO WARRANTY.") print( "This is Free Software, and you are welcome to redistribute it under certain conditions." ) print("Echoing HTTP at http://{0}:{1} ...".format(args.address, port)) httpd.serve_forever()
def manual_flow(self): params = { 'client_id': self.client_id, 'redirect_uri': self.redirect_uri, 'response_type': 'code', 'scope': 'all', 'state': str(uuid.uuid4()), } query = urllib.parse.urlencode(params) url_parts = ('https', self.host, self.authorize_endpoint, None, query, None) url = urllib.parse.urlunparse(url_parts) webbrowser.open_new(url) server_address = ('', self.port) httpd = BaseHTTPServer.HTTPServer(server_address, OAuthResponseHandler) sa = httpd.socket.getsockname() print('Server started on {}:{}...'.format(sa[0], sa[1])) httpd.handle_request() if httpd.query_params.get('state') == params['state']: code = httpd.query_params.get('code') credentials = self.request_access_token('authorization_code', code=code) return credentials
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 get_webdriver_request_headers(webdriver): # There's a small chance that the port was taken since the call of # get_unused_port(), so make sure we try as often as needed while True: port = get_unused_port() try: server = BaseHTTPServer.HTTPServer(('', port), HTTPRequestHandler) logger.info("监听PORT:"+str(port)) break except socket.error: pass threading.Thread(target=server.handle_request).start() original_window_handle = webdriver.current_window_handle # webdriver.execute_script("window.open('http://127.0.0.1:%d/');" % port) requests.get("http://127.0.0.1:%d/" % port) update_headers_mutex.acquire() # Possibly optional: Make sure that the webdriver didn't switch the window # handle to the newly opened window. Behaviors of different webdrivers seem # to differ greatly here if webdriver.current_window_handle != original_window_handle: webdriver.switch_to.window(original_window_handle) global headers headers_ = headers headers = None # Remove the host header, which will simply contain the localhost address # of the HTTPRequestHandler instance del headers_['host'] return headers_
def get_webdriver_request_headers(webdriver): # There's a small chance that the port was taken since the call of get_unused_port(), so make sure we try as often # as needed while True: port = get_unused_port() try: server = BaseHTTPServer.HTTPServer(('', port), HTTPRequestHandler) break except socket.error: pass threading.Thread(target=server.handle_request).start() original_window_handle = webdriver.current_window_handle webdriver.execute_script("window.open('http://127.0.0.1:%d/', '_blank');" % port) update_headers_mutex.acquire() # Not optional: Make sure that the webdriver didn't switch the window handle to the newly opened window. Behaviors # of different webdrivers seem to differ here. Workaround for Firefox: If a new window is opened via JavaScript as a # new tab, requesting self.current_url never returns. Explicitly switching to the current window handle again seems # to fix this issue. webdriver.switch_to.window(original_window_handle) global headers headers_ = headers headers = None # Remove the host header, which will simply contain the localhost address of the HTTPRequestHandler instance del headers_['host'] return headers_
def __init__(self, port): class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_POST(self): def verify(signature, data): try: sha, signature = signature.split('=') except ValueError: return False if sha != 'sha1': return False mac = hmac.new(os.environb.get(b'SECRET', bytes()), data, hashlib.sha1) return hmac.compare_digest(mac.hexdigest(), signature) length = int(self.headers.get('Content-Length', 0)) data = self.rfile.read(length) if not verify(self.headers.get('X-Hub-Signature'), data): self.send_error(403) return event = self.headers.get('X-GitHub-Event') if event == 'ping': self.send_response(200) return if event == 'release': data = json.loads(data) url = data.get('clone_url') tag = data.get('release', {}).get('tag_name') PyPI.release(url, tag) self.send_response(200) self.server = BaseHTTPServer.HTTPServer(('', port), RequestHandler)
def __init__(self): self.received = [] self.paused = False class Handler(BaseHTTPServer.BaseHTTPRequestHandler): def do_POST(handler): start = time.time() while self.paused: if time.time() > (start + 0.5): raise Exception('Paused HTTP server timeout') time.sleep(0.001) length = int(handler.headers['Content-Length']) raw_body = handler.rfile.read(length).decode('utf-8') if handler.path != '/ignore': self.received.append({'headers': handler.headers, 'json_body': json.loads(raw_body), 'path': handler.path, 'method': handler.command}) handler.send_response(200) handler.end_headers() return () def log_request(self, *args): pass self.server = BaseHTTPServer.HTTPServer(('localhost', 0), Handler) self.server.timeout = 0.5 self.thread = Thread(target=self.server.serve_forever, args=(0.1,)) self.thread.daemon = True self.thread.start()
def _make_server(port, request_handler): server = BaseHTTPServer.HTTPServer(("localhost", port), request_handler) t = threading.Thread(target=server.serve_forever) # Set daemon just in case something fails t.daemon = True t.start() return server, t
def on_server_start(self): """Initialize service.""" handler = AMTServerHandler handler.emit = self.add_alert_to_queue self.server = BaseHTTPServer.HTTPServer(("0.0.0.0", AMT_PORT), handler) self.signal_ready() self.server.serve_forever()
def __init__(self, port, cert, root, report_size): class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(self): path = self.path.split('?', 1)[0].split('#', 1)[0] path = urllib.parse.unquote(path) path = posixpath.normpath(path) path = os.path.join(root, path.lstrip('/')) try: with open(path, 'rb') as f: data = f.read() self.send_response(200) content_type = 'application/json' if 'versioneers' in path else 'application/octet-stream' self.send_header('Content-Type', content_type) self.send_header('Content-Transfer-Encoding', 'binary') if report_size: self.send_header('Content-Length', len(data)) self.end_headers() self.wfile.write(data) except FileNotFoundError: self.send_error(404) self.server = BaseHTTPServer.HTTPServer(('', port), RequestHandler) if cert: self.server.socket = ssl.wrap_socket(self.server.socket, certfile=cert, server_side=True)
def start_server(): class OAuthRedirectHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(self): parsed_path = urlparse(self.path) query = parse_qs(parsed_path.query) access_token = query["access_token"][ 0] if "access_token" in query else None if not access_token: print("Something went wrong! Please try again.") sys.exit() print("Access token auto-detected!") access_token_queue.put(access_token) # Redirect user's browser self.send_response(301) self.send_header( "Location", "{}/{}".format(get_base_http_url(), "/oauth/github/success")) self.end_headers() # Silence logs def log_message(self, _format, *args): return server = BaseHTTPServer.HTTPServer((LOOPBACK, port), OAuthRedirectHandler) server_started_queue.put(True) server.handle_request()
def __init__(self, cb, listening_address, **kwargs): super(EventForwarderHTTPSource, self).__init__() self.daemon = True http_parts = urllib.parse.urlparse(listening_address) addr_parts = http_parts.netloc.split(":") listening_host = addr_parts[0] if len(addr_parts) == 2: port = int(addr_parts[1]) listening_host = addr_parts[0] else: if http_parts.scheme == "https": port = 443 else: port = 80 self.listening_address = listening_address self.httpd = BaseHTTPServer.HTTPServer( (listening_host, port), SimpleHTTPServer.SimpleHTTPRequestHandler) if http_parts.scheme == "https": keyfile = kwargs.get("keyfile", None) certfile = kwargs.get("certfile", None) if not keyfile or not certfile: raise CredentialError( "Need to specify 'keyfile' and 'certfile' for HTTPS") self.httpd.socket = ssl.wrap_socket(self.httpd.socket, certfile=certfile, keyfile=keyfile, server_side=True)
def test_list_fail(lib): proxy = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock) proxy.expectations = [ (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (501, {}, "")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "lskj")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "{}")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "{\"objects\":[]}")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "{\"prefixes\":[]}")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "{\"objects\":[]\"prefixes\":[]}")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "{\"objects\":[{}]\"prefixes\":[]}")), ] proxy_url = str(proxy.server_name) + ':' + str(proxy.server_port) service = Service(proxy) service.start() cfg = json.dumps({"NS": {"proxy": proxy_url}}).encode('utf-8') try: lib.test_init(cfg, b"NS") lib.test_list_badarg(cfg, b"NS") while len(proxy.expectations) > 0: # invalid HTTP reply status lib.test_list_fail(cfg, b"NS", b"NS/ACCT/JFS") assert (0 == len(proxy.expectations)) finally: proxy.shutdown() service.join()
def __init__(self, is_chief): self._init() self._lock = Lock() self._thread = None self.started = False self.is_chief = is_chief if is_chief: self._httpd = BaseHTTPServer.HTTPServer((FLAGS.coord_host, FLAGS.coord_port), TrainingCoordinator.make_handler(self))
def start_mock_server(port, daemon=True): mock_server = BaseHTTPServer.HTTPServer(('localhost', port), MockServerRequestHandler) mock_server_thread = Thread(target=mock_server.serve_forever) if daemon: mock_server_thread.setDaemon(True) mock_server_thread.start() return mock_server
def __init__(self, ota_filename, serving_range): threading.Thread.__init__(self) # serving_payload and serving_range are class attributes and the # UpdateHandler class is instantiated with every request. UpdateHandler.serving_payload = ota_filename UpdateHandler.serving_range = serving_range self._httpd = BaseHTTPServer.HTTPServer(('127.0.0.1', 0), UpdateHandler) self.port = self._httpd.server_port
def run_server(root, server_address, initialized): os.chdir(root) SimpleHTTPRequestHandler.protocol_version = "HTTP/1.0" httpd = BaseHTTPServer.HTTPServer(server_address, SimpleHTTPRequestHandler) sa = httpd.socket.getsockname() print("Serving HTTP on {0} port {1}...".format(sa[0], sa[1])) initialized.set() httpd.serve_forever()
def __init__(self, processor, address, proto_factory): """Initialize an FHttpServer. Args: processor: FProcessor used to process requests. address: tuple of host name and port. proto_factory: FProtocolFactory used to read requests and write responses. """ class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_POST(self): length = self.headers.getheader('Content-Length') payload = b64decode(self.rfile.read(int(length))) response_limit = int(self.headers.getheader( 'x-frugal-payload-limit', 0)) if len(payload) <= 4: logging.exception( 'Invalid request frame length {}'.format(len(payload))) self.send_response(400) self.end_headers() return itrans = TTransport.TMemoryBuffer(payload[4:]) otrans = TTransport.TMemoryBuffer() iprot = proto_factory.get_protocol(itrans) oprot = proto_factory.get_protocol(otrans) try: processor.process(iprot, oprot) except TApplicationException: # Continue so the exception is sent to the client pass except Exception: self.send_response(400) self.end_headers() return # Encode response. response = otrans.getvalue() if len(response) > response_limit > 0: self.send_response(413) self.end_headers() return frame_length = pack('!I', len(response)) frame = b64encode(frame_length + response) self.send_response(200) self.send_header('Content-Type', 'application/x-frugal') self.send_header('Content-Length', len(frame)) self.send_header('Content-Transfer-Encoding', 'base64') self.end_headers() self.wfile.write(frame) self._httpd = BaseHTTPServer.HTTPServer(address, RequestHandler)
def start_server(self): def do_GET(self): """Serve a GET request.""" f = self.send_head() if f: try: self.copyfile(f, self.wfile) finally: f.close() t = threading.Thread(target=self.server.shutdown) t.daemon = True t.start() print( 'File transfer was completed.Server is shutdowning.....' ) def translate_path(self, path): """Translate a /-separated PATH to the local filename syntax. Components that mean special things to the local file system (e.g. drive or directory names) are ignored. (XXX They should probably be diagnosed.) """ import posixpath from six.moves.urllib_parse import unquote # abandon query parameters path = path.split('?', 1)[0] path = path.split('#', 1)[0] # Don't forget explicit trailing slash when normalizing. Issue17324 trailing_slash = path.rstrip().endswith('/') path = posixpath.normpath(unquote(path)) words = filter(None, path.split('/')) path = to_abs_path() for word in words: if os.path.dirname(word) or word in (os.curdir, os.pardir): # Ignore components that are not a simple file/directory name continue path = os.path.join(path, word) if trailing_slash: path += '/' return path print('Starting Server.....') SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET = do_GET SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path = translate_path try: server = BaseHTTPServer.HTTPServer( ('', self.port), SimpleHTTPServer.SimpleHTTPRequestHandler) except Exception as e: print(e) print('Server has already started') else: thread = threading.Thread(target=server.serve_forever, name='server') thread.deamon = True thread.start() thread.join() os.remove(self.send_path)
def __init__(self): sock = socket.socket() sock.bind(('', 0)) self.port = sock.getsockname()[1] self.blocking = True self._server = BaseHTTPServer.HTTPServer(('127.0.0.1', self.port), CallbackHandler) self._server.result = {} self._server.stop = self.stop
def __init__(self, test_server_spawner_port, port_forwarder, max_instances): self.server = BaseHTTPServer.HTTPServer(('', test_server_spawner_port), SpawningServerRequestHandler) self.server_port = self.server.server_port _logger.info('Started test server spawner on port: %d.', self.server_port) self.server.port_forwarder = port_forwarder self.server.test_servers = {} self.server.max_instances = max_instances
def __init__(self, is_chief): self._init() self._lock = Lock() self._thread = None self.started = False self.is_chief = is_chief if is_chief: self._httpd = BaseHTTPServer.HTTPServer( ('localhost', 2500), TrainingCoordinator.make_handler(self))
def __init__(self, port): Thread.__init__(self) self.port = port self.uri = 'http://localhost:%d' % port self.server = BaseHTTPServer.HTTPServer(('localhost', port), MockServerRequestHandler) self.server.server_wrapper = self self.matchers = {} self.requests = queue.Queue()
def run_ssl_server(): cert_file = os.path.join(CERTIFICATE_DIR, 'server.pem') httpd = BaseHTTPServer.HTTPServer((SSL_SERVER_ADDRESS, SSL_SERVER_PORT), StandaloneAppsResponseHandler) httpd.socket = ssl.wrap_socket(httpd.socket, certfile=cert_file, server_side=False) httpd.timeout = 5 threading.Thread(target=httpd.handle_request).start() time.sleep(0.5) return httpd
def main(port=8000): server = BaseHTTPServer.HTTPServer(('0.0.0.0', port), SimpleHTTPRequestHandler) try: print('Serving HTTP on 0.0.0.0 port %d ...' % port) print('local IP address is %s' % globals()['_stash'].libcore.get_lan_ip()) server.serve_forever() except KeyboardInterrupt: print('Server shutting down ...') server.server_close()
def main(_): server_address = ('localhost', FLAGS.port) clusters = load_clusters(FLAGS.clusters_path) # Default to overwriting the input. output_path = FLAGS.output_path or FLAGS.clusters_path def create_request_handler(*args): return handler.LabelerHTTPRequestHandler(clusters, output_path, *args) server = BaseHTTPServer.HTTPServer(server_address, create_request_handler) print('Listening on port %d...', FLAGS.port) server.serve_forever()
def main(args=None, default_port=8000): """ Run the echo HTTP server. """ import argparse parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--address', '-a', default='localhost', help='Hostname or IP address to accept requests on.') parser.add_argument( '--port', '-p', help='Port to accept requests on. ' 'If not specified, use the first available port after 8000.') args = parser.parse_args(args) port = args.port if port is None: port = default_port bound = False while not bound: try: httpd = BaseHTTPServer.HTTPServer((args.address, port), EchoHTTPRequestHandler) except socket.error: port += 1 if port > 65535: raise ValueError('No available port found') else: bound = True else: httpd = BaseHTTPServer.HTTPServer((args.address, int(port)), EchoHTTPRequestHandler) print('Echoing HTTP at http://{0}:{1} ...'.format(args.address, port)) httpd.serve_forever()
def run(self): """Start the HTTP server thread.""" self.server = http_server.HTTPServer( server_address=(self.host, self.port), RequestHandlerClass=self.request_handler) self.server.requests = self.requests_queue self.server.responses = self.responses_queue self.server.handler_attributes = self.handler_attributes self.server.timeout = self.timeout self.server.interval = self.interval nothing = lambda msg: None self.server.log_callback = self.logger.debug if self.logger else nothing self.server.serve_forever()
def __init__(self): assert issubclass(self._HANDLER_CLS, Handler), self._HANDLER_CLS self._closed = False self._stopped = False self._server = BaseHTTPServer.HTTPServer(('127.0.0.1', 0), self._HANDLER_CLS) self._server.parent = self self._server.url = self.url = 'http://127.0.0.1:%d' % ( self._server.server_port) self._thread = threading.Thread(target=self._run, name='httpd') self._thread.daemon = True self._thread.start() logging.info('%s', self.url)
def get_http_server(address=None, port=None): addon = xbmcaddon.Addon('plugin.video.youtube') address = address if address else addon.getSetting('kodion.http.listen') address = address if re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', address) else '0.0.0.0' port = int(port) if port else 50152 try: server = BaseHTTPServer.HTTPServer((address, port), YouTubeRequestHandler) return server except socket.error as e: xbmc.log('[plugin.video.youtube] HTTPServer: Failed to start |{address}:{port}| |{response}|'.format(address=address, port=port, response=str(e)), xbmc.LOGDEBUG) xbmcgui.Dialog().notification(addon.getAddonInfo('name'), str(e), xbmc.translatePath('special://home/addons/{0!s}/icon.png'.format(addon.getAddonInfo('id'))), 5000, False) return None