https://github.com/mopemope/meinheld

Meinheld is a high performance asynchronous WSGI Web Server (based on picoev)
https://github.com/mopemope/meinheld

async http-server python python3 wsgi-server

Last synced: 4 days ago
JSON representation

Meinheld is a high performance asynchronous WSGI Web Server (based on picoev)

• Host: GitHub
• URL: https://github.com/mopemope/meinheld
• Owner: mopemope
• License: other
• Created: 2010-07-30T01:38:27.000Z (over 14 years ago)
• Default Branch: master
• Last Pushed: 2021-05-08T08:18:11.000Z (over 3 years ago)
• Last Synced: 2024-12-31T20:07:09.060Z (11 days ago)
• Topics: async, http-server, python, python3, wsgi-server
• Language: C
• Homepage: http://meinheld.org
• Size: 3.96 MB
• Stars: 1,461
• Watchers: 46
• Forks: 103
• Open Issues: 32
• Metadata Files:
  • Readme: README.rst
  • Changelog: CHANGES.rst
  • License: LICENSE

Awesome Lists containing this project

• starred-awesome - meinheld - meinheld is a high performance asynchronous WSGI Web Server (based on picoev) (C)

README

        
What's this

---------------------------------

.. image:: https://travis-ci.org/mopemope/meinheld.svg

    :target: https://travis-ci.org/mopemope/meinheld

This is a high performance python wsgi web server.

And Meinheld is a WSGI compliant web server. (PEP333 and PEP3333 supported)

You can also join us in `meinheld mailing list`_.

Requirements

---------------------------------

Meinheld requires **Python 2.x >= 2.6** or **Python 3.x >= 3.5** . and **greenlet >= 0.4.5**.

Meinheld supports Linux, FreeBSD, and macOS.

Installation

---------------------------------

Install from pypi::

  $ pip install -U meinheld

Install from source::

  $ python setup.py install

Meinheld also supports working as a gunicorn worker.

To install gunicorn::

  $ pip install -U gunicorn

Basic Usage

---------------------------------

simple wsgi app:

.. code:: python

    from meinheld import server

    def hello_world(environ, start_response):

        status = b'200 OK'

        res = b"Hello world!"

        response_headers = [('Content-type', 'text/plain'), ('Content-Length', str(len(res)))]

        start_response(status, response_headers)

        return [res]

    server.listen(("0.0.0.0", 8000))

    server.run(hello_world)

with gunicorn. user worker class "egg:meinheld#gunicorn_worker" or "meinheld.gmeinheld.MeinheldWorker"::

    $ gunicorn --workers=2 --worker-class="egg:meinheld#gunicorn_worker" gunicorn_test:app

Continuation

---------------------------------

**NOTE: This feature is deprecated and will be removed in 2.0**

Meinheld provides a simple continuation API (based on greenlet).

To enable continuations, use ContinuationMiddleware. get Continuation from wsgi environ.

Continuation objects have two very interesting methods, `suspend` and `resume`.

For example:

.. code:: python

    from meinheld import server

    from meinheld import middleware

    def app(environ, start_response):

        ...

        #get Continuation

        c = environ.get(middleware.CONTINUATION_KEY, None)

        ...

        if condtion:

            waiters.append(c)

            #suspend

            c.suspend()

        else:

            for c in waiters:

                # resume suspend function

                c.resume()

        ...

    server.listen(("0.0.0.0", 8000))

    server.run(middleware.ContinuationMiddleware(hello_world))

For more info see http://github.com/mopemope/meinheld/tree/master/example/chat/

Websocket

---------------------------------

**NOTE: This feature is deprecated and will be removed in 2.0**

Meinheld support Websockets. use WebSocketMiddleware.

For example:

.. code:: python

    from flask import Flask, render_template, request

    from meinheld import server, middleware

    SECRET_KEY = 'development key'

    DEBUG=True

    app = Flask(__name__)

    app.config.from_object(__name__)

    participants = set()

    @app.route('/')

    def index():

        return render_template('websocket_chat.html')

    @app.route('/chat')

    def chat():

        print request.environ

        ws = request.environ.get('wsgi.websocket')

        participants.add(ws)

        try:

            while True:

                print "ws.wait()..."

                m = ws.wait()

                print "recv msg %s" % m

                if m is None:

                    break

                for p in participants:

                    print "send message %s" % m

                    p.send(m)

        finally:

            participants.remove(ws)

        return ""

    if __name__ == "__main__":

        server.listen(("0.0.0.0", 8000))

        server.run(middleware.WebSocketMiddleware(app))

Patching

---------------------------------

**NOTE: This feature is deprecated and will be removed in 2.0**

Meinheld provides a few monkeypatches.

Socket

==========================================

This patch replaces the standard socket module.

For Example:

.. code:: python

    from meinheld import patch

    patch.patch_all()

For more info see http://github.com/mopemope/meinheld/tree/master/example/patch/

Performance

------------------------------

For parsing HTTP requests, Meinheld uses Ryan Dahl's http-parser library.

(see https://github.com/joyent/http-parser)

It is built around the high performance event library picoev.

(see http://developer.cybozu.co.jp/kazuho/2009/08/picoev-a-tiny-e.html)

Sendfile

===========================

Meinheld uses sendfile(2), over wgsi.file_wrapper.

.. _meinheld mailing list: http://groups.google.com/group/meinheld