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