def _start_on_server_thread(self) -> None:
configuration = QuicConfiguration(
alpn_protocols=H3_ALPN,
is_client=False,
max_datagram_frame_size=65536,
)
_logger.info("Starting WebTransport over HTTP/3 server on %s:%s",
self.host, self.port)
configuration.load_cert_chain(self.cert_path, self.key_path)
ticket_store = SessionTicketStore()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.loop.run_until_complete(
serve(
self.host,
self.port,
configuration=configuration,
create_protocol=WebTransportH3Protocol,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add,
))
self.loop.run_forever()
def start(kwargs):
configuration = QuicConfiguration(
alpn_protocols=['wq-vvv-01'] + ['siduck'],
is_client=False,
max_datagram_frame_size=65536,
)
global handlers_path
handlers_path = os.path.abspath(os.path.expanduser(
kwargs['handlers_path']))
logger.info('port = %s', kwargs['port'])
logger.info('handlers path = %s', handlers_path)
# load SSL certificate and key
configuration.load_cert_chain(kwargs['certificate'], kwargs['private_key'])
ticket_store = SessionTicketStore()
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve(
kwargs['host'],
kwargs['port'],
configuration=configuration,
create_protocol=QuicTransportProtocol,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add,
))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
def configure_http3_server(
listen_port,
server_port,
https_pem,
ca_pem,
listening_sentinel,
h3_to_server=False):
HttpQuicServerHandler.cert_file = https_pem
HttpQuicServerHandler.ca_file = ca_pem
HttpQuicServerHandler.h3_to_server = h3_to_server
HttpQuicServerHandler.server_port = server_port
try:
os.mkdir('quic_log_directory')
except FileExistsError:
pass
quic_logger = QuicDirectoryLogger('quic_log_directory')
secrets_log_file = open('tls_secrets.log', "a", encoding='utf-8')
configuration = QuicConfiguration(
alpn_protocols=H3_ALPN,
is_client=False,
max_datagram_frame_size=65536,
quic_logger=quic_logger,
secrets_log_file=secrets_log_file,
)
configuration.load_cert_chain(https_pem, ca_pem)
ticket_store = SessionTicketStore()
# TODO
# In 3.7: how about asyncio.run(serve(...))
loop = asyncio.get_event_loop()
server_side_proto = "HTTP/3" if h3_to_server else "HTTP/1"
print(
f"Serving HTTP/3 Proxy on 127.0.0.1:{listen_port} with pem '{https_pem}', "
f"forwarding to 127.0.0.1:{server_port} over {server_side_proto}")
loop.run_until_complete(
serve(
'0.0.0.0',
listen_port,
configuration=configuration,
create_protocol=HttpQuicServerHandler,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add
)
)
# Indicate to the caller that the quic socket is configured and listening.
Path(listening_sentinel).touch()
try:
loop.run_forever()
except KeyboardInterrupt as e:
# The calling test_proxy.py will handle this.
print("Handling KeyboardInterrupt")
raise e
except SystemExit:
pass
def rsocket_serve(host: str,
port: int,
configuration: QuicConfiguration = None,
on_server_create=None,
**kwargs):
if configuration is None:
configuration = QuicConfiguration(
is_client=False
)
def protocol_factory(*protocol_args, **protocol_kwargs):
protocol = RSocketQuicProtocol(*protocol_args, **protocol_kwargs)
server = RSocketServer(RSocketQuicTransport(protocol), **kwargs)
if on_server_create is not None:
on_server_create(server)
return protocol
return serve(
host,
port,
create_protocol=protocol_factory,
configuration=configuration)
configuration = QuicConfiguration(
alpn_protocols=H3_ALPN + H0_ALPN + ["siduck"],
is_client=False,
max_datagram_frame_size=65536,
quic_logger=quic_logger,
secrets_log_file=secrets_log_file,
)
# load SSL certificate and key
configuration.load_cert_chain(args.certificate, args.private_key)
ticket_store = SessionTicketStore()
if uvloop is not None:
uvloop.install()
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve(
args.host,
args.port,
configuration=configuration,
create_protocol=HttpServerProtocol,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add,
retry=args.retry,
))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('certificate')
parser.add_argument('key')
args = parser.parse_args()
configuration = QuicConfiguration(
# Identifies the protocol used. The origin trial uses the protocol
# described in draft-vvv-webtransport-quic-01, hence the ALPN value.
# See https://tools.ietf.org/html/draft-vvv-webtransport-quic-01#section-3.1
alpn_protocols=['wq-vvv-01'],
is_client=False,
# Note that this is just an upper limit; the real maximum datagram size
# available depends on the MTU of the path. See
# <https://en.wikipedia.org/wiki/Maximum_transmission_unit>.
max_datagram_frame_size=1500,
)
configuration.load_cert_chain(args.certificate, args.key)
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve(
BIND_ADDRESS,
BIND_PORT,
configuration=configuration,
create_protocol=QuicTransportProtocol,
))
loop.run_forever()
format="%(asctime)s.%(msecs)03d %(levelname)-8s %(message)s",
level=logging.INFO,
datefmt="%Y-%m-%d %H:%M:%S",
)
configuration.load_cert_chain(args.certificate, args.private_key)
if uvloop is not None:
uvloop.install()
loop = asyncio.get_event_loop()
loop.create_task(
serve(
args.host,
args.port,
configuration=configuration,
create_protocol=VideoStreamServerProtocol,
retry=True,
)
)
logging.info(
f"Starting Server with VideoStreamServerProtocol on {args.host}:{args.port}"
)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
logging.info("Program Terminated")
def process_client_indication(self) -> None:
indication = dict(
self.parse_client_indication(
io.BytesIO(self.client_indication_data)))
origin = urllib.parse.urlparse(indication[0].decode())
path = urllib.parse.urlparse(indication[1]).decode()
self.handler = TestHandler(self._quic)
def is_closing_or_closed(self) -> bool:
return self._quic._close_pending or self._quic._state in END_STATES
if __name__ == '__main__':
configuration = QuicConfiguration(
alpn_protocols=['wq-vvv-01'],
is_client=False,
max_datagram_frame_size=1500,
)
configuration.load_cert_chain('localhost.crt', 'localhost.key')
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve(
'localhost',
4443,
configuration=configuration,
create_protocol=QuicTransportProtocol,
))
loop.run_forever()
yield (key, value)
def process_client_indication(self) -> None:
indication = dict(self.parse_client_indication(io.BytesIO(self.client_indication_data)))
origin = urllib.parse.urlparse(indication[0].decode())
path = urllib.parse.urlparse(indication[1]).decode()
self.handler = TestHandler(self._quic)
def is_closing_or_closed(self) -> bool:
return self._quic._close_pending or self._quic._state in END_STATES
if __name__ == '__main__':
configuration = QuicConfiguration(
alpn_protocols=['wq-vvv-01'],
is_client=False,
max_datagram_frame_size=1500,
)
configuration.load_cert_chain('localhost.crt', 'localhost.key')
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve(
'::1',
4443,
configuration=configuration,
create_protocol=QuicTransportProtocol,
))
loop.run_forever()
configuration = QuicConfiguration(
alpn_protocols=['wq-vvv-01'] + ['siduck'],
is_client=False,
max_datagram_frame_size=65536,
)
handlers_path = os.path.abspath(os.path.expanduser(args.handlers_path))
logging.log(logging.INFO, 'port = %s' % args.port)
logging.log(logging.INFO, 'handlers path = %s' % handlers_path)
# load SSL certificate and key
configuration.load_cert_chain(args.certificate, args.private_key)
ticket_store = SessionTicketStore()
loop = asyncio.get_event_loop()
loop.run_until_complete(
serve(
args.host,
args.port,
configuration=configuration,
create_protocol=QuicTransportProtocol,
session_ticket_fetcher=ticket_store.pop,
session_ticket_handler=ticket_store.add,
)
)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
default=6363,
help='router port',
metavar='PORT')
opts = parser.parse_args()
configuration = QuicConfiguration(
alpn_protocols=H3_ALPN,
is_client=False,
max_datagram_frame_size=32 + opts.mtu,
)
configuration.load_cert_chain(opts.cert, opts.key)
logging.info('Starting QUIC server at [%s]:%d', opts.listen_addr,
opts.listen_port)
logging.info('NDN router is at [%s]:%d', opts.router_addr,
opts.router_port)
def create_protocol(*args, **kwargs):
return H3Server((opts.router_addr, opts.router_port), opts.mtu, *args,
**kwargs)
loop = aio.new_event_loop()
loop.run_until_complete(
serve(
opts.listen_addr,
opts.listen_port,
configuration=configuration,
create_protocol=create_protocol,
))
loop.run_forever()
