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()
