def __init__(
        self, listener, application=None, backlog=2048, socket_type=socket.SOCK_STREAM, address_family=socket.AF_INET
    ):
        self.address_family = address_family
        self.socket_type = socket_type
        from meinheld import patch

        patch.patch_all()
        server.set_backlog(backlog)
        host, port = listener
        if host.startswith("fd://"):
            fd = int(host.split("://")[1])
            server.set_listen_socket(fd)
        else:
            if self.address_family == socket.AF_UNIX:
                filename = listener[0][len("unix:") :]

                try:
                    os.remove(filename)
                except OSError:
                    pass
                server.listen(filename)
            else:
                server.listen(listener)

        self.application = application

 def run(self, port, hostname, **kwargs):
     from meinheld import server, patch
     patch.patch_all()
     print(" - Running Hosting Server using Meinheld")
     print(" - http://%s:%s/" % (hostname, port))
     server.listen((hostname, port))
     server.run(self.app)

    def run(self, handler): # pragma: no cover
        import tornado.wsgi, tornado.httpserver, tornado.ioloop

        container = tornado.wsgi.WSGIContainer(handler)
        server = tornado.httpserver.HTTPServer(container)
        server.listen(port=self.port)
        tornado.ioloop.IOLoop.instance().start()

def main():
    opts, args = getopt.parse_args()

    if opts.debug:
        application.debug = True

    print "Server listen: http://%s:%s/" % (opts.address, opts.port)
    server.listen((opts.address, opts.port))
    server.run(application)

def test_getsockopt():
    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        tr = s.getsockopt(msocket.IPPROTO_TCP, msocket.TCP_NODELAY)
        assert(tr > 0)
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_fileno():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        assert(s.fileno() > 2)
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_detach():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.detach()
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_sock():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        assert(type(s) == msocket.socket)
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_connect_ex():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.connect_ex(("localhost", 8000))
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_connect_fail():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        with raises(msocket.gaierror):
            s.connect(("google.comaaa", 80))
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def meinheld_server_runner(wsgi_app, global_config, **settings):
    from meinheld import server, middleware
    host = settings.get('host', '0.0.0.0')
    port = int(settings.get('port', 8080))

    server.listen((host, port))
    server.set_access_logger(None)
    server.set_error_logger(None)

    print('Starting HTTP server on http://%s:%s' % (host, port))
    server.run(middleware.WebSocketMiddleware(wsgi_app))

def test_sendto():
    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.connect(("localhost", 8000))
        s.sendto(b"GET / HTTP/1.0\r\n\r\n", (b'localhost',8000))
        assert(len(s.recv(1024)) == 135)
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_timeout():
    def _test():
        val = 5
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.settimeout(val)
        assert(val == s.gettimeout())
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

    def __init__(self, listener, application=None, backlog=2048):
        from meinheld import patch
        patch.patch_all()
        server.set_backlog(backlog)
        host, port = listener
        if host.startswith('fd://'):
            fd = int(host.split('://')[1])
            server.set_listen_socket(fd)
        else:
            server.listen(listener)

        self.application = application

def test_makefile():
    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.connect(("localhost", 8000))
        f = s.makefile()
        assert(f)

        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def start(name):
    print "started server at "+str(host)+":"+str(port)
    if name =="meinheld":
        from meinheld import server
        server.set_access_logger(None)
        server.set_error_logger(None)
        server.listen((host, port))
        server.run(app)
    elif name =="gevent":
        #from gevent import wsgi 
        #wsgi.WSGIServer((host, port), application=app.application, log=None).serve_forever() 
        from gevent.pywsgi import WSGIServer
        WSGIServer((host, port), app, log=None).serve_forever()
    elif name =="bjoern":
        import bjoern
        bjoern.listen(app, host, port)
        bjoern.run() 
    elif name =="eventlet":
        import eventlet
        from eventlet import wsgi
        #worker_pool = eventlet.GreenPool(2000)
        #wsgi.server(eventlet.listen(('', port)), app, custom_pool=worker_pool, log=file('/dev/null', 'w'))
        # max_size
        wsgi.server(eventlet.listen(('', port)), app, max_size=10000, log=file('/dev/null', 'w'))
    elif name =="fapws":
        import fapws._evwsgi as evwsgi
        from fapws import base
        evwsgi.start(host, str(port)) 
        evwsgi.set_base_module(base)
        evwsgi.wsgi_cb(('/', app))
        evwsgi.set_debug(0)        
        evwsgi.run()
    elif name=="uwsgi":
        print ("""Enter this command in the console
                \nsudo uwsgi --http :8000 --master --disable-logging --pythonpath /home/a/g --wsgi-file w.py --listen 2  --buffer-size 2048 --async 10000 --ugreen -p 4
            """)
        #  http://osdir.com/ml/python-wsgi-uwsgi-general/2011-02/msg00136.html
        # 
        #  Re: strange SIGPIPE: writing to a closed pipe/socket/fd on image requested from facebook -msg#00136
        """
SIGPIPE: writing to a closed pipe/socket/fd (probably the client disconnected) on request /1 (ip 127.0.0.1) !!!
uwsgi_response_write_body_do(): Broken pipe [core/writer.c line 260]
IOError: write error
        """
        cmd_txt = "sudo uwsgi --http :8000 --master --harakiri 1 --harakiri-verbose --close-on-exec --disable-logging --pythonpath /home/a/todo/test --wsgi-file w2.py --listen 2  --buffer-size 2048 --async 10000 --ugreen -p 4"
        cmd(cmd_txt)
    elif name=="pycgi":
        from wsgiref.handlers import CGIHandler 
        CGIHandler().run(app)
    elif name=="pystandard":
        from wsgiref.simple_server import make_server
        make_server(host, port, app).serve_forever()

def test_getpeername():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.connect(("localhost", 8000))
        assert(s)
        host, port = s.getpeername()
        assert(host == "127.0.0.1")
        assert(port == 8000)
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_sockname():

    def _test():
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        shost, sport = s.getsockname()
        ms = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        host, port = ms.getsockname()
        assert(host == shost)
        assert(port == sport)
        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_recvfrom():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.connect(("localhost", 8000))
        s.send(b"GET / HTTP/1.0\r\n")
        s.send(b"\r\n")
        c, addr = s.recvfrom(1024)
        assert(len(c) == 135)

        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())

def test_recv_into():

    def _test():
        s = msocket.socket(msocket.AF_INET, msocket.SOCK_STREAM)
        s.connect(("localhost", 8000))
        s.send(b"GET / HTTP/1.0\r\n")
        s.send(b"\r\n")
        buf = array.array('b', [0] *1024)
        r = s.recv_into(buf)
        assert(r == 135)

        server.shutdown()

    server.listen(("0.0.0.0", 8000))
    server.spawn(_test)
    server.run(App())