ASGI vs WSGI: Web Server Interfaces

# Minimal WSGI application
def application(environ, start_response):
    """
    environ: Dictionary containing HTTP request information
    start_response: Callable to send HTTP response headers
    """
    # Read request information
    method = environ['REQUEST_METHOD']
    path = environ['PATH_INFO']

    # Prepare response
    status = '200 OK'
    headers = [('Content-Type', 'application/json')]

    # Send headers
    start_response(status, headers)

    # Return response body as iterable of bytes
    response_body = b'{"message": "Hello from WSGI!"}'
    return [response_body]


# To run with a WSGI server:
# gunicorn myapp:application

# WSGI blocks on I/O operations
import time

def wsgi_app(environ, start_response):
    # This blocks the entire worker!
    time.sleep(5)  # Simulating database query

    start_response('200 OK', [('Content-Type', 'text/plain')])
    return [b'Done!']

# Problem: While sleeping, this worker can't handle other requests
# Solution: Need more workers = more memory = doesn't scale well

# Minimal ASGI application
async def application(scope, receive, send):
    """
    scope: Dictionary with connection information (type, method, path, headers)
    receive: Async callable to receive messages from client
    send: Async callable to send messages to client
    """
    if scope['type'] == 'http':
        # Handle HTTP request
        await send({
            'type': 'http.response.start',
            'status': 200,
            'headers': [
                [b'content-type', b'application/json'],
            ],
        })
        await send({
            'type': 'http.response.body',
            'body': b'{"message": "Hello from ASGI!"}',
        })
    elif scope['type'] == 'websocket':
        # Handle WebSocket connection
        await send({'type': 'websocket.accept'})

        message = await receive()
        await send({
            'type': 'websocket.send',
            'text': 'Echo: ' + message['text']
        })


# To run with an ASGI server:
# uvicorn myapp:application

# FastAPI lifespan events
from fastapi import FastAPI
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: runs once when application starts
    print("🚀 Connecting to database...")
    db = await connect_to_database()

    yield  # Application runs here

    # Shutdown: runs once when application stops
    print("🛑 Closing database connection...")
    await db.close()


app = FastAPI(lifespan=lifespan)

@app.get("/")
async def read_root():
    return {"message": "API is running"}

# app.py - Flask application
from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return {"message": "Hello from Flask"}


# Run with different WSGI servers:

# 1. Development server (built-in, not for production)
# python -m flask run

# 2. Gunicorn (production-ready)
# pip install gunicorn
# gunicorn -w 4 -b 0.0.0.0:8000 app:app
# -w 4: 4 worker processes
# -b: bind to host:port

# 3. uWSGI (alternative production server)
# pip install uwsgi
# uwsgi --http :8000 --wsgi-file app.py --callable app --master

# 4. With Nginx (reverse proxy)
# Nginx → Gunicorn → Flask app

# main.py - FastAPI application
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def hello():
    return {"message": "Hello from FastAPI"}


# Run with different ASGI servers:

# 1. Uvicorn (most popular, recommended)
# pip install uvicorn
# uvicorn main:app --host 0.0.0.0 --port 8000
# With auto-reload for development:
# uvicorn main:app --reload

# 2. Uvicorn with multiple workers (production)
# uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

# 3. Hypercorn (alternative ASGI server)
# pip install hypercorn
# hypercorn main:app --bind 0.0.0.0:8000

# 4. Daphne (Django Channels server)
# pip install daphne
# daphne -b 0.0.0.0 -p 8000 main:app

# 5. With Nginx (reverse proxy)
# Nginx → Uvicorn → FastAPI app