def greenify():
    """Patch threading and psycopg2 modules for green threads."""
    from gevent.monkey import patch_all, saved
    if ('threading' in sys.modules) and ('threading' not in saved):
        raise Exception('threading module loaded before patching!')
    patch_all()

    from psycogreen.gevent import patch_psycopg
    patch_psycopg()

def postfork(server, worker):
    # Make sure any lazily initialized SQLAlchemy state, notably the
    # `returns_unicode_strings` flag on the engine's `Dialect`, is initialized
    # before we start accepting requests. Otherwise, some requests could start
    # making queries before the initialization was complete, and those queries
    # would observe the incorrect, uninitialized values for certain
    # engine/dialect state variables, leading to errors.
    angular_momentum.db.get_engine().connect().close()

    from psycogreen.gevent import patch_psycopg

    patch_psycopg()

    def handle(self, addrport='', *args, **options):
        if not addrport:
            self.addr = ''
            self.port = DEFAULT_PORT
        else:
            m = match(naiveip_re, addrport)
            if m is None:
                raise CommandError('"%s" is not a valid port number '
                                   'or address:port pair.' % addrport)
            self.addr, _, _, _, self.port = m.groups()

        environ['DJANGO_SOCKETIO_PORT'] = str(self.port)

        if options.get('use_psyco'):
            try:
                from psycogreen.gevent import patch_psycopg
            except ImportError:
                raise CommandError(
                    'Could not patch psycopg. '
                    'Is psycogreen installed?')
            patch_psycopg()

        if options.get('use_reloader'):
            start_new_thread(reload_watcher, ())

        try:
            bind = (self.addr, int(self.port))
            print 'SocketIOServer running on %s:%s\n\n' % bind
            handler = self.get_handler(*args, **options)
            server = SocketIOServer(
                bind, handler, resource='socket.io', policy_server=True)
            server.serve_forever()
        except KeyboardInterrupt:
            socks = []
            for key, sock in six.iteritems(server.sockets):
                socks.append(sock)
            for sock in socks:
                sock.kill(detach=True)
            server.stop()
            if RELOAD:
                print 'Reloading...\n\n'
                restart_with_reloader()

def greenify():
    """Patch threading and psycopg2 modules for green threads."""
    # don't greenify twice.
    if _GREEN:
        return
    _GREEN[True] = True

    from gevent.monkey import patch_all, saved
    if ('threading' in sys.modules) and ('threading' not in saved):
        raise Exception('threading module loaded before patching!')
    patch_all()

    from psycogreen.gevent import patch_psycopg
    patch_psycopg()

    try:
        # Use psycopg2 by default
        import psycopg2
        del psycopg2
    except ImportError:
        # Fallback to psycopg2cffi if required (eg: pypy)
        from psycopg2cffi import compat
        compat.register()

import sqlalchemy as sql
from sqlalchemy import or_
import bottle_sqlalchemy as sqlalchemy
from sqlalchemy import create_engine, Column, Sequence
from sqlalchemy.ext.declarative import declarative_base
import psycopg2, random, urllib, os
from bin.utils import isInt, gen_string
from dataobjects import Debug

from datetime import datetime

from gevent import monkey
monkey.patch_all()
from psycogreen.gevent import patch_psycopg
patch_psycopg()

Base = declarative_base()

class Postgres():
    def __init__(self, cfg, app):
        self._cfg = cfg
        self._db_host = self._cfg.get('Postgres', 'host')
        self._db_port = self._cfg.get('Postgres', 'port')
        self._db_database = self._cfg.get('Postgres', 'db')
        self._db_user = self._cfg.get('Postgres', 'user')
        self._db_pass = self._cfg.get('Postgres', 'pass')

        self.engine = create_engine('postgresql+psycopg2://%s:%[email protected]%s:%s/%s' % (
            self._db_user,
            self._db_pass,
            self._db_host,

def pre_fork(server, worker):
    patch_psycopg()
    worker.log.info('Patched psycopg with gevent support')

def post_fork(server, worker):
    from psycogreen.gevent import patch_psycopg
    patch_psycopg()
    worker.log.info("Made psycopg Green")

def post_fork(server, worker):
    from psycogreen.gevent import patch_psycopg
    patch_psycopg()

#!/usr/bin/env python
import os
import sys
from gevent import monkey#; monkey.patch_all()
monkey.patch_os()
monkey.patch_time()
monkey.patch_thread( _threading_local=False)
monkey.patch_sys()
monkey.patch_socket()
monkey.patch_select()
monkey.patch_ssl()
monkey.patch_subprocess()

from psycogreen.gevent import patch_psycopg; patch_psycopg();

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "geventpooltest.settings")

    from django.core.management import execute_from_command_line

    execute_from_command_line(sys.argv)

 def post_fork(server, worker):
     patch_psycopg()

def post_fork(server, worker):
    patch_psycopg()
    worker.log.info("Made Psycopg2 Green")
    server.log.info("Worker spawned (pid: %s)", worker.pid)

def post_fork(server, worker):
    os.environ["GEVENT_RESOLVER"] = "ares"
    from psycogreen.gevent import patch_psycopg
    patch_psycopg()

def patch():
    # Patch all the things that gevent knows about.
    patch_all()

    # Patch psycopg2 to also be gevent friendly.
    patch_psycopg()

def post_fork(server, worker):
    """
    https://github.com/jneight/django-db-geventpool
    """
    patch_psycopg()
    worker.log.info("Made Psycopg2 Green")