def start(self): if self.server: self.stop() config = get_config() if config.setting["browser_integration_localhost_only"]: host_address = '127.0.0.1' else: host_address = '0.0.0.0' # nosec for port in range(config.setting["browser_integration_port"], 65535): try: self.server = ThreadingHTTPServer((host_address, port), RequestHandler) except OSError: continue log.info("Starting the browser integration (%s:%d)", host_address, port) self.listen_port_changed.emit(port) threading.Thread(target=self.server.serve_forever).start() break else: log.error( "Failed finding an available port for the browser integration." ) self.stop()
def serve(httpd: ThreadingHTTPServer): try: httpd.serve_forever() except KeyboardInterrupt: pass finally: httpd.shutdown()
def main(): global key, update_servers server_config, update_servers = get_config('config.json') print('[{}] Starting MultiDDNS update server at port: {}.'.format( time.asctime(), server_config['port'])) # Initial IP update. update_ips(update_servers, get_ip()) key = server_config['credentials'] # Setup server. httpd = ThreadingHTTPServer(('', server_config['port']), DDNSHandler) # HTTPS if USE_TLS: context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) context.load_cert_chain(certfile=server_config['cert'], keyfile=server_config['key'], password=server_config['cert_password']) httpd.socket = context.wrap_socket(httpd.socket, server_side=True) # Run server. httpd.serve_forever()
def __init__(self, port: int, checks: List[Callable]): super().__init__() class LivenessChecker(BaseHTTPRequestHandler): """Request handler class.""" def handle_check(self): if self.path != HEALTH_PATH: self.send_response(404) self.end_headers() return success = True try: for check in checks: if not check(): success = False except Exception as e: success = False liveness_logger.error("Liveness check raised exception", e) self.send_response(200 if success else 503) self.end_headers() do_GET = handle_check do_POST = handle_check do_PUT = handle_check do_DELETE = handle_check self.checks = checks self.logger = liveness_logger self.port = port server_address = ("", port) self.server = ThreadingHTTPServer(server_address, LivenessChecker) self.thread = None # type: Thread
def StartServer(): sever = ThreadingHTTPServer(("", int(os.environ.get('PORT', 40005))), PostHandler) #sever = HTTPServer(("",9999),PostHandler) #sever.socket = ssl.wrap_socket (sever.socket, certfile='server.pem', server_side=True) print('ready') sever.serve_forever()
def start(cls): """ This method starts the server. """ config = Config.shared() colon_index = config.bind_address.rindex(":") port_index = colon_index + 1 address = config.bind_address[:colon_index] port = config.bind_address[port_index:] log.info(f"Listening on {address}:{port}") if address.startswith("[") and address.endswith("]"): server = ThreadingHTTPServerV6((address[1:-1], int(port)), cls) else: server = ThreadingHTTPServer((address, int(port)), cls) if config.enable_tls: context = Server.load_ssl_context() server.socket = context.wrap_socket(server.socket, server_side=True) observer = Observer() event_handler = CertificateEventHandler() for path in set([ Path(config.certificate_file).parent.as_posix(), Path(config.key_file).parent.as_posix(), ]): observer.schedule(event_handler, path) observer.start() server.serve_forever()
class MJPEGServer(Thread): """ TEST """ # Enable logging logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO ) logger = logging.getLogger("HTTPServer") ch = logging.FileHandler('./test.log') ch.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) def __init__(self, port=80): Thread.__init__(self) self.port = port self.server_address = ('', self.port) self.httpd = ThreadingHTTPServer(self.server_address, StreamingHandler) def run(self): self.httpd.serve_forever()
class MockHTTPServer: def __init__(self, host, port): self.host = host self.port = port self.stop_server = False self.handler = HTTPRequestHandler self.server = ThreadingHTTPServer((self.host, self.port), self.handler) self.server.timeout = 0 #init with default data self.server.data = settings.MOCK_DATA["data"] self.server.tokens = settings.MOCK_DATA["tokens"] def start(self): self.server.allow_reuse_address = True self.th = threading.Thread(target=self.server.serve_forever)#, daemon=True) print("server starting") self.th.start() return self.server def stop(self): self.server.server_close() self.server.shutdown() self.stop_server = True def set_data(self, data): self.handler.data = json.dumps(data).encode()
def __init__(self, port, api): QObject.__init__(self) self.api = api HandlerClass = self.requestHandlerFactory(self.api.getState, self.actionCallback) ThreadingHTTPServer.__init__(self, ('localhost', port), HandlerClass) self.action.connect(self.api.action)
class PrometheusServer(StoppableThread): """Wraps a ThreadingHTTPServer to serve Prometheus metrics""" def __init__(self, host, port): self.logger = logging.getLogger(__name__) self.display_name = "Prometheus Server" self._host = host self._port = port # Basically prometheus_client.exposition.start_http_server metrics_handler = MetricsHandler.factory(REGISTRY) self.httpd = ThreadingHTTPServer((host, port), metrics_handler) super(PrometheusServer, self).__init__(logger=self.logger, name="PrometheusServer") def run(self): self.logger.debug("Initializing metric counts") initialize_counts() self.logger.info( f"Starting {self.display_name} on {self._host}:{self._port}") self.httpd.serve_forever() self.logger.info(f"{self.display_name} is stopped") def stop(self): self.httpd.shutdown()
class WebGUITask(Task): def setup(self): self.data_queues = [] task = self class AugmentedAppClass(AppClass): def __init__(self, *args, **kwargs): self.task = task super().__init__(*args, **kwargs) self.app_class = AugmentedAppClass self.thread = threading.Thread(target=self._run_server) self.thread.start() def run(self, data): for q in self.data_queues: q.put(data) def _run_server(self): self.httpd = ThreadingHTTPServer(('', 8000), self.app_class) self.httpd.serve_forever() def teardown(self): self.httpd.shutdown()
def StartServer(): global secret os.chdir(server_base_path) os.chmod('unrar', stat.S_IXUSR) os.makedirs('game', exist_ok=True) os.makedirs('archive', exist_ok=True) sever = ThreadingHTTPServer(("", int(os.environ.get('PORT', 9999))), PostHandler) print('ready') print() passphrase = os.environ.get('PASSPHRASE', str(int(time.time()))) passphrase = passphrase[:10] passphrase = ' ' * (len(passphrase) - 10) + passphrase secret = base64.b32encode(passphrase.encode('ascii')).decode('ascii') uid = 'me' mark = 'serverpg' qr = pyqrcode.create('otpauth://totp/' + uid + '?secret=' + secret + '&issuer=' + mark) secret_path = hashlib.blake2b( bytes(secret, 'ascii') + bytes(str(time.time()), 'ascii'), digest_size=16).hexdigest() + '.svg' secret_url = '/' + secret_path print(secret_url) qr.svg(secret_path, scale=8) #print(parse(qr.text())) sever.serve_forever()
def __init__(self, **kwargs): logging.basicConfig( format="[%(asctime)s] %(name)s [%(levelname)s]: %(message)s", level=logging.INFO) self.bind_host = kwargs.get("host", "127.0.0.1") self.bind_port = kwargs.get("port", "6000") self.router = kwargs.get("router", Router) self.routes = kwargs.get("routes", []) self.conffile = kwargs.get("config", None) self._config = {} if ':' in self.bind_host: self.bind_host, self.bind_port = self.bind_host.split(':') if self.conffile: self._config = yaml.load(open(self.conffile), Loader=yaml.FullLoader) if self._config.get("routes", {}): for route in self._config.get("routes", {}): self.router.routes.append(route) self.bind_port = int(self.bind_port) self.server = ThreadingHTTPServer((self.bind_host, self.bind_port), self.router) for route in self.routes: self.router.routes.append(route)
def __init__(self, width, height): ''' Creating the GUI :return: :rtype: ''' threading.Thread.__init__(self) self.connected = False self.led_array_listener = [] self.connection_state_listener = [] self.width = width self.height = height # Register listener in the LocalCGIHTTPRequestHandler class LocalCGIHTTPRequestHandler.local_cgi_script[ "connection_status"] = self.add_connection_state_listener LocalCGIHTTPRequestHandler.local_cgi_script[ "led_array"] = self.add_led_array_listener # Create server instance self.https = ThreadingHTTPServer(('', 8000), LocalCGIHTTPRequestHandler) self.led_array = [] self.html_led_array = 'EMPTY'
def _servedb(self): # try to open a port in range 8800 - 8899 for i in range(99): portno = 8800+i self.debugmsg(0, "trying port:", portno) server_address = ('', portno) reason = "" if self.dbopen: try: self.httpserver = ThreadingHTTPServer(server_address, MyNoSQLServer) # self.httpserver.setdb(self) self.port = portno except PermissionError: reason = "PermissionError" except Exception as e: reason = "{}".format(e) else: reason = "DB Closed" if self.port>0: break else: self.debugmsg(0, "open port failed:", reason) if self.port>0: self.doc_id = self._registerself() self.debugmsg(0, "Server started on port:", self.port) self.httpserver.serve_forever() else: self.debugmsg(0, "Unable to start server:", reason)
def main( self, folder, field_name, port=0, open_browser=True, serve_forever=True, **kwargs, ): if os.path.isfile(field_name) and field_name.endswith(".jira"): field_name = field_name.split(".")[0] with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s: s.bind(("", port)) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) port = s.getsockname()[1] path = field_name.replace(".", "/") IssueRequestHandler.folder = folder IssueRequestHandler.get_converted_markup = get_converted_markup server = ThreadingHTTPServer(("", port), IssueRequestHandler) server.timeout = 0.1 print(f"Serving from http://127.0.0.1:{port}") print("Press <Ctrl+C> to Exit") if open_browser: webbrowser.open(f"http://127.0.0.1:{port}/{path}") try: while self.continue_serving(serve_forever): server.handle_request() except KeyboardInterrupt: pass
def __init__(self, port, getCallback, responseCallback=None): QObject.__init__(self) HandlerClass = self.requestHandlerFactory(getCallback, self.responseCallback) ThreadingHTTPServer.__init__(self, ('localhost', port), HandlerClass) if responseCallback is not None: self.action.connect(responseCallback)
def run_groupme_listener(self, channel, conf): server_address = ('', conf['BOT_PORT']) HandlerClass = make_groupme_handler(channel, conf, self.send_from_groupme) httpd = ThreadingHTTPServer(server_address, HandlerClass) _LOGGER.debug('listening http for groupme bot: %s', channel) httpd.socket = context.wrap_socket(httpd.socket, server_side=True) httpd.serve_forever()
def exporter(args): from http.server import ThreadingHTTPServer from prometheus_client.exposition import MetricsHandler REGISTRY.register(Collector(args)) httpd = ThreadingHTTPServer((args.listen_address, args.port), MetricsHandler) httpd.serve_forever()
def __init__(self, base_path, server_address, msg_handler=None, RequestHandlerClass=HTTPHandler): self.base_path = base_path HTTPHandler.MSG_HANDLER = msg_handler BaseHTTPServer.__init__(self, server_address, RequestHandlerClass)
def StartServer(): """ return:启动服务器 """ sever = ThreadingHTTPServer(("", 9001), PostHandler) #如果要改成局域网互传,只需要填入0.0.0.0 print('Started httpserver on port ') sever.serve_forever()
class App: def __init__(self, **kwargs): logging.basicConfig( format="[%(asctime)s] %(name)s [%(levelname)s]: %(message)s", level=logging.INFO) self.bind_host = kwargs.get("host", "127.0.0.1") self.bind_port = kwargs.get("port", "6000") self.router = kwargs.get("router", Router) self.routes = kwargs.get("routes", []) self.conffile = kwargs.get("config", None) self._config = {} if ':' in self.bind_host: self.bind_host, self.bind_port = self.bind_host.split(':') if self.conffile: self._config = yaml.load(open(self.conffile), Loader=yaml.FullLoader) if self._config.get("routes", {}): for route in self._config.get("routes", {}): self.router.routes.append(route) self.bind_port = int(self.bind_port) self.server = ThreadingHTTPServer((self.bind_host, self.bind_port), self.router) for route in self.routes: self.router.routes.append(route) @property def config(self): return self._config def run(self): logging.info( f"Starting server on {self.bind_host}:{self.bind_port}, use <Ctrl-C> to stop" ) try: self.server.serve_forever() except KeyboardInterrupt: pass logging.info(f"Stopping server") self.server.server_close() def cli(self): self.parser = argparse.ArgumentParser( description="fastapp application server") self.parser.add_argument( "-b", "--bind", help="Host address to bind to; default 127.0.0.1", default="127.0.0.1") self.parser.add_argument("-p", "--port", help="Port to bind to; default 6000", default="6000") self.args = parser.parse_args()
def main(): print('Prepare temporary dir %s for code runner...' % CONFIG.tempdir) if not os.path.isdir(CONFIG.tempdir): os.makedirs(CONFIG.tempdir) httpd = ThreadingHTTPServer((CONFIG.ip, int(CONFIG.port)), RunnerHTTPRequestHandler) print('Ready for code runner on %s:%s...' % (CONFIG.ip, CONFIG.port)) print('Press Ctrl + C to exit...') httpd.serve_forever()
def run(self): global server global server_running server = ThreadingHTTPServer(("", 8020), HTTPHandler) print("starting server") server_running = True server.serve_forever() server_running = False print("stopping server")
def main(): try: raw_port = get_option('server_port', "8888") server = ThreadingHTTPServer(('', int(raw_port)), StorageHandler) server.serve_forever() except KeyboardInterrupt: print("shutting down on keyboard interrupt", file=sys.stderr) server.socket.close() the_pool.closeall()
def start(self, address="localhost", port=5000, debug=False): """Start hops builtin http server on given address:port""" # setup logging hlogger.setLevel(logging.DEBUG if debug else logging.INFO) # start ther server _HopsHTTPHandler.hops = self httpd = ThreadingHTTPServer((address, port), _HopsHTTPHandler) hlogger.info("Starting hops python server on %s:%s", address, port) httpd.serve_forever()
def runHTTPServer(port): try: RecorderHTTPHandler.AppConnector = RecorderPlugin() server = ThreadingHTTPServer(('', int(port)),RecorderHTTPHandler) print('started httpserver...') server.serve_forever() except KeyboardInterrupt: print('^C received, shutting down server') server.socket.close()
class BrowserIntegration(QtCore.QObject): listen_port_changed = QtCore.pyqtSignal(int) def __init__(self, parent=None): super().__init__(parent) self.server = None @property def host_address(self): if not self.server: return '' return self.server.server_address[0] @property def port(self): if not self.server: return 0 return self.server.server_address[1] def start(self): if self.server: self.stop() config = get_config() if config.setting["browser_integration_localhost_only"]: host_address = '127.0.0.1' else: host_address = '0.0.0.0' # nosec for port in range(config.setting["browser_integration_port"], 65535): try: self.server = ThreadingHTTPServer((host_address, port), RequestHandler) except OSError: continue log.info("Starting the browser integration (%s:%d)", host_address, port) self.listen_port_changed.emit(port) threading.Thread(target=self.server.serve_forever).start() break else: log.error( "Failed finding an available port for the browser integration." ) self.stop() def stop(self): if self.server: log.info("Stopping the browser integration") self.server.shutdown() self.server.server_close() self.server = None self.listen_port_changed.emit(self.port) else: log.debug("Browser integration inactive, no need to stop")
def main(bind, port): foo = {} global _g_foo _g_foo = foo address = (bind, port) print(f'Listening on {address}') server = ThreadingHTTPServer(address, RequestHandler) server.serve_forever()
def run(): logging.info('CLUSTER_LOCATION set to '+CLUSTER_LOCATION) httpd = ThreadingHTTPServer(('', 8080), Webhook) if os.path.isfile(CERT_PATH) and os.path.isfile(KEY_PATH): logging.info('using tls cert at '+CERT_PATH) logging.info('using tls key at '+KEY_PATH) httpd.socket = ssl.wrap_socket( httpd.socket, certfile=CERT_PATH, keyfile=KEY_PATH, server_side=True) logging.info('starting on 8080...') httpd.serve_forever()