def test_wsgi_exc_info():
# Note that we're testing the WSGI app directly here.
# The HTTP protocol implementations would catch this error and return 500.
app = WSGIMiddleware(return_exc_info)
client = TestClient(app)
with pytest.raises(RuntimeError):
response = client.get("/")
app = WSGIMiddleware(return_exc_info)
client = TestClient(app, raise_server_exceptions=False)
response = client.get("/")
assert response.status_code == 500
assert response.text == "Internal Server Error"
async def test_wsgi_post() -> None:
app = WSGIMiddleware(echo_body)
async with httpx.AsyncClient(app=app,
base_url="http://testserver") as client:
response = await client.post("/", json={"example": 123})
assert response.status_code == 200
assert response.text == '{"example": 123}'
def test_wsgi_exception():
# Note that we're testing the WSGI app directly here.
# The HTTP protocol implementations would catch this error and return 500.
app = WSGIMiddleware(raise_exception)
client = TestClient(app)
with pytest.raises(RuntimeError):
response = client.get("/")
def load(self):
assert not self.loaded
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(
HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.wsgi:
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
self.loaded = True
async def test_wsgi_get() -> None:
app = WSGIMiddleware(hello_world)
async with httpx.AsyncClient(app=app,
base_url="http://testserver") as client:
response = await client.get("/")
assert response.status_code == 200
assert response.text == "Hello World!\n"
async def test_wsgi_exception() -> None:
# Note that we're testing the WSGI app directly here.
# The HTTP protocol implementations would catch this error and return 500.
app = WSGIMiddleware(raise_exception)
async with httpx.AsyncClient(app=app,
base_url="http://testserver") as client:
with pytest.raises(RuntimeError):
await client.get("/")
async def test_wsgi_exc_info() -> None:
# Note that we're testing the WSGI app directly here.
# The HTTP protocol implementations would catch this error and return 500.
app = WSGIMiddleware(return_exc_info)
async with httpx.AsyncClient(app=app,
base_url="http://testserver") as client:
with pytest.raises(RuntimeError):
response = await client.get("/")
app = WSGIMiddleware(return_exc_info)
transport = httpx.ASGITransport(
app=app,
raise_app_exceptions=False,
)
async with httpx.AsyncClient(transport=transport,
base_url="http://testserver") as client:
response = await client.get("/")
assert response.status_code == 500
assert response.text == "Internal Server Error"
def load(self):
assert not self.loaded
encoded_headers = [
(key.lower().encode("latin1"), value.encode("latin1"))
for key, value in self.headers
]
self.encoded_headers = (
encoded_headers
if b"server" in dict(encoded_headers)
else [(b"server", b"uvicorn")] + encoded_headers
) # type: List[Tuple[bytes, bytes]]
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi2":
self.loaded_app = ASGI2Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
self.loaded = True
def load(self):
assert not self.loaded
if self.logger is None:
self.logger_instance = get_logger(self.log_level)
else:
self.logger_instance = self.logger
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.wsgi:
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
if self.ssl_keyfile or self.ssl_certfile:
self.ssl = create_ssl_context(
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
ssl_version=self.ssl_version,
cert_reqs=self.ssl_cert_reqs,
ca_certs=self.ssl_ca_certs,
ciphers=self.ssl_ciphers,
)
else:
self.ssl = None
self.loaded = True
def load(self):
assert not self.loaded
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(
HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi3":
self.loaded_app = ASGI3Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
self.loaded = True
def load(self):
assert not self.loaded
if self.is_ssl:
self.ssl = create_ssl_context(
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
password=self.ssl_keyfile_password,
ssl_version=self.ssl_version,
cert_reqs=self.ssl_cert_reqs,
ca_certs=self.ssl_ca_certs,
ciphers=self.ssl_ciphers,
)
else:
self.ssl = None
encoded_headers = [
(key.lower().encode("latin1"), value.encode("latin1"))
for key, value in self.headers
]
self.encoded_headers = (
encoded_headers
if b"server" in dict(encoded_headers)
else [(b"server", b"uvicorn")] + encoded_headers
) # type: List[Tuple[bytes, bytes]]
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
logger.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi2":
self.loaded_app = ASGI2Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if logger.level <= TRACE_LOG_LEVEL:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(
self.loaded_app, trusted_hosts=self.forwarded_allow_ips
)
self.loaded = True
def load(self) -> None:
assert not self.loaded
if self.is_ssl:
assert self.ssl_certfile
self.ssl: Optional[ssl.SSLContext] = create_ssl_context(
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
password=self.ssl_keyfile_password,
ssl_version=self.ssl_version,
cert_reqs=self.ssl_cert_reqs,
ca_certs=self.ssl_ca_certs,
ciphers=self.ssl_ciphers,
)
else:
self.ssl = None
encoded_headers = [(key.lower().encode("latin1"),
value.encode("latin1"))
for key, value in self.headers]
self.encoded_headers = ([(b"server", b"uvicorn")] + encoded_headers
if b"server" not in dict(encoded_headers)
and self.server_header else encoded_headers)
if isinstance(self.http, str):
http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
self.http_protocol_class: Type[
asyncio.Protocol] = http_protocol_class
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
self.ws_protocol_class: Optional[Type[
asyncio.Protocol]] = ws_protocol_class
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
logger.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
try:
self.loaded_app = self.loaded_app()
except TypeError as exc:
if self.factory:
logger.error("Error loading ASGI app factory: %s", exc)
sys.exit(1)
else:
if not self.factory:
logger.warning(
"ASGI app factory detected. Using it, "
"but please consider setting the --factory flag explicitly."
)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi2":
self.loaded_app = ASGI2Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if logger.level <= TRACE_LOG_LEVEL:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(
self.loaded_app, trusted_hosts=self.forwarded_allow_ips)
self.loaded = True
def test_wsgi_post():
app = WSGIMiddleware(echo_body)
client = TestClient(app)
response = client.post("/", json={"example": 123})
assert response.status_code == 200
assert response.text == '{"example": 123}'
def test_wsgi_get():
app = WSGIMiddleware(hello_world)
client = TestClient(app)
response = client.get("/")
assert response.status_code == 200
assert response.text == "Hello World!\n"
def run(
app,
host="127.0.0.1",
port=8000,
uds=None,
fd=None,
loop="auto",
http="auto",
ws="auto",
log_level="info",
access_log=True,
wsgi=False,
debug=False,
proxy_headers=False,
root_path="",
limit_concurrency=None,
limit_max_requests=None,
timeout_keep_alive=5,
install_signal_handlers=True,
ready_event=None,
):
if fd is None:
sock = None
else:
host = None
port = None
sock = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
logger = get_logger(log_level)
http_protocol_class = import_from_string(HTTP_PROTOCOLS[http])
ws_protocol_class = import_from_string(WS_PROTOCOLS[ws])
if isinstance(loop, str):
loop_setup = import_from_string(LOOP_SETUPS[loop])
loop = loop_setup()
try:
app = import_from_string(app)
except ImportFromStringError as exc:
click.echo("Error loading ASGI app. %s" % exc)
sys.exit(1)
if wsgi:
app = WSGIMiddleware(app)
ws_protocol_class = None
if debug:
app = DebugMiddleware(app)
if logger.level <= logging.DEBUG:
app = MessageLoggerMiddleware(app)
if proxy_headers:
app = ProxyHeadersMiddleware(app)
connections = set()
tasks = set()
state = {"total_requests": 0}
def create_protocol():
return http_protocol_class(
app=app,
loop=loop,
logger=logger,
access_log=access_log,
connections=connections,
tasks=tasks,
state=state,
ws_protocol_class=ws_protocol_class,
root_path=root_path,
limit_concurrency=limit_concurrency,
timeout_keep_alive=timeout_keep_alive,
)
server = Server(
app=app,
host=host,
port=port,
uds=uds,
sock=sock,
logger=logger,
loop=loop,
connections=connections,
tasks=tasks,
state=state,
limit_max_requests=limit_max_requests,
create_protocol=create_protocol,
on_tick=http_protocol_class.tick,
install_signal_handlers=install_signal_handlers,
ready_event=ready_event,
)
server.run()
def __init__(
self,
app,
host="127.0.0.1",
port=8000,
uds=None,
fd=None,
loop="auto",
http="auto",
ws="auto",
log_level="info",
logger=None,
access_log=True,
wsgi=False,
debug=False,
proxy_headers=False,
root_path="",
limit_concurrency=None,
limit_max_requests=None,
disable_lifespan=False,
timeout_keep_alive=5,
install_signal_handlers=True,
):
self.app = app
self.host = host
self.port = port
self.uds = uds
self.fd = fd
self.loop = loop
self.http = http
self.ws = ws
self.log_level = log_level
self.logger = logger
self.access_log = access_log
self.wsgi = wsgi
self.debug = debug
self.proxy_headers = proxy_headers
self.root_path = root_path
self.limit_concurrency = limit_concurrency
self.limit_max_requests = limit_max_requests
self.disable_lifespan = disable_lifespan
self.timeout_keep_alive = timeout_keep_alive
self.install_signal_handlers = install_signal_handlers
if fd is None:
self.sock = None
else:
self.host = None
self.port = None
self.sock = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
if self.logger is None:
self.logger = get_logger(log_level)
else:
assert log_level == "info", "Cannot set both 'logger' and 'log_level'"
if isinstance(http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[http])
else:
self.http_protocol_class = http
if isinstance(ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[ws])
else:
self.ws_protocol_class = ws
if isinstance(self.loop, str):
loop_setup = import_from_string(LOOP_SETUPS[loop])
self.loop = loop_setup()
try:
self.app = import_from_string(self.app)
except ImportFromStringError as exc:
click.echo("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.wsgi:
self.app = WSGIMiddleware(self.app)
self.ws_protocol_class = None
if self.debug:
self.app = DebugMiddleware(self.app)
if self.logger.level <= logging.DEBUG:
self.app = MessageLoggerMiddleware(self.app)
if self.proxy_headers:
self.app = ProxyHeadersMiddleware(self.app)
import os
from django.core.wsgi import get_wsgi_application
from dj_static import Cling
from uvicorn.middleware.wsgi import WSGIMiddleware
print(f"RUNNING: __name__: {__name__}")
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'testdjango.settings')
application = WSGIMiddleware(
Cling(get_wsgi_application()), workers=10
)
