def __enter__(self):
for server_number in range(self.number_of_servers):
self.mock_server_address, mock_server_port = get_free_port()
mock_server = TCPServer(('localhost', mock_server_port),
MockEpoServerRequestHandler)
mock_server.socket = ssl.wrap_socket(
mock_server.socket,
certfile=MOCK_EPOHTTPSERVER_CERTNAME,
keyfile=MOCK_EPOHTTPSERVER_KEYNAME,
server_side=True)
mock_server_thread = Thread(target=mock_server.serve_forever)
self.servers[server_number] = {
"server": mock_server,
"thread": mock_server_thread
}
self.servers[server_number]["thread"].setDaemon(True)
self.servers[server_number]["thread"].start()
self.server_info_list.append({
SERVER_INFO_SERVER_NAME_KEY:
TEST_EPONAME_BASE + str(server_number),
SERVER_INFO_SERVER_PORT_KEY:
mock_server_port,
})
return self.server_info_list
def serve(port_queue: "Queue[int]", shutdown_queue: "Queue[bool]") -> None:
httpd = TCPServer(("", 0), handler_class)
httpd.timeout = 0.1
if ssl_context:
httpd.socket = ssl_context.wrap_socket(httpd.socket,
server_side=True)
port_queue.put(httpd.server_address[1])
while shutdown_queue.empty():
httpd.handle_request()
def tcp_listener(port):
host = "localhost"
cntx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
cntx.load_cert_chain('cert.pem', 'cert.pem')
server = TCPServer((host, port), tcp_handler)
server.socket = cntx.wrap_socket(server.socket, server_side=True)
try:
server.serve_forever()
except:
print("listener shutting down")
server.shutdown()
def https_server(address,
path,
cacert,
cert,
key,
client_verification=False):
os.chdir(path)
httpd = TCPServer(address, NoLogHttpHandler)
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH,
cafile=cacert)
context.load_cert_chain(certfile=cert, keyfile=key)
if client_verification:
context.verify_mode = ssl.CERT_REQUIRED
httpd.socket = context.wrap_socket(httpd.socket, server_side=True)
httpd.serve_forever()
def serve_https(https_port=80, https=True, start_dir=None, handler_class=SimpleHTTPRequestHandler):
''' setting up server '''
TCPServer.allow_reuse_address = True
httpd = TCPServer(("", https_port), handler_class)
if https:
# If you use SSL, create a ".ssl" directory under your boot directory and
# store your private key and certificate in it.
keyfile, certfile = cert.create_ssl_cert(socket.gethostname())
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=keyfile,
certfile=certfile, server_side=True)
if start_dir:
logger.info("Changing dir to {cd}".format(cd=start_dir))
os.chdir(start_dir)
socket_addr = httpd.socket.getsockname()
print("Serving HTTP on", socket_addr[0], "port", socket_addr[1], "use <Ctrl-C> to stop...")
httpd.serve_forever()
def serve_https(https_port=80,
https=True,
start_dir=None,
handler_class=AuthRequestHandler):
''' setting up server '''
httpd = TCPServer(("", https_port), handler_class)
if https:
httpd.socket = ssl.wrap_socket(httpd.socket,
keyfile=KEY_FILE,
certfile=CERT_FILE,
server_side=True)
if start_dir:
print("Changing dir to {cd}".format(cd=start_dir))
os.chdir(start_dir)
socket_addr = httpd.socket.getsockname()
print("Serving HTTP on", socket_addr[0], "port", socket_addr[1], "...")
httpd.serve_forever()
def setup_proxy(listen_port: int, listen_ssl: bool, dst_url: str, record: bool,
record_file: str, replay: bool, replay_throttle: bool,
replay_clear_cache: bool, replay_clear_cache_seconds: int,
config: str, verbose: int):
with logerr():
with wrap_context('initialization'):
extensions = load_extensions(config)
_config = Config(
listen_port=listen_port,
listen_ssl=listen_ssl,
dst_url=dst_url,
record=record,
record_file=record_file,
replay=replay,
replay_throttle=replay_throttle,
replay_clear_cache=replay_clear_cache,
replay_clear_cache_seconds=replay_clear_cache_seconds,
verbose=verbose,
)
if extensions.override_config:
extensions.override_config(_config)
log.info('Configuration set', **asdict(_config))
RequestHandler.extensions = extensions
RequestHandler.config = _config
RequestHandler.cache = RequestCache(extensions, _config)
TCPServer.allow_reuse_address = True
httpd = TCPServer((_config.listen_addr, _config.listen_port),
RequestHandler)
if _config.listen_ssl:
httpd.socket = ssl.wrap_socket(httpd.socket,
certfile='./dev-cert.pem',
server_side=True)
log.info(
f'Listening on {_config.listen_scheme} port {_config.listen_port}...'
)
try:
httpd.serve_forever()
finally:
httpd.server_close()
httpd = TCPServer(("", opt.port), MyHandler)
print("serving at port", opt.port)
httpd.serve_forever()
else:
port = server.port
if not port:
port = int(opt.port)
if port < 100: port = 443
import ssl
import subprocess
hostname = server.hostname
if not hostname:
hostname = "localhost"
cc = hostname.split(".")[-1]
og = hostname.split(".")[-2]
if len(cc) > 2: cc = "US"
cmd = "openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes"
cmd += " -keyout /tmp/{hostname}.key -out /tmp/{hostname}.crt -subj /C={cc}/L={og}/CN={hostname}".format(
**locals())
print(cmd)
subprocess.call(cmd, shell=True)
cmd = "cat /tmp/{hostname}.key /tmp/{hostname}.crt > /tmp/{hostname}.pem".format(
**locals())
subprocess.call(cmd, shell=True)
httpd = TCPServer(("", port), MyHandler)
httpd.socket = ssl.wrap_socket(httpd.socket,
certfile='/tmp/%s.pem' % hostname,
server_side=True)
print("serving at port", port, "for", SSL)
httpd.serve_forever()
def server_https(handler):
httpd = TCPServer(("", PORT), handler)
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile=KEY_FILE, certfile=CERT_FILE, server_side=True)
httpd.serve_forever()
if self.headers.get('Authorization') == None:
self.do_AUTHHEAD()
self.wfile.write(b'no auth header received')
pass
elif self.check_user(self.headers.get('Authorization')):
SimpleHTTPRequestHandler.do_GET(self)
pass
else:
self.do_AUTHHEAD()
self.wfile.write(str.encode(self.headers.get('Authorization')))
self.wfile.write(b'\t!not authenticated\n')
pass
if certifacate_path is not None:
if single_user_key is not None:
httpd = TCPServer(('', 4443 if args.port is None else args.port), AuthHandler)
else:
httpd = TCPServer(('', 4443 if args.port is None else args.port), SimpleHTTPRequestHandler)
httpd.socket = ssl.wrap_socket (httpd.socket, certfile=certifacate_path, server_side=True)
sa = httpd.socket.getsockname()
print("Serving HTTP on "+ str(sa[0])+ " port "+ str(sa[1])+ "...")
httpd.serve_forever()
else:
if single_user_key is not None:
httpd = TCPServer(('', 8080 if args.port is None else args.port), AuthHandler)
else:
httpd = TCPServer(('', 8080 if args.port is None else args.port), SimpleHTTPRequestHandler)
sa = httpd.socket.getsockname()
print("Serving HTTP on "+ str(sa[0])+ " port "+ str(sa[1])+ "...")
httpd.serve_forever()
text = f.read()
f.close()
self.send_response(200)
except IOError:
print('Generating new')
q.put((hash, origin, vals))
self.send_response(500)
text = b'... And then what? Check back later to find out!'
self.send_header("Content-type", "text/html")
self.send_header("Content-length", len(text))
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
self.wfile.write(text)
def do_OPTIONS(self):
self.send_response(200, "ok")
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
GeneratorThread(name='generator-thread').start()
PORT = 443
httpd = TCPServer(("", PORT), MyHandler)
print("serving at port", PORT)
httpd.socket = ssl.wrap_socket (httpd.socket, certfile='/etc/letsencrypt/live/rebiasednews.ddns.net/fullchain.pem',
keyfile='/etc/letsencrypt/live/rebiasednews.ddns.net/privkey.pem', server_side=True)
httpd.serve_forever()
