def main(argv):
"""Entry point for prometheus_speedtest.py."""
del argv # unused
if FLAGS.version:
print('prometheus_speedtest v%s' % version.VERSION)
return
registry = core.CollectorRegistry(auto_describe=False)
if FLAGS.servers and set(FLAGS.excludes).issuperset(FLAGS.servers):
logging.fatal(
'--excludes is a superset of --includes, no viable test server is '
'possible. Ensure --excludes does not contain all --servers.')
# TEST_ASDF_ASDF_ASDF_ASDF_ASDF_ASDF_ASDF_ASDF_ASDF_ASDFfoobar
registry.register(
RemoteSpeedtestCollector(servers=FLAGS.servers,
excludes=FLAGS.excludes,
remotes=FLAGS.remotes))
metrics_handler = SpeedtestMetricsHandler.factory(registry)
http = server.ThreadingHTTPServer((FLAGS.address, FLAGS.port),
metrics_handler)
logging.info('Starting HTTP server listening on %s:%s', FLAGS.address,
FLAGS.port)
http.serve_forever()
def StartWebserver():
WebServer = server.ThreadingHTTPServer(("", 8080), DogCamWebServer)
HttpHandle = threading.Thread(target=WebServer.serve_forever,
daemon=True,
name="WebServer")
HttpHandle.start()
print("Web server started")
def main(entrypoint, port):
config_parser = configparser.ConfigParser()
config_parser['DEFAULT'] = dict(
http_port=str(port),
function_path='/data/function'
# http_port=10010,
# function_path='/home/vancior/Documents/senior/functions/test2'
)
config_parser['DEFAULT']['entrypoint'] = entrypoint
global CONFIG
CONFIG = config_parser['DEFAULT']
runtime_server = server.ThreadingHTTPServer(
('', CONFIG.getint('http_port')), RuntimeHandler)
global FUNCTION_CONTEXT
FUNCTION_CONTEXT = FunctionContext()
# TODO: notify ready(send message to agent and agent set runtime_id with 'running' in redis)
"""
data: {runtime_id: "123", ip: "172.17.0.2"}
"""
msg = {
'runtime_id': FUNCTION_CONTEXT.runtime_meta['runtime_id'],
'ip': socket.gethostbyname(socket.gethostname())
}
# TODO: 可能的异常点，host中的ready daemon挂了
connection = client.HTTPConnection('172.17.42.1', 10008, timeout=10)
connection.request('POST',
'/',
bytes(json.dumps(msg, ensure_ascii=True), 'ascii'),
headers={'Content-Type': 'application/json'})
response = connection.getresponse()
result = json.loads(response.read())
if result['status'] == 'success':
runtime_server.serve_forever()
else:
exit(2)
def __init__(self, port, certfile, keyfile):
"""
Parameters
----------
port : int
Port to run the local server on.
certfile : str
keyfile : str
"""
self.httpd = None
if not certfile or not keyfile:
certfile, keyfile = create_localhost_cert()
if not certfile or not keyfile:
Logger.error(
'[LocalServerHTTPS.__init__] No certfile and/or no keyfile. Cannot start HTTPS server.'
)
return
if hasattr(server, 'ThreadingHTTPServer'):
self.httpd = server.ThreadingHTTPServer(('', port),
APIRequestHandler)
else:
Logger.warn('http.server.ThreadingHTTPServer not available. '
'Using fallback to http.server.HTTPServer instead.')
self.httpd = server.HTTPServer(('', port), APIRequestHandler)
self.httpd.socket = ssl.wrap_socket(self.httpd.socket,
certfile=certfile,
keyfile=keyfile,
server_side=True)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--port', type=int, default=8000)
args = parser.parse_args()
addr = '', args.port
with server.ThreadingHTTPServer(addr, Handler) as s:
logging.info(f'Serving at http://localhost:{args.port}')
s.serve_forever()
def __init__(self, site, port):
import http.server as _http
import functools as _functools
super().__init__(name="server", daemon=True)
self.site = site
self.port = port
handler = _functools.partial(_http.SimpleHTTPRequestHandler,
directory=self.site.output_dir)
self.server = _http.ThreadingHTTPServer(("localhost", self.port),
handler)
def run_server(config):
server_config = config.get_server_config()
db_config = config.get_database_config()
with Database(**db_config) as database:
s = server.ThreadingHTTPServer(
(server_config['host'], server_config['port']),
partial(Handler, database, dict()))
try:
logger.info("Starting server on port {}...".format(
server_config['port']))
s.serve_forever()
except KeyboardInterrupt:
s.shutdown()
logger.info("Server shut down")
def run():
port = EndpointHandler.port
print(
'INFO: (Secured: {})Mock Endpoint Server listening on localhost:{}...'
.format(EndpointHandler.secured, port))
socketserver.TCPServer.allow_reuse_address = True
httpd = server.ThreadingHTTPServer(('', port), EndpointHandler)
# cert_path = path.dirname(__file__) + 'youryourpemfile.pem'
cert_path = 'certificates/knnect.cert.pem'
print("DEBUG: cert_path = " + cert_path)
if EndpointHandler.secured:
httpd.socket = ssl.wrap_socket(httpd.socket,
server_side=True,
certfile=cert_path)
httpd.serve_forever()
def __init__(self, port):
"""
Parameters
----------
port : int
Port to run the local server on.
"""
if hasattr(server, 'ThreadingHTTPServer'):
self.httpd = server.ThreadingHTTPServer(('', port),
APIRequestHandler)
else:
Logger.warn('http.server.ThreadingHTTPServer not available. '
'Using fallback to http.server.HTTPServer instead.')
self.httpd = server.HTTPServer(('', port), APIRequestHandler)
def server():
server_address = ('0.0.0.0', 8000)
if sys.version_info[1] < 7:
class ThreadingHTTPServer(socketserver.ThreadingMixIn,
http.HTTPServer):
pass
httpd = ThreadingHTTPServer(server_address,
http.SimpleHTTPRequestHandler)
else:
httpd = http.ThreadingHTTPServer(server_address,
http.SimpleHTTPRequestHandler)
log("Server started")
httpd.serve_forever()
def main(argv):
"""Entry point for prometheus_speedtest.py."""
del argv # unused
if FLAGS.version:
print('prometheus_speedtest v%s' % version.VERSION)
return
registry = core.CollectorRegistry(auto_describe=False)
registry.register(SpeedtestCollector(servers=FLAGS.servers))
metrics_handler = SpeedtestMetricsHandler.factory(registry)
http = server.ThreadingHTTPServer((FLAGS.address, FLAGS.port),
metrics_handler)
logging.info('Starting HTTP server listening on %s:%s', FLAGS.address,
FLAGS.port)
http.serve_forever()
def __init__(self, services):
self.services_objs = list()
self.threads = list()
for srv in services:
port = srv[0]
proto = srv[1]
service = server.ThreadingHTTPServer(
('', port),
DummyHTTPRequestHandler,
)
if proto == 'https':
service.socket = ssl.wrap_socket(
service.socket,
certfile='tests/files/server.pem',
server_side=True)
self.services_objs.append(service)
for srv in self.services_objs:
thread = threading.Thread(target=srv.serve_forever)
thread.daemon = True
self.threads.append(thread)
import os
import http.server as server
port = 8081
path = 'C:/OSM'
os.chdir(path=path)
with server.ThreadingHTTPServer(('', port),
server.SimpleHTTPRequestHandler) as httpd:
print('Start tileserver on port %d path [%s]' % (port, path))
httpd.serve_forever()
request = HTTP_util.Request(self)
response = HTTP_util.Response(self)
# Calls the handler function
globfile.requests_GET[path](request, response)
# Unwraps the response, prepares it for sending back.
self.send_response(response.status_code)
for h in response.headers:
self.send_header(h, response.headers[h])
self.end_headers()
# Send the response
self.wfile.write(response.message)
else:
# Wrong request
self.send_error(404, "No cats here")
if __name__ == "__main__":
import sys
import importlib
# Importing modules given in arguments
for module_name in sys.argv[1:]:
importlib.import_module(module_name)
# Feel free to bind it to other addresses/ports
httpd = server.ThreadingHTTPServer(('', 8080), Handler)
httpd.serve_forever()