def create_store(cls, address, namespace=None, pool_size=2, **kw):
     if cls.redis_py_parser:
         kw['parser_class'] = redis_parser(True)
     if not namespace:
         namespace = cls.randomkey(6).lower()
     return create_store(address, namespace=namespace,
                         pool_size=pool_size, **kw)

 def setup(self, environ):
     cfg = environ['pulsar.cfg']
     self.store = create_store(cfg.data_store)
     pubsub = self.store.pubsub()
     return WsgiHandler([Router('/', get=self.home_page),
                         WebSocket('/message',
                                   TweetsWsHandler(pubsub, self.channel))])

 def __init__(self, app, name, url):
     super().__init__(app, name, url)
     if app.green_pool:
         self._wait = app.green_pool.wait
         self.client = create_store(url).client()
     else:
         import redis
         self.client = redis.StrictRedis.from_url(url)

    def monitor_start(self, monitor):
        '''When the monitor starts load all test classes into the queue'''
        # Create a datastore for this test suite
        if not self.cfg.task_backend:
            server = PulsarDS(bind='127.0.0.1:0', workers=0,
                              key_value_save=[],
                              name='%s_store' % self.name)
            yield server()
            address = 'pulsar://%s:%s' % server.cfg.addresses[0]
        else:
            address = self.cfg.task_backend

        store = create_store(address, pool_size=2, loop=monitor._loop)
        self.get_backend(store)
        loader = self.loader
        tags = self.cfg.labels
        exclude_tags = self.cfg.exclude_labels
        if self.cfg.show_leaks:
            show = show_leaks if self.cfg.show_leaks == 1 else hide_leaks
            self.cfg.set('when_exit', show)
            arbiter = pulsar.arbiter()
            arbiter.cfg.set('when_exit', show)
        try:
            tests = []
            loader.runner.on_start()
            for tag, testcls in loader.testclasses(tags, exclude_tags):
                suite = loader.runner.loadTestsFromTestCase(testcls)
                if suite and suite._tests:
                    tests.append((tag, testcls))
            self._time_start = None
            if tests:
                self.logger.info('loading %s test classes', len(tests))
                monitor.cfg.set('workers', min(self.cfg.workers, len(tests)))
                self._time_start = default_timer()
                queued = []
                self._tests_done = set()
                self._tests_queued = None
                #
                # Bind to the task_done event
                self.backend.bind_event('task_done',
                                        partial(self._test_done, monitor))
                for tag, testcls in tests:
                    r = self.backend.queue_task('test', testcls=testcls,
                                                tag=tag)
                    queued.append(r)
                queued = yield multi_async(queued)
                self.logger.debug('loaded %s test classes', len(tests))
                self._tests_queued = set(queued)
                yield self._test_done(monitor)
            else:   # pragma    nocover
                raise ExitTest('Could not find any tests.')
        except ExitTest as e:   # pragma    nocover
            monitor.stream.writeln(str(e))
            monitor.arbiter.stop()
        except Exception:   # pragma    nocover
            monitor.logger.critical('Error occurred while starting tests',
                                    exc_info=True)
            monitor._loop.call_soon(self._exit, 3)

 def on_loaded(self, app):
     '''Once the application has loaded, create the pub/sub
     handler used to publish messages to channels as
     well as subscribe to channels
     '''
     pubsub_store = app.config['PUBSUB_STORE']
     if pubsub_store:
         self.pubsub_store = create_store(pubsub_store)
         self.websocket.pubsub = self.pubsub_store.pubsub()

 def __init__(self, app, scheme, url):
     super().__init__(app, scheme, url)
     if app.green_pool:
         from pulsar.apps.greenio import wait
         self._wait = wait
         self.client = create_store(url).client()
     else:
         import redis
         self.client = redis.StrictRedis.from_url(url)

 def __init__(self, cfg, logger=None, app=None, **kw):
     self.store = create_store(cfg.data_store)
     self.cfg = cfg
     self.app = app
     self.green_pool = getattr(app, 'green_pool', GreenPool())
     self.logger = logger or logging.getLogger('pulsar.queue')
     self._closing = False
     self._pubsub = PubSub(self)
     self.logger.debug('created %s', self)

 def create_database(self, dbname=None, **kw):
     dbname = dbname or self.database
     store = create_store(self.dns, database='postgres', loop=self._loop)
     conn = store.sql_engine.connect()
     # when creating a database the connection must not be in a transaction
     conn.execute("commit")
     conn.execute("create database %s" % dbname)
     conn.close()
     return dbname

 def get_pubsub(self, websocket):
     if not self._store:
         cfg = websocket.cfg
         self._store = create_store(cfg.data_store, namespace='game_')
         self._client = self._store.client()
         self._pubsub = self._store.pubsub()
         gameserver = '%s:gameserver' % cfg.exc_id
         gameuser = '%s:gameuser' % cfg.exc_id
         yield from self._pubsub.subscribe(gameserver, gameuser)

 def get_pubsub(self, websocket):
     if not self._store:
         cfg = websocket.cfg
         self._store = create_store(cfg.data_store)
         self._client = self._store.client()
         self._pubsub = self._store.pubsub()
         webchat = '%s:webchat' % cfg.exc_id
         chatuser = '%s:chatuser' % cfg.exc_id
         yield from self._pubsub.subscribe(webchat, chatuser)
     return self._pubsub

 def get_pubsub(self, websocket):
     '''Create the pubsub handler if not already available'''
     if not self._store:
         cfg = websocket.cfg
         self._store = create_store(cfg.data_store)
         self._client = self._store.client()
         self._pubsub = self._store.pubsub()
         webchat = '%s:webchat' % cfg.exc_id
         chatuser = '%s:chatuser' % cfg.exc_id
         self._pubsub.subscribe(webchat, chatuser)
     return self._pubsub

