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 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 base_http_server_start(address="0.0.0.0", port=80): handler = DefaultHTTPHandler address = (address, port) server = ThreadingHTTPServer(address, handler, bind_and_activate=False) server.server_bind() server.server_activate() server.serve_forever()
def serve(httpd: ThreadingHTTPServer): try: httpd.serve_forever() except KeyboardInterrupt: pass finally: httpd.shutdown()
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()
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 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()
class AppleWatchStreamer(BaseStreamer): server_port = 8118 def __init__(self, port=8118, path='./Files', parent=None): super(AppleWatchStreamer, self).__init__(path=path, parent=parent) self.server_port = port def run(self): self.add_log.emit( "Démarrage du serveur sur le port " + str(self.server_port), LogTypes.LOGTYPE_INFO) self.request_handler = AppleWatchRequestHandler self.request_handler.streamer = self self.server = ThreadingHTTPServer( (self.get_local_ip_address(), self.server_port), self.request_handler) self.server_running = True self.server.timeout = 5 # 5 seconds timeout should be ok since we are usually on local network self.server.serve_forever() self.server.server_close() # print('Server stopped') # # def get_streamer_infos(self): # return {"Adresse IP": self.get_local_ip_address(), # "Port": str(self.server_port), # "Données": self.server_save_path} @pyqtSlot() def stop_server(self): self.add_log.emit('Arrêt du serveur...', LogTypes.LOGTYPE_INFO) self.server_running = False self.server.shutdown()
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_server(port=8000, launcher=None): from confply import pushd global launcher_path global aliases global configs # this is required to work with safari for some reason. ThreadingHTTPServer.address_family, addr = _get_best_family(None, port) if launcher is not None: launcher_path = os.path.abspath(launcher) with pushd(os.path.dirname(launcher_path)): with open(os.path.basename(launcher_path)) as launcher_file: config = {"aliases": {}, "__file__": launcher_path} exec(launcher_file.read(), config, config) aliases = config["aliases"] for k, v in aliases.items(): for elem in shlex.split(v): if elem.endswith(".py"): configs.add(elem) webServer = ThreadingHTTPServer(addr, ConfplyServer) print("Server started http://%s:%s" % (addr)) try: webServer.serve_forever() except KeyboardInterrupt: pass webServer.server_close() print("Server stopped.")
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()
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 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 directorServer(self, username, passphrase, addr=None, pub_addr=False, lport=16666, sys_version='', server_version=''): if (self.__directorInit == True): raise serverDirectorIsInit('El servidor ya está iniciado') self.__directorInit = True BaseHTTPRequestHandler.sys_version = str(sys_version) BaseHTTPRequestHandler.server_version = str(server_version) _address = self.__get_my_addr(addr, pub_addr) HTTPServerHandler._username = username HTTPServerHandler._passphrase = passphrase HTTPServerHandler.db_path = self.db_path HTTPServerHandler.db_pass = self.db_pass HTTPServerHandler._object = self httpd = ThreadingHTTPServer(('', lport), HTTPServerHandler) _hash = self.showServerHash() if (_hash == False): _hash = generate_uniqkey.generate() wrap_secure.add('hash', _hash, self.db_pass, self.db_path) self.directorResponse = self.send(('addPeer', { 'url': 'http://%s:%d' % (_address, lport), 'username': username, 'passphrase': passphrase, 'db_passwd': self.db_pass, 'hash': _hash })) try: httpd.serve_forever() finally: httpd.shutdown() self.__directorInit = False
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 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 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()
def web_server(): print("Listing on 172.20.10.7:8080 \n") httpd = ThreadingHTTPServer(("", 8080), PostGetRequestHandler) try: httpd.serve_forever() except KeyboardInterrupt: print("Server is terminated") httpd.server_close()
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 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 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()
def go(): webServer = ThreadingHTTPServer((hostName, serverPort), MyServer) print("Server started http://%s:%s" % (hostName, serverPort)) try: webServer.serve_forever() except KeyboardInterrupt: pass webServer.server_close()
def run(): print('starting server...') server_address = ('0.0.0.0', 8081) server = ThreadingHTTPServer(server_address, MysqlHealthCheck) print('running server...') try: server.serve_forever() except KeyboardInterrupt: pass server.server_close()
def serve(self): httpd = ThreadingHTTPServer((self.host, self.port), RequestsHandlerWrapper(self.domain_cache)) try: httpd.serve_forever() except KeyboardInterrupt: pass finally: httpd.shutdown()
def serve_on_thread(address, port, secure): httpd = ThreadingHTTPServer((address, port), MyHTTPRequestHandler) if secure: httpd.socket = ssl.wrap_socket( httpd.socket, certfile=cert_file, keyfile=cert_key_file, server_side=True, ) httpd.serve_forever()
def main(*args) -> int: """ Entry point. """ # Initialise GPIO pins assert not GarageDoorRequestHandler._control('init').returncode # Start HTTP server srv = ThreadingHTTPServer(ADDRESS, GarageDoorRequestHandler) srv.serve_forever() return 0
class LivenessHandler(): """Class managing Web server for liveness checks.""" 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 listen(self): """Listen for incoming HTTP connections. Spawns a new thread for server.""" self.thread = Thread(target=self.start_server) self.thread.start() def start_server(self): """Start the web server. This is supposed to be used within a thread (it's blocking).""" self.logger.info("Web server listening on {}".format(self.port)) self.server.serve_forever(2) self.logger.info("Web server stopped") def stop(self): """Stop the HTTP server and wait for it's thread to join.""" if self.thread is not None: self.server.shutdown() self.thread.join()