# Gunicorn

***

**1. Simple HTTP Server**

```python
import os

from gunicorn.config import Config
from gunicorn.app.base import BaseApplication

class HelloApp(BaseApplication):
    def __init__(self, application, options):
        self.options = options
        self.application = application
        super().__init__()

    def load_config(self):
        config = Config()
        for key, value in self.options.items():
            config.set(key.lower(), value)
        return config

    def init(self, parser, opts, args):
        pass

    def run(self):
        return self.application(self.environ, self.start_response)

    def __call__(self, environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/plain')])
        return [b'Hello, world!\n']

if __name__ == '__main__':
    HelloApp(None, {}).run()
```

**2. Host a Django Application**

```python
import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')

application = get_wsgi_application()
```

**3. Host a Flask Application**

```python
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, world!'

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=5000)
```

**4. Host a Twisted Application**

```python
from twisted.web import server, resource

class HelloResource(resource.Resource):
    def render_GET(self, request):
        return b'Hello, world!'

site = server.Site(HelloResource())
```

**5. Host a Tornado Application**

```python
import tornado.ioloop
import tornado.web

class HelloHandler(tornado.web.RequestHandler):
    def get(self):
        self.write('Hello, world!')

application = tornado.web.Application([(r'/', HelloHandler)])

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    application.listen(port)
    tornado.ioloop.IOLoop.instance().start()
```

**6. Use a Custom Server Class**

```python
from gunicorn.app.base import BaseApplication

class MyServer(BaseApplication):
    def __init__(self, application, options):
        self.options = options
        self.application = application
        super().__init__()

    def load_config(self):
        config = Config()
        for key, value in self.options.items():
            config.set(key.lower(), value)
        return config

    def init(self, parser, opts, args):
        pass

    def run(self):
        return self.application(self.environ, self.start_response)

    def __call__(self, environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/plain')])
        return [b'Hello, world!\n']

if __name__ == '__main__':
    MyServer(None, {}).run()
```

**7. Use a Custom Worker Class**

```python
from gunicorn.workers.base import Worker

class MyWorker(Worker):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def handle(self, request):
        # Process the request
        pass

if __name__ == '__main__':
    MyWorker().run()
```

**8. Use a Custom Logger**

```python
import logging
import sys

from gunicorn.logging import Logger

class MyLogger(Logger):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # Configure the logger
        self.handler = logging.StreamHandler(sys.stdout)
        self.handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
        self.logger.addHandler(self.handler)

        # Set the log level
        self.logger.setLevel(logging.INFO)

if __name__ == '__main__':
    MyLogger().daemon_log()
```

**9. Use a Custom Configuration**

```python
from gunicorn.config import Config

config = Config()

# Set the bind address and port
config.bind = '127.0.0.1:8000'

# Set the number of workers
config.workers = 4

# Set the log level
config.loglevel = 'info'

if __name__ == '__main__':
    HelloApp(None, config).run()
```

**10. Use a Custom SSL Context**

```python
from gunicorn.config import Config
from ssl import SSLContext

config = Config()

# Set the bind address and port
config.bind = 'mysite.com:443'

# Create an SSL context
context = SSLContext()
context.load_cert_chain('mysite.crt', 'mysite.key')

# Set the SSL context
config.ssl_context = context

if __name__ == '__main__':
    HelloApp(None, config).run()
```

**11. Use a Custom Error Handler**

```python
from gunicorn.app.base import Application

class MyApplication(Application):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def handle_error(self, request, response, *args):
        # Handle the error
        pass

if __name__ == '__main__':
    MyApplication(None, {}).run()
```

**12. Use a Custom Middleware**

```python
from gunicorn.app.middleware import Middleware

class MyMiddleware(Middleware):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def process_request(self, request):
        # Process the request
        pass

    def process_response(self, request, response):
        # Process the response
        pass

if __name__ == '__main__':
    MyMiddleware(HelloApp(None, {})).run()
```

**13. Use a Custom Signal Handler**

```python
from gunicorn.app.base import BaseApplication
from gunicorn.signals import pre_fork

class MyApplication(BaseApplication):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # Register a signal handler
        pre_fork.connect(self.pre_fork_handler)

    def pre_fork_handler(self, server):
        # Handle the pre-fork signal
        pass

if __name__ == '__main__':
    MyApplication(None, {}).run()
```

**14. Host a GraphQL API**

```python
import graphene
import graphql_ws
import gunicorn.app.base

schema = graphene.Schema(query=MyQuery)

class GraphQLApp(gunicorn.app.base.BaseApplication):
    def __init__(self, application, options):
        self.options = options
        self.application = application
        self.schema = schema
        self.middleware = graphql_ws.WebSocketsMiddleware(schema)
        super().__init__()

    def load_config(self):
        config = Config()
        for key, value in self.options.items():
            config.set(key.lower(), value)
        return config

    def init(self, parser, opts, args):
        pass

    def run(self):
        return self.application(self.environ, self.start_response)

    def __call__(self, environ, start_response):
        if environ['PATH_INFO'] == '/graphql':
            self.application(environ, start_response)
        else:
            self.middleware(environ, start_response)

if __name__ == '__main__':
    GraphQLApp(None, {}).run()
```

**15. Host a WebSocket API**

```python
import tornado.ioloop
import tornado.web
import tornado.websocket

class WebSocketHandler(tornado.websocket.WebSocketHandler):
    def open(self):
        # Handle the WebSocket connection
        pass

    def on_message(self, message):
        # Handle the WebSocket message
        pass

    def on_close(self):
        # Handle the WebSocket close
        pass

application = tornado.web.Application([(r'/websocket', WebSocketHandler)])

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    application.listen(port)
    tornado.ioloop.IOLoop.instance().start()
```

**16. Host a REST API with Swagger Documentation**

```python
from flask import Flask, jsonify, request
from flask_restplus import Api, Resource

app = Flask(__name__)
api = Api(app)

@api.route('/api/v1/users')
class UserResource(Resource):
    def get(self):
        return jsonify([{'id': 1, 'name': 'John Doe'}, {'id': 2, 'name': 'Jane Doe'}])

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=5000)
```

**17. Host a GraphQL API with GraphQL Playground**

```python
import graphene
import graphql_playground
import gunicorn.app.base

schema = graphene.Schema(query=MyQuery)

class GraphQLPlaygroundApp(gunicorn.app.base.BaseApplication):
    def __init__(self, application, options):
        self.options = options
        self.application = application
        self.schema = schema
        super().__init__()

    def load_config(self):
        config = Config()
        for key, value in self.options.items():
            config.set(key.lower(), value)
        return config

    def init(self, parser, opts, args):
        pass

    def run(self):
        return self.application(self.environ, self.start_response)

    def __call__(self, environ, start_response):
        if environ['PATH_INFO'] == '/graphql':
            self.application(environ, start_response)
        else:
            start_response('200 OK', [('Content-Type', 'text/html')])
            return [graphql_playground.graphiql_html(schema)]

if __name__ == '__main__':
    GraphQLPlaygroundApp(None, {}).run()
```

**18. Host a REST API with CORS**

```python
from flask import Flask, jsonify, request
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route('/api/v1/users')
def user_list():
    return jsonify([{'id': 1, 'name': 'John Doe'}, {'id': 2, 'name': 'Jane Doe'}])

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=5000)
```

**19. Host a REST API with rate limiting**

```python
from flask import Flask, jsonify, request
from flask_limiter import Limiter,

```