async def start_store(app, url, workers=0, **kw):
    '''Equivalent to :func:`.create_store` for most cases excepts when the
    ``url`` is for a pulsar store not yet started.
    In this case, a :class:`.PulsarDS` is started.
    '''
    store = create_store(url, **kw)
    if store.name == 'pulsar':
        client = store.client()
        try:
            await client.ping()
        except ConnectionRefusedError:
            host = localhost(store._host)
            if not host:
                raise
            cfg = await send('arbiter', 'run', start_pulsar_ds,
                             host, workers)
            store._host = cfg.addresses[0]
            dns = store._buildurl()
            store = create_store(dns, **kw)
    app.cfg.set('data_store', store.dns)

 def delete_database(self, dbname=None):
     # make sure no connections are opened
     self.sql_engine.dispose()
     dbname = dbname or self.database
     # switch to postgres database
     store = create_store(self.dns, database='postgres', loop=self._loop)
     conn = store.sql_engine.connect()
     conn.execute("commit")
     conn.execute("drop database %s" % dbname)
     conn.close()
     return dbname

 def start_store(url, workers=0, **kw):
     '''Equivalent to :func:`.create_store` for most cases excepts when the
     ``url`` is for a pulsar store not yet started.
     In this case, a :class:`.PulsarDS` is started.
     '''
     store = create_store(url, **kw)
     if store.name == 'pulsar':
         client = store.client()
         try:
             yield client.ping()
         except pulsar.ConnectionRefusedError:
             host = localhost(store._host)
             if not host:
                 raise
             cfg = yield send('arbiter', 'run', start_pulsar_ds,
                              host, workers)
             store._host = cfg.addresses[0]
             dns = store._buildurl()
             store = create_store(dns, **kw)
     coroutine_return(store)

