Python aiopg.create_pool方法代码示例

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def main():
    tornado.options.parse_command_line()

    # Create the global connection pool.
    async with aiopg.create_pool(
        host=options.db_host,
        port=options.db_port,
        user=options.db_user,
        password=options.db_password,
        dbname=options.db_database,
    ) as db:
        await maybe_create_tables(db)
        app = Application(db)
        app.listen(options.port)

        # In this demo the server will simply run until interrupted
        # with Ctrl-C, but if you want to shut down more gracefully,
        # call shutdown_event.set().
        shutdown_event = tornado.locks.Event()
        await shutdown_event.wait() 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def _init(self):

        host = os.environ.get("MF_METADATA_DB_HOST", "localhost")
        port = os.environ.get("MF_METADATA_DB_PORT", 5432)
        user = os.environ.get("MF_METADATA_DB_USER", "postgres")
        password = os.environ.get("MF_METADATA_DB_PSWD", "postgres")
        database_name = os.environ.get("MF_METADATA_DB_NAME", "postgres")

        dsn = "dbname={0} user={1} password={2} host={3} port={4}".format(
            database_name, user, password, host, port
        )
        # todo make poolsize min and max configurable as well as timeout
        # todo add retry and better error message
        retries = 3
        for i in range(retries):
            while True:
                try:
                    self.pool = await aiopg.create_pool(dsn)
                except Exception as e:
                    if retries - i < 1:
                        raise e
                    time.sleep(1)
                    continue
                break 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_release_with_invalid_status(create_pool):
    pool = await create_pool(minsize=10)
    conn = await pool.acquire()
    assert 9 == pool.freesize
    assert {conn} == pool._used
    cur = await conn.cursor()
    await cur.execute('BEGIN')
    cur.close()

    with mock.patch("aiopg.pool.warnings") as m_log:
        pool.release(conn)
    assert 9 == pool.freesize
    assert not pool._used
    assert conn.closed
    m_log.warn.assert_called_with(
        "Invalid transaction status on "
        "released connection: {}".format(TRANSACTION_STATUS_INTRANS),
        ResourceWarning
    ) 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_release_with_invalid_status_wait_release(create_pool):
    pool = await create_pool(minsize=10)
    conn = await pool.acquire()
    assert 9 == pool.freesize
    assert {conn} == pool._used
    cur = await conn.cursor()
    await cur.execute('BEGIN')
    cur.close()

    with mock.patch("aiopg.pool.warnings") as m_log:
        await pool.release(conn)
    assert 9 == pool.freesize
    assert not pool._used
    assert conn.closed
    m_log.warn.assert_called_with(
        "Invalid transaction status on "
        "released connection: {}".format(TRANSACTION_STATUS_INTRANS),
        ResourceWarning
    ) 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_fill_free(create_pool, loop):
    pool = await create_pool(minsize=1)
    with (await pool):
        assert 0 == pool.freesize
        assert 1 == pool.size

        conn = await asyncio.wait_for(pool.acquire(),
                                      timeout=0.5,
                                      loop=loop)
        assert 0 == pool.freesize
        assert 2 == pool.size
        pool.release(conn)
        assert 1 == pool.freesize
        assert 2 == pool.size
    assert 2 == pool.freesize
    assert 2 == pool.size 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_connection_in_good_state_after_timeout(create_pool):
    async def sleep(conn):
        cur = await conn.cursor()
        await cur.execute('SELECT pg_sleep(10);')

    pool = await create_pool(minsize=1,
                             maxsize=1,
                             timeout=0.1)
    with (await pool) as conn:
        with pytest.raises(asyncio.TimeoutError):
            await sleep(conn)

    assert 1 == pool.freesize

    with (await pool) as conn:
        cur = await conn.cursor()
        await cur.execute('SELECT 1;')
        val = await cur.fetchone()
        assert (1,) == val 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_pool_with_connection_recycling(create_pool, loop):
    pool = await create_pool(minsize=1,
                             maxsize=1,
                             pool_recycle=3)
    with (await pool) as conn:
        cur = await conn.cursor()
        await cur.execute('SELECT 1;')
        val = await cur.fetchone()
        assert (1,) == val

    await asyncio.sleep(5, loop=loop)

    assert 1 == pool.freesize
    with (await pool) as conn:
        cur = await conn.cursor()
        await cur.execute('SELECT 1;')
        val = await cur.fetchone()
        assert (1,) == val 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_connection_in_good_state_after_timeout_in_transaction(
        create_pool):
    async def sleep(conn):
        cur = await conn.cursor()
        await cur.execute('BEGIN;')
        await cur.execute('SELECT pg_sleep(10);')

    pool = await create_pool(minsize=1,
                             maxsize=1,
                             timeout=0.1)
    with (await pool) as conn:
        with pytest.raises(asyncio.TimeoutError):
            await sleep(conn)
        conn.close()

    assert 0 == pool.freesize
    assert 0 == pool.size
    with (await pool) as conn:
        async with conn.cursor() as cur:
            await cur.execute('SELECT 1;')
            val = await cur.fetchone()
            assert (1,) == val 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_pool_on_connect(create_pool):
    called = False

    async def cb(connection):
        nonlocal called
        async with connection.cursor() as cur:
            await cur.execute('SELECT 1')
            data = await cur.fetchall()
            assert [(1,)] == data
            called = True

    pool = await create_pool(on_connect=cb)

    with (await pool.cursor()) as cur:
        await cur.execute('SELECT 1')

    assert called 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def test_pool_context_manager_timeout(pg_params, loop):
    async with aiopg.create_pool(**pg_params, minsize=1,
                                 maxsize=1) as pool:
        cursor_ctx = await pool.cursor()
        with pytest.raises(psycopg2.ProgrammingError):
            with cursor_ctx as cursor:
                hung_task = cursor.execute('SELECT pg_sleep(10000);')
                # start task
                fut = loop.create_task(hung_task)
                # sleep for a bit so it gets going
                await asyncio.sleep(1)

        fut.cancel()
        cursor_ctx = await pool.cursor()
        with cursor_ctx as cursor:
            resp = await cursor.execute('SELECT 42;')
            resp = await cursor.fetchone()
            assert resp == (42,)

    assert cursor.closed
    assert pool.closed 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def try_connect_postgres(self, host, user, password, database):
        """Loop forever and attempt to connect to postgres.

        Args:
            host -- the hostname to connect to.
            user -- the username to authenticate as.
            password -- the password to authenticate with.
            database -- the name of the database to use.

        Returns:
            The connected postgres client.
        """

        while True:
            logger.info("Trying to connect to postgres... {}@{}/{}".format(user, host, database))
            logger.debug("loop: {}".format(self.loop))
            try:
                postgres = await aiopg.create_pool(
                        loop=self.loop,
                        host=host,
                        user=user,
                        database=database,
                        password=password)
                logger.info("Successfully connected to postgres")
                return postgres
            except:
                logger.warn("Failed to connect to postgres")
                time.sleep(5) 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def run_aiopg():
    pool = await aiopg.create_pool(dsn, minsize=5, maxsize=5)
    t0 = time.time()
    for i in range(1000):
        async with pool.acquire() as conn:
            async with conn.cursor() as cur:
                await cur.execute("SELECT 1")
                ret = []
                async for row in cur:
                    ret.append(row)
                assert ret == [(1,)]
    print('run_aiopg', time.time() - t0)
    pool.close()
    await pool.wait_closed() 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def run_asyncpg():
    async with asyncpg.create_pool(
            user='rssant', password='rssant',
            database='rssant', host='127.0.0.1',
            command_timeout=60, min_size=5, max_size=5
    ) as pool:
        t0 = time.time()
        for i in range(1000):
            async with pool.acquire() as conn:
                values = await conn.fetch("SELECT 1")
                assert values == [(1,)]
        print('run_asyncpg', time.time() - t0)
    await pool.close() 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def _init(self):

        host = os.environ.get("MF_METADATA_DB_HOST", "localhost")
        port = os.environ.get("MF_METADATA_DB_PORT", 5432)
        user = os.environ.get("MF_METADATA_DB_USER", "postgres")
        password = os.environ.get("MF_METADATA_DB_PSWD", "postgres")
        database_name = os.environ.get("MF_METADATA_DB_NAME", "postgres")

        dsn = "dbname={0} user={1} password={2} host={3} port={4}".format(
            database_name, user, password, host, port
        )
        # todo make poolsize min and max configurable as well as timeout
        # todo add retry and better error message
        retries = 3
        for i in range(retries):
            while True:
                try:
                    self.pool = await aiopg.create_pool(dsn)
                    for table in self.tables:
                        await table._init()
                except Exception as e:
                    if retries - i < 1:
                        raise e
                    time.sleep(1)
                    continue
                break 

# 需要导入模块: import aiopg [as 别名]
# 或者: from aiopg import create_pool [as 别名]
def _connect(self):
        conn_kwargs = {
            "database": self.database,
        }

        conn_kwargs.update(self.connect_params)
        if 'passwd' in conn_kwargs:
            conn_kwargs['password'] = conn_kwargs.pop('passwd')
        if "db" in conn_kwargs:
            conn_kwargs["database"] = conn_kwargs.pop("db")
        if "maxsize" not in conn_kwargs:
            conn_kwargs["maxsize"] = 32
        return aiopg.create_pool(None, **conn_kwargs)