def connect(self, attempts=1): try: self._server = BaseHTTPServer.HTTPServer(('127.0.0.1', self.port), CallbackHandler) except socket.error: if attempts < 5: self.port += random.randint(1, 1000) self.connect(attempts + 1) else: logging.info( "Unable to start local server, proceeding manually") class FakeServer(): def serve_forever(self): pass self._server = FakeServer()
def test_url(self): archive_path = self.archive_path port = random.choice(xrange(7000, 10000)) server_address = ("127.0.0.1", port) httpd = BaseHTTPServer.HTTPServer( server_address, ArchiveServerHandlerFactory(archive_path)) t = threading.Thread(target=httpd.serve_forever) t.start() bootstrap(self.path, "http://127.0.0.1:%s" % port) httpd.shutdown() self.assertEqual( sorted(fileList(self.path, relative=True)), sorted(fileList(self.skeleton_path, relative=True)), )
def run_http_server(request_handler_class): while True: port = get_unused_port() try: server = BaseHTTPServer.HTTPServer(('', port), request_handler_class) break except socket.error: pass def run(): while True: server.handle_request() thread = threading.Thread(target=run) thread.daemon = True thread.start() return 'http://127.0.0.1:%d/' % port
def gzip_server(gzipped_json): class MyHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "application/octet-stream") s.end_headers() s.wfile.write(gzipped_json) host = '' port = 8080 addr = host, port httpd = BaseHTTPServer.HTTPServer(addr, MyHandler) url = 'http://localhost:{port}/'.format(**locals()) try: threading.Thread(target=httpd.serve_forever).start() yield url finally: httpd.shutdown() httpd.server_close()
def get_http_server(address=None, port=None): addon_id = 'plugin.video.youtube' addon = xbmcaddon.Addon(addon_id) 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: logger.log_debug( 'HTTPServer: Failed to start |{address}:{port}| |{response}|'. format(address=address, port=port, response=str(e))) xbmcgui.Dialog().notification( addon.getAddonInfo('name'), str(e), "{}/icon.png".format(addon.getAddonInfo('path')), 5000, False) return None
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
def serve_page(self, port, callback): # This is an array so AppConfigHandler doesn't create an instance variable when trying to set the state to False running = [True] class AppConfigHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(self): path, query = self.path.split('?', 1) if path == '/close': self.send_response(200) self.end_headers() self.wfile.write("OK") running[0] = False callback(query) else: self.send_response(404) self.end_headers() self.wfile.write("Not Found") server = BaseHTTPServer.HTTPServer(('', port), AppConfigHandler) while running[0]: server.handle_request()
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 start_standalone_http_server(): def _get_http_handler_class(): class StaticHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(self): data = b"Hello World!!!" self.send_response(http.OK) self.send_header('Content-Length', str(len(data))) self.end_headers() self.wfile.write(data) return return StaticHTTPRequestHandler server_address = ('127.0.0.1', 0) handler_class = _get_http_handler_class() httpd = BaseHTTPServer.HTTPServer(server_address, handler_class) port = httpd.socket.getsockname()[1] thread = threading.Thread(target=httpd.serve_forever) thread.daemon = True thread.start() return thread, httpd, port
def test_has(lib): proxy = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock) proxy.expectations = [ (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (204, {}, "")), (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (404, {}, "")), (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (500, {}, "")), ] 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_has(cfg, b"NS", b"NS/ACCT/JFS//plop") lib.test_has_not(cfg, b"NS", b"NS/ACCT/JFS//plop") lib.test_has_fail(cfg, b"NS", b"NS/ACCT/JFS//plop") finally: proxy.shutdown() service.join() assert (0 == len(proxy.expectations))
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): """ Request handler implements a frugal HTTP handler. """ def do_POST(self): """ do_POST implements POST method on a frugal server. """ 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 %s', 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 __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) def do_POST(self): def dechunk(f): bio = io.BytesIO() while True: chunksize = bytearray() while not chunksize.endswith(b'\r\n'): chunksize += f.read(1) chunksize = chunksize.decode().split(':')[0] chunksize = int(chunksize, 16) if chunksize == 0: break chunk = f.read(chunksize) assert(f.read(2) == b'\r\n') bio.write(chunk) bio.seek(0) return bio def verify_hash(f, hashtype, hsh): try: chksum = hashlib.new(hashtype) except ValueError: return False chksum.update(f.read()) return chksum.hexdigest() == hsh if self.headers.get('Transfer-Encoding') == 'chunked': fp = dechunk(self.rfile) else: fp = self.rfile data = cgi.FieldStorage(fp=fp, headers=self.headers, environ={'REQUEST_METHOD': 'POST'}, # accept maximum of 10MB of data limit=10 * 1024 * 1024) try: if 'filename' in data: resp = b'Missing' self.send_response(200) self.send_header('Content-Type', 'text/plain') self.send_header('Content-Length', len(resp)) self.end_headers() self.wfile.write(resp) else: hashtype = [k for k in data.keys() if k.endswith('sum')][0] hsh = data[hashtype].value hashtype = hashtype.split('sum')[0] if verify_hash(data['file'].file, hashtype, hsh): self.send_response(204) self.end_headers() else: self.send_error(500) except (KeyError, IndexError): self.send_error(400) self.server = BaseHTTPServer.HTTPServer(('', port), RequestHandler) if cert: self.server.socket = ssl.wrap_socket(self.server.socket, certfile=cert, server_side=True)
self.send_header('Content-Type', 'text/plain') self.end_headers() self.wfile.write(_MY_VERSION) elif self.path == '/dump': # yaml module is not installed on Macs and Windows machines by default # so we import it lazily (/dump action is only used for debugging) import yaml self.send_response(200) self.send_header('Content-Type', 'text/plain') self.end_headers() now = time.time() self.wfile.write( yaml.dump({ 'pool': pool, 'in_use': dict((k, now - v) for k, v in in_use.items()) })) elif self.path == '/quitquitquit': self.send_response(200) self.end_headers() keep_running = False httpd = BaseHTTPServer.HTTPServer(('', args.port), Handler) while keep_running: httpd.handle_request() sys.stderr.flush() print('done')
def receive( address, include_body=True, include_client=False, include_method=False, include_path=False, include_version=False, ): """Receives data sent using HTTP requests. Provides a simple HTTP server that receives client requests, converting each request into Pipecat records. Parameters ---------- address: (host, port) tuple, required TCP address and IP port to be bound for listening to requests. Yields ------ record: dict Records will contain `client`, `version`, `method`, `path`, and `body` keys containing the content of each request. """ class Handler(BaseHTTPServer.BaseHTTPRequestHandler): server_version = "Pipecat/" + pipecat.__version__ record = {} def create_record(self): request_size = int(self.headers.get("Content-length", 0)) Handler.record.clear() if include_body: pipecat.record.add_field(Handler.record, "body", self.rfile.read(request_size)) if include_client: pipecat.record.add_field(Handler.record, "client", self.client_address) if include_method: pipecat.record.add_field(Handler.record, "method", self.command) if include_path: pipecat.record.add_field(Handler.record, "path", self.path) if include_version: pipecat.record.add_field(Handler.record, "version", self.request_version) self.send_response(200) self.end_headers() def do_GET(self): self.create_record() def do_PUT(self): self.create_record() def do_POST(self): self.create_record() def do_DELETE(self): self.create_record() def log_message(self, format, *args): log.debug(format, *args) server = BaseHTTPServer.HTTPServer(address, Handler) while True: server.handle_request() yield Handler.record
def test_get(lib): http, services, urls = [], [], [] http.append(BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock)) for _ in range(3): http.append(BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock)) for h in http: urls.append(http2url(h)) services.append(Service(h)) rawx_expectations = [ (("/0000000000000000000000000000000000000000000000000000000000000000", { "Range": "bytes=0-63" }, ""), (200, { "Content-Range": "bytes=0-63/64" }, "0" * 64)), (("/0000000000000000000000000000000000000000000000000000000000000001", { "Range": "bytes=0-63" }, ""), (200, { "Content-Range": "bytes=0-63/64" }, "0" * 64)), (("/0000000000000000000000000000000000000000000000000000000000000004", { "Range": "bytes=0-15" }, ""), (200, { "Content-Range": "bytes=0-15/16" }, "0" * 16)), (("/0000000000000000000000000000000000000000000000000000000000000005", { "Range": "bytes=0-15" }, ""), (200, { "Content-Range": "bytes=0-15/16" }, "0" * 16)), (("/0000000000000000000000000000000000000000000000000000000000000006", { "Range": "bytes=0-15" }, ""), (200, { "Content-Range": "bytes=0-15/16" }, "0" * 16)), (("/0000000000000000000000000000000000000000000000000000000000000007", { "Range": "bytes=0-15" }, ""), (200, { "Content-Range": "bytes=0-15/16" }, "0" * 16)), ] for h in http[1:]: h.expectations = rawx_expectations czero = "000000000000000000000000000000000000000000000000000000000000000" hash_zero = "00000000000000000000000000000000" http[0].expectations = [ (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (503, {}, "")), (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (200, { "x-oio-content-meta-chunk-method": "plain" }, "[]")), (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (200, { "x-oio-content-meta-chunk-method": "plain" }, json.dumps([ { "url": "http://%s/%s%d" % (urls[1], czero, 0), "pos": "0", "size": 64, "hash": hash_zero }, ]))), (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (200, { "x-oio-content-meta-chunk-method": "plain" }, json.dumps([ { "url": "http://%s/%s%d" % (urls[1], czero, 1), "pos": "0", "size": 64, "hash": hash_zero }, { "url": "http://%s/%s%d" % (urls[2], czero, 2), "pos": "0", "size": 64, "hash": hash_zero }, { "url": "http://%s/%s%d" % (urls[3], czero, 3), "pos": "0", "size": 64, "hash": hash_zero }, ]))), (("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (200, { "x-oio-content-meta-chunk-method": "plain" }, json.dumps([ { "url": "http://%s/%s%d" % (urls[1], czero, 4), "pos": "0.0", "size": 16, "hash": hash_zero }, { "url": "http://%s/%s%d" % (urls[2], czero, 5), "pos": "1.0", "size": 16, "hash": hash_zero }, { "url": "http://%s/%s%d" % (urls[3], czero, 6), "pos": "2.0", "size": 16, "hash": hash_zero }, { "url": "http://%s/%s%d" % (urls[3], czero, 7), "pos": "3.0", "size": 16, "hash": hash_zero }, ]))), ] for s in services: s.start() cfg = json.dumps({"NS": {"proxy": urls[0]}}).encode('utf-8') try: lib.test_init(cfg, b"NS") lib.test_get_fail(cfg, b"NS", b"NS/ACCT/JFS//plop") lib.test_get_fail(cfg, b"NS", b"NS/ACCT/JFS//plop") lib.test_get_success(cfg, b"NS", b"NS/ACCT/JFS//plop", 64) lib.test_get_success(cfg, b"NS", b"NS/ACCT/JFS//plop", 64) lib.test_get_success(cfg, b"NS", b"NS/ACCT/JFS//plop", 64) finally: for h in http: assert (0 == len(h.expectations)) h.shutdown() for s in services: s.join()
def test_list_ok(lib): names = ("plap", "plep", "plip", "plop", "plup", "plyp") proxy = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock) proxy.expectations = [ (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "{\"objects\":[],\"prefixes\":[]}")), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, json.dumps({ "objects": [{ "name": x, "hash": "0000", "size": 0, "version": 1 } for x in names], "prefixes": [], }))), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS&prefix=pla", {}, ""), (200, {}, json.dumps({ "objects": [{ "name": x, "hash": "0000", "size": 0, "version": 1 } for x in names if x.startswith("pla")], "prefixes": [], }))), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS&marker=plap", {}, ""), (200, { "X-Oio-list-truncated": False, "X-Oio-list-next": "plep", }, json.dumps({ "objects": [{ "name": "plep", "hash": "0000", "size": 0, "version": 1 }], "prefixes": [], }))), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, { "X-Oio-list-truncated": True, "X-Oio-list-next": "plep", }, json.dumps({ "objects": [ { "name": "plap", "hash": "0000", "size": 0, "version": 1 }, { "name": "plep", "hash": "0000", "size": 0, "version": 1 }, ], "prefixes": [], }))), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS&max=2", {}, ""), (200, { "X-Oio-list-truncated": True, "X-Oio-list-next": "plep", }, json.dumps({ "objects": [ { "name": "plap", "hash": "0000", "size": 0, "version": 1 }, { "name": "plep", "hash": "0000", "size": 0, "version": 1 }, ], "prefixes": [], }))), (("/v3.0/NS/container/list?acct=ACCT&ref=JFS&marker=plap&max=1", {}, ""), (200, { "X-Oio-list-truncated": False, "X-Oio-list-next": "plep", }, json.dumps({ "objects": [{ "name": "plep", "hash": "0000", "size": 0, "version": 1 }], "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_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 0, None, None, None, 0) lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 6, None, None, None, 0) lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 1, b"pla", None, None, 0) lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 1, None, b"plap", None, 0) lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 2, None, None, None, 0) lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 2, None, None, None, 2) lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 1, None, b"plap", None, 1) finally: proxy.shutdown() service.join() assert (0 == len(proxy.expectations))
def serve_sensor_page(self, pypkjs_port, port=None): controller = self self.port = port or self._choose_port() class SensorPageHandler(BaseHTTPServer.BaseHTTPRequestHandler): PERMITTED_PATHS = { 'static/js/backbone-min.js', 'static/js/backbone-min.map', 'static/js/propeller.min.js', 'static/js/sensors.js', 'static/js/underscore-min.js', 'static/js/underscore-min.map', 'static/js/websocket.js', 'static/compass-arrow.png', 'static/compass-rose.png', 'static/stylesheets/normalize.min.css', 'static/stylesheets/sensors.css' } def do_HEAD(self): self.send_response(200) self.end_headers() def do_GET(self): requested_file = self.path.rsplit('/', 1)[1] file_path = self.path.lstrip('/') if requested_file == '': self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write( SENSOR_PAGE_HTML.format( websocket_host="'{}'".format(controller._get_ip()), websocket_port="'{}'".format(pypkjs_port))) elif file_path in self.PERMITTED_PATHS: try: file_contents = open( os.path.join( os.path.dirname(os.path.realpath(__file__)), file_path)) self.send_response(200) self.end_headers() self.wfile.write(file_contents.read()) except IOError: self.send_response(404) self.end_headers() self.wfile.write("Not Found") else: self.send_response(403) self.end_headers() self.wfile.write("Forbidden") def log_request(self, code='-', size='-'): logger.debug("{} - - [{}] '{}' {} {}".format( self.client_address[0], self.log_date_time_string(), self.requestline, code, size)) server = BaseHTTPServer.HTTPServer(('', self.port), SensorPageHandler) try: url = "http://{}:{}".format(self._get_ip(), server.server_port) url_code = pyqrcode.create(url) print(url_code.terminal(quiet_zone=1)) print( "===================================================================================================" ) print( "Please scan the QR code or enter the following URL in your mobile browser:\n{}" .format(url)) print( "===================================================================================================" ) except socket.error: print( "Unable to determine local IP address. Please browse to port {} on this machine from your mobile " "browser.".format(server.server_port)) print("\nUse Ctrl-C to stop sending sensor data to the emulator.\n") try: server.serve_forever() except KeyboardInterrupt: print("Stopping...") server.server_close() time.sleep(2) # Wait for WS connection to die between phone/QEMU
def init_server(): srv = BaseHTTPServer.HTTPServer(("127.0.0.1", 7331), RequestHandler) event.set() srv.handle_request() srv.server_close()
def start(self): self.server = BaseHTTPServer.HTTPServer(("localhost", 0), FakeHTTPRequestHandler) self.server_thread = threading.Thread(target=self.serve) self.server_thread.daemon = True self.server_thread.start()
fp.close() if __name__ == '__main__': parser = OptionParser() parser.add_option('-p', '--port', action='store', dest='port', type='int', default=PORT, help='TCP port number') parser.add_option('-a', '--authorization', action='store_true', dest='authorization', default=False, help='Require authorization') parser.add_option('-u', '--username', action='store', dest='username', default='username', help='User name for HTTP Proxy authorization, unquoted') parser.add_option('-w', '--password', action='store', dest='password', default='password', help='Password for HTTP Proxy authorization, unquoted') parser.add_option('-r', '--realm', action='store', dest='realm', default='realm', help='Realm for HTTP Proxy authorization') parser.add_option('-t', '--translate', action='store', dest='translate', metavar='HOSTNAME', help='Translate requests for this host name to localhost') parser.add_option('-f', '--fork', action='store_true', dest='fork', default=False, help='Fork daemon process') parser.add_option('-v', '--verbose', action='store_true', dest='verbose', default=False, help='Output verbose informations') (options, arguments) = parser.parse_args() httpd = BaseHTTPServer.HTTPServer(('', int(options.port)), Proxy) if options.fork: pid = os.fork() if pid == 0: for fd in range(3): os.close(fd) fd2 = os.open(os.devnull, fd == 0 and os.O_RDONLY or os.O_WRONLY) if fd2 != fd: os.dup2(fd2, fd) os.close(fd2) httpd.serve_forever() else: print("proxy_pid=%d proxy_port=%d" % (pid, httpd.server_port)) else: try: print("proxy_pid=%d proxy_port=%d" % (os.getpid(), httpd.server_port))
def _create_http_server(listen_ip, listen_port, root_dir): return BaseHTTPServer.HTTPServer( (listen_ip, listen_port), _generate_request_handler(root_dir), )