def check_redis():
    '''Check if redis server is available at the address specified
    by the :ref:`redis server <setting-redis_server>` config value.

    :rtype: boolean
    '''
    addr = get_actor().cfg.get('redis_server')
    sync_store = create_store(addr, loop=new_event_loop())
    try:
        sync_store.client().ping()
        return True
    except Exception:
        return False

    def _autodiscover(self, binds):
        # Setup mdoels and engines
        if not binds:
            binds = {}
        elif isinstance(binds, str):
            binds = {'default': binds}
        if binds and 'default' not in binds:
            raise ImproperlyConfigured('default datastore not specified')

        self.metadata = MetaData()
        self._engines = {}
        self._nosql_engines = {}
        self._declarative_register = {}
        self.binds = {}
        # Create all sql engines in the binds dictionary
        # Quietly fails if the engine is not recognised,
        # it my be a NoSQL store
        for name, bind in tuple(binds.items()):
            key = None if name == 'default' else name
            try:
                self._engines[key] = create_engine(bind)
            except exc.NoSuchModuleError:
                self._nosql_engines[key] = create_store(bind)
        #
        if self._nosql_engines and not self.app.green_pool:
            raise ImproperlyConfigured('NoSql stores requires GREEN_POOL')

        for label, mod in module_iterator(self.app.config['EXTENSIONS']):
            # Loop through attributes in mod_models
            for name in dir(mod):
                value = getattr(mod, name)
                if isinstance(value, (Table, DeclarativeMeta)):
                    for table in value.metadata.sorted_tables:
                        if table.key not in self.metadata.tables:
                            engine = None
                            label = table.info.get('bind_label')
                            keys = ('%s.%s' % (label, table.key),
                                    label, None) if label else (None,)
                            for key in keys:
                                engine = self.get_engine(key)
                                if engine:
                                    break
                            assert engine
                            table.tometadata(self.metadata)
                            self.binds[table] = engine
                    if (isinstance(value, DeclarativeMeta) and
                            hasattr(value, '__table__')):
                        table = value.__table__
                        self._declarative_register[table.key] = value

    def setup(self, environ):
        '''Called once only to setup the WSGI application handler.

        Check :ref:`lazy wsgi handler <wsgi-lazy-handler>`
        section for further information.
        '''
        cfg = environ['pulsar.cfg']
        loop = environ['pulsar.connection']._loop
        self.store = create_store(cfg.data_store, loop=loop)
        pubsub = self.store.pubsub(protocol=Protocol())
        channel = '%s_webchat' % self.name
        pubsub.subscribe(channel)
        return WsgiHandler([Router('/', get=self.home_page),
                            WebSocket('/message', Chat(pubsub, channel)),
                            Router('/rpc', post=Rpc(pubsub, channel))])

    def setup(self, environ):
        '''Called once only to setup the WSGI application handler.

        Check :ref:`lazy wsgi handler <wsgi-lazy-handler>`
        section for further information.
        '''
        cfg = environ['pulsar.cfg']
        loop = environ['pulsar.connection']._loop
        self.store = data.create_store(cfg.data_store, loop=loop)
        pubsub = self.store.pubsub(protocol=WsProtocol())
        channel = '%s_messages' % self.name
        pubsub.subscribe(channel)
        middleware = [wsgi.Router('/', get=self.home_page),
                      ws.WebSocket('/message', PhilosopherWs(pubsub, channel)),
                      wsgi.FileRouter('/favicon.ico', FAVICON),
                      wsgi.MediaRouter('media', ASSET_DIR)]
        return wsgi.WsgiHandler(middleware)

def check_server(name):
    '''Check if server ``name`` is available at the address specified
    ``<name>_server`` config value.

    :rtype: boolean
    '''
    cfg = get_actor().cfg
    cfgname = '%s_server' % name
    addr = cfg.get('%s_server' % name)
    if ('%s://' % name) not in addr:
        addr = '%s://%s' % (name, addr)
    sync_store = create_store(addr, loop=new_event_loop())
    try:
        sync_store.ping()
        return True
    except Exception:
        return False

    def setup(self, environ):
        '''Called once only by the WSGI server.

        It returns a :class:`.WsgiHandler` with three routes:

        * The base route served by the :meth:`home_page` method
        * The websocket route
        * A route for static files
        '''
        cfg = environ['pulsar.cfg']
        # Create the store and the pubsub handler
        self.store = create_store(cfg.data_store)
        pubsub = self.store.pubsub()
        # subscribe to channel
        ensure_future(self.subscribe(pubsub))
        return WsgiHandler([Router('/', get=self.home_page),
                            MediaRouter('/static', STATIC_DIR),
                            WebSocket('/message',
                                      TweetsWsHandler(pubsub, self.channel))])