def main():
global values
parser = argparse.ArgumentParser(description='MEW HTTP Server')
parser.add_argument('-i',
'--input',
type=argparse.FileType('r'),
help='Variable names',
required=True)
parser.add_argument('-a',
'--answer',
type=argparse.FileType('r'),
help='Variable values',
required=True)
params = parser.parse_args()
variables_list = get_file_tokens(params.input)
if len(variables_list) != 4:
print('Expected 4 variable names found %d names' % len(variables_list))
sys.exit(1)
params.input.close()
values_list = get_file_tokens(params.answer)
if len(values_list) != 4:
print('Expected 4 values found %d values' % len(values_list))
params.answer.close()
values = {}
for i in range(4):
values[variables_list[i]] = values_list[i]
server = hs.HTTPServer(('127.0.0.1', 7777), MyHTTPHandler)
server.serve_forever()
def run():
"""
runs the http server
"""
ip_address = 'localhost'
port = 3280
handler = generate_handler()
srv = server.HTTPServer((ip_address, port), handler)
sys.stdout.flush()
def start_browser():
"""
opens the browser
"""
return webbrowser.open('http://{}:{}'.format(ip_address, port))
threading.Thread(target=start_browser).start()
try:
srv.serve_forever()
except (KeyboardInterrupt, SystemExit):
print('stopped server')
srv.server_close()
def setUp(self):
self['request_handler'] = self.request_handler
self['httpd'] = http_server.HTTPServer(
(self.host, self.port), self.request_handler)
self['httpd_thread'] = threading.Thread(
target=self['httpd'].serve_forever)
self['httpd_thread'].daemon = True
self['httpd_thread'].start()
# Wait as it sometimes takes a while to get the server started.
# XXX this is a little kludgy
time.sleep(0.001)
port = self['httpd'].server_port
self['http_host'] = self.host
self['http_port'] = port
self['http_address'] = f'{self.host}:{port}'
# XXX copy&paste from gocept.httpserverlayer.wsgi
orig_flush = self['_orig_handler_flush'] = (
wsgiref.handlers.SimpleHandler._flush)
def silent_flush(self):
try:
orig_flush(self)
except OSError as e:
if e.args[0] != 32:
raise
wsgiref.handlers.SimpleHandler._flush = silent_flush
def concrete_server_factory(
request_handler_class: typing.Type[httpserver.BaseHTTPRequestHandler],
) -> typing.Tuple[str, int]:
"""
Create web server with given request handler.
The web server is also started automatically in a thread. The thread
automatically stops when the parent stops.
Parameters
----------
request_handler_class: typing.Type[httpserver.BaseHTTPRequestHandler]
Request handler which handles the requests send to the web server.
Returns
-------
typing.Tuple[str, int]
typing.Tuple containing the servers domain ("localhost") and the port it
is listening on.
"""
mock_server_domain = "localhost"
mock_server_port = free_port
mock_server = httpserver.HTTPServer(
(mock_server_domain, mock_server_port),
request_handler_class,
)
mock_server_thread = threading.Thread(target=mock_server.serve_forever)
mock_server_thread.setDaemon(True)
mock_server_thread.start()
return mock_server_domain, mock_server_port
def run():
if len(sys.argv) != 1:
print(__doc__)
sys.exit(1)
server_address = ('', 9885)
httpd = server.HTTPServer(server_address, Handler)
httpd.serve_forever()
def main():
# Terminate process when Kubernetes sends SIGTERM.
signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
server_address = ('', 8000)
httpd = server.HTTPServer(server_address, MyRequestHandler)
httpd.serve_forever()
def __init__(self,
host="0.0.0.0",
port=80,
log_function=None,
staticdir="static",
staticindex="index.html",
include_fp=['{staticdir}/*'],
exclude_fp=[],
error_404_page_func=None):
self.host = host
self.port = port
self.log_function = log_function
self.staticdir = staticdir
self.staticindex = staticindex
self.include_fp = include_fp
self.exclude_fp = exclude_fp
self.error_404_page_func = error_404_page_func
self.request_handler_class = self.WebRequestHandler
self.resource_dict = {}
self.set_default_handler("GET", self.default_GET_handler)
setattr(self.request_handler_class, 'log_string',
classmethod(self.log_string))
setattr(self.request_handler_class, 'get_404_page',
classmethod(self.get_404_page))
self.httpd = http_server.HTTPServer((self.host, self.port),
self.request_handler_class)
def load_in_default_browser(html):
""" Opens the html content in the default web browser by temporarily launching a http get
server and providing the CCOBRA html output.
Parameters
----------
html : str
Html content to serve.
"""
class RequestHandler(httpserver.BaseHTTPRequestHandler):
""" CCOBRA html request handler.
"""
def do_GET(self):
""" Implement the get request handler responding with the html content.
"""
self.protocol_version = 'HTTP/1.0'
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.send_header('Content-length', len(html))
self.end_headers()
buffer_size = 1024 ** 2
for idx in range(0, len(html), buffer_size):
self.wfile.write(html[idx:idx+buffer_size])
server = httpserver.HTTPServer(('127.0.0.1', 0), RequestHandler)
webbrowser.open('http://127.0.0.1:{}'.format(server.server_port))
server.handle_request()
def start(path: str, ip: str, port: int):
'''Starts the server
Args:
path (str): The path to the files being served
ip (str): The ip address or localhost
port (int): The port number
'''
log.info("Server starting up\n")
global homeFiles
homeFiles = path
print(ip + ":" + str(port))
log.info("Server on: " + ip + ":" + str(port))
t = http.HTTPServer((ip, port), handleRequest)
try:
t.serve_forever()
except KeyboardInterrupt:
pass
finally:
print("Server shutting down\n")
log.info("Server shutting down\n")
logging.shutdown()
def oauth_desktop_login(self, ruri=None):
"""
Log into FamilySearch using OAuth2 Authentication.
This is primarily a convenience function for desktop apps.
Not normally intended for production apps, but should
work while waiting for approval for password login.
Default Redirect URI is "http://localhost:63342/fslogin",
but you can set your own as a paramater.
"""
if ruri is None:
ruri = "http://localhost:63342/fslogin"
self.logged_in = False
self.cookies.clear()
url = self.root_collection['response']['collections'][0]['links']\
['http://oauth.net/core/2.0/endpoint/authorize']['href']
url = self._add_query_params(
url, {
'response_type': 'code',
'client_id': self.dev_key,
'redirect_uri': ruri,
})
webbrowser.open(url)
server.HTTPServer(('', 63342), Getter).handle_request()
# Now that we have the authentication token, grab the access token.
self.oauth_code_login(qs)
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 __init__(self):
super(WebappsQmlContentHttpServer, self).__init__()
self.server = http.HTTPServer(("", 0), RequestHandler)
self.server.allow_reuse_address = True
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.start()
logging.info("now serving on port {}".format(self.server.server_port))
def build_httpd(secure=None):
"""
build an http daemon
Builds an HTTP server instance on a random local port which can be used
to verify HTTP/HTTPS request handling for various releng-tool features.
By default, an HTTP is spawned with `secure` set to `False`. When building
a "secure" HTTP server, key/cert. files are used from the assets folder.
Args:
secure (optional): whether or not a secure http server should be made
Returns:
the http server
"""
LOCAL_RANDOM_PORT = ('127.0.0.1', 0)
httpd = http_server.HTTPServer(LOCAL_RANDOM_PORT, MockServerRequestHandler)
httpd.req = {}
httpd.rsp = []
if secure:
keyfile, certfile = fetch_cert_files()
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(certfile, keyfile=keyfile)
httpd.socket = context.wrap_socket(httpd.socket, server_side=True)
return httpd
def run(self):
self.exited = False
self.httpd = server.HTTPServer(self.server_address,
self.server_handler_class)
while self.should_continue:
self.httpd.handle_request()
self.exited = True
def start_http_server(image_id, image_data):
def _get_http_handler_class(fixture):
class StaticHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-Length', str(len(fixture)))
self.end_headers()
self.wfile.write(fixture)
return
def do_HEAD(self):
self.send_response(200)
self.send_header('Content-Length', str(len(fixture)))
self.end_headers()
return
def log_message(self, *args, **kwargs):
# Override this method to prevent debug output from going
# to stderr during testing
return
return StaticHTTPRequestHandler
server_address = ('127.0.0.1', 0)
handler_class = _get_http_handler_class(image_data)
httpd = BaseHTTPServer.HTTPServer(server_address, handler_class)
port = httpd.socket.getsockname()[1]
pid = os.fork()
if pid == 0:
httpd.serve_forever()
else:
return pid, port
def main():
httpd = http.HTTPServer(('0.0.0.0', 8000), Request_Handler)
try:
print("Receive running on port 8000")
httpd.serve_forever()
except KeyboardInterrupt:
httpd.server_close()
print("Done")
def run_server():
server_address = ('', 8000)
httpd = _hs.HTTPServer(server_address, RequestHandler)
trace('server is starting...')
global server_keeps_running
while server_keeps_running:
httpd.handle_request()
trace('server has stopped')
def run(port=8080):
server_address, handler = ('', port), RequestHandler
httpd = server.HTTPServer(server_address, handler)
print(("Server running on port http://localhost:{}.".format(
server_address[1])))
print("Press CTRL+C to Quit.")
httpd.serve_forever()
def __init__(self, *args):
super().__init__()
self.port = args[0]
self.logger = args[1]
self.ip = self.getIP()
self.print_name = "Webserver"
self.httpd = webserver.HTTPServer(('', 80),
webserver.BaseHTTPRequestHandler)
def __init__(self):
# port == 0 will assign a random free port
self.handler = HTTPRequestHandler
self.server = http.HTTPServer(("", 0), self.handler)
self.server.allow_reuse_address = True
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.start()
logging.info("now serving on port {}".format(self.server.server_port))
def api_server(api_server_port):
mock_server = server.HTTPServer(
("localhost", api_server_port), api_mock.MockApiServer
)
mock_server_thread = threading.Thread(target=mock_server.serve_forever)
mock_server_thread.setDaemon(True)
mock_server_thread.start()
return mock_server
def main():
serverAddress = ('', 8080)
se = server.HTTPServer(serverAddress, RequestHandler)
try:
se.serve_forever()
except KeyboardInterrupt:
pass
se.server_close()
def run():
port = 8081
if 'port' in options:
port = int(options['port'])
local_server = server_class.HTTPServer(('localhost', port),
instance_for(captured_scope))
print('Serving on http://localhost:8081')
local_server.serve_forever(0.1)
def __init__(self, port: int, work_dir: str, certfile: str, keyfile: str):
self.work_dir = work_dir
self._ssl = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
# openssl req -new -x509 -days 3650 -nodes -out mycertfile.pem -keyout mykeyfile.pem
self._ssl.load_cert_chain(certfile, keyfile)
self.httpd = server.HTTPServer(('localhost', port), HTTPRequest)
self.httpd.socket = self._ssl.wrap_socket(self.httpd.socket,
server_side=True)
def login_server(login_server_port):
mock_server = server.HTTPServer(
("localhost", login_server_port), login_mock.MockLoginServer
)
mock_server_thread = threading.Thread(target=mock_server.serve_forever)
mock_server_thread.setDaemon(True)
mock_server_thread.start()
return mock_server
def setUpClass(cls):
cls.server = server.HTTPServer(('', 27489), MockBugzillaServer)
cls.bugzillaProvider = BugzillaProvider({
'General': {'env': 'dev'},
'apikey': 'bob',
'url': 'http://localhost:27489/',
})
cls.bugzillaProvider.update_config(SimpleLoggerConfig)
def main(args):
try:
port = int(args[1])
except IndexError:
port = 8000
server_address = ('', port)
httpd = BaseHTTPServer.HTTPServer(server_address, LoggingProxyHTTPHandler)
httpd.serve_forever()
def serve(host=HOST, port=PORT, open_browser=False):
server_address = (HOST, port)
SimpleHTTPRequestHandler.protocol_version = "HTTP/1.0"
os.chdir(ROOT_DST_PATH)
httpd = BaseHTTPServer.HTTPServer(server_address, SimpleHTTPRequestHandler)
print("Serving HTTP on %s port %d ..." % server_address)
if open_browser:
webbrowser.open_new_tab("http://%s:%d" % server_address)
httpd.serve_forever()
def serve(html,
ip='127.0.0.1',
port=8888,
n_retries=50,
files=None,
ipython_warning=False,
open_browser=True,
http_server=None):
"""Start a server serving the given HTML, and (optionally) open a
browser
Parameters
----------
html : string
HTML to serve
ip : string (default = '127.0.0.1')
ip address at which the HTML will be served.
port : int (default = 8888)
the port at which to serve the HTML
n_retries : int (default = 50)
the number of nearby ports to search if the specified port is in use.
files : dictionary (optional)
dictionary of extra content to serve
ipython_warning : bool (optional)
if True (default), then print a warning if this is used within IPython
open_browser : bool (optional)
if True (default), then open a web browser to the given HTML
http_server : class (optional)
optionally specify an HTTPServer class to use for showing the
figure. The default is Python's basic HTTPServer.
"""
port = find_open_port(ip, port, n_retries)
Handler = generate_handler(html, files)
if http_server is None:
srvr = server.HTTPServer((ip, port), Handler)
else:
srvr = http_server((ip, port), Handler)
if ipython_warning:
print(IPYTHON_WARNING)
# Start the server
print("Serving to http://{0}:{1}/ [Ctrl-C to exit]".format(ip, port))
sys.stdout.flush()
if open_browser:
# Use a thread to open a web browser pointing to the server
b = lambda: webbrowser.open('http://{0}:{1}'.format(ip, port))
threading.Thread(target=b).start()
try:
srvr.serve_forever()
except (KeyboardInterrupt, SystemExit):
print("\nstopping Server...")
srvr.server_close()
def mcpi_central_server(id, secret, client, db_url):
handler = APIServer(id, secret, client, db_url)
server = http.HTTPServer(("0.0.0.0", int(environ.get("PORT"))), handler)
try:
server.serve_forever()
except KeyboardInterrupt:
handler.db.close()
print()
return 0
