Exemplo n.º 1
0
 async def _make_connection():
     try:
         self.connection = AsyncDB('pg', dsn=default_dsn)
         await self.connection.connection()
     except Exception as err:
         print(err)
         raise Exception(err)
Exemplo n.º 2
0
async def test_connect(driver, params, event_loop):
    db = AsyncDB(driver, params=params, loop=event_loop)
    await db.connection()
    print('CONNECTED: ', db.is_connected() is True)
    result, error = await db.test_connection()
    print(result, error)
    print(type(result) == list)
    db.use('library')  # set database to work
    # # making a simple query:
    # result, error = await db.query('SELECT * from events')
    # print(error)
    # for row in result:
    #     print(row)
    # creation and insertion:
    await db.execute("CREATE TABLE tests (id int, name text, PRIMARY KEY(id))")
    ql = "INSERT INTO tests (id, name) VALUES(?, ?)"
    # prepare the statement:
    prepared, error = await db.prepare(ql)
    print(": prepare the statement: ", prepared)
    print(": Executing Insert of many entries: ")
    result, error = await db.execute(prepared, (2, "def"))
    result, error = await db.execute(prepared, (3, "ghi"))
    result, error = await db.execute(prepared, (4, "jkl"))
    examples = [(5, "mno"), (6, "pqr"), (7, "stu")]
    for example in examples:
        result, error = await db.execute(prepared, example)
        print(result, error)
    result, error = await db.query("SELECT * FROM tests")
    for row in result:
        print(row)
    await db.close()
Exemplo n.º 3
0
 def get_connection(self, dsn: str = None):
     """
     Getting the database connection and driver based on parameters
     """
     driver = self.Meta.driver if self.Meta.driver else "pg"
     if driver:
         # logging.debug('Getting data from Database: {}'.format(driver))
         # working with app labels
         try:
             app = self.Meta.app_label if self.Meta.app_label else None
         except AttributeError:
             app = None
         if app:
             # TODO: get formula to got app database list
             # db = DATABASES[app]
             db = {}
             try:
                 params = {
                     "user": db["USER"],
                     "password": db["PASSWORD"],
                     "host": db["HOST"],
                     "port": db["PORT"],
                     "database": db["NAME"],
                 }
                 if "SCHEMA" in db:
                     params["schema"] = db["SCHEMA"]
             except KeyError:
                 pass
         elif hasattr(self.Meta, "credentials"):
             params = self.Meta.credentials
             self.Meta.connection = AsyncDB(driver, params=params)
         elif dsn is not None:
             # print('HERE ', dsn)
             self.Meta.connection = AsyncDB(driver, dsn=dsn)
         return self.Meta.connection
Exemplo n.º 4
0
async def test_pool_by_params(driver, event_loop):
    db = AsyncDB(driver, params=params, loop=event_loop)
    assert db.is_connected() is False
    await db.connection()
    pytest.assume(db.is_connected() is True)
    await db.close()
    assert db.is_closed() is True
Exemplo n.º 5
0
async def test_connect(driver, event_loop):
    db = AsyncDB(driver, params=params, loop=event_loop)
    await db.connection()
    pytest.assume(db.is_connected() is True)
    result, error = await db.test_connection()
    pytest.assume(type(result) == list)
    await db.close()
Exemplo n.º 6
0
async def test_connect(driver, event_loop):
    db = AsyncDB(driver, params=params, loop=event_loop)
    await db.connection()
    pytest.assume(db.is_connected() is True)
    result, error = await db.test_connection('bigtest')
    pytest.assume(not error)
    assert result == 'bigtest'
    await db.close()
Exemplo n.º 7
0
async def test_connect(driver, params, event_loop):
    db = AsyncDB(driver, params=params, loop=event_loop)
    await db.connection()
    print('CONNECTED: ', db.is_connected() is True)
    result, error = await db.test_connection()
    print(result, error)
    print(type(result) == list)
    await db.close()
Exemplo n.º 8
0
def adb():
    try:
        db = AsyncDB('postgres', dsn=asyncpg_url)
        if db:
            db.connect()
        return asyncORM(db=db)
    except Exception as err:
        raise Exception(err)
Exemplo n.º 9
0
    def create_problem_data(proid):
        db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                     config.MOD_DBPASSWORD)

        cur = db.cursor()
        sqlstr = ('INSERT INTO "PMOD_TEST_MODE" ("proid", "modeid", '
                  '"content", "testmodeid") VALUES (%s, %s, %s, %s);')
        sqlarr = (proid, 1, '', None)
        cur.execute(sqlstr, sqlarr)        
Exemplo n.º 10
0
async def test_connect(driver, event_loop):
    db = AsyncDB(driver, params=PARAMS, loop=event_loop)
    await db.connection()
    pytest.assume(db.is_connected() is True)
    result, error = await db.test_connection()
    pytest.assume(type(result) == dict)
    pytest.assume(result['version'] == '4.4.2')
    await db.close()
    pytest.assume(db.is_connected() is False)
Exemplo n.º 11
0
async def test_connect(driver, event_loop):
    db = AsyncDB(driver, params=PARAMS, loop=event_loop)
    await db.connection()
    pytest.assume(db.is_connected() is True)
    result, error = await db.test_connection()
    pytest.assume(type(result) == list)
    row = result[0]
    pytest.assume(row['release_version'] == '3.11.8')
    await db.close()
    pytest.assume(db.is_connected() is False)
    def __init__(self,mod_idendesc,get_link_fn):
        self.DATATYPE_CHALLENGE = 1
        self.DATATYPE_STATUS = 2

        self.DATASTSTUS_PEND = 1
        self.DATASTSTUS_WAIT = 2
        self.DATASTSTUS_DONE = 3

        self._idendesc = mod_idendesc
        self.get_link = get_link_fn
        self.db = AsyncDB(config.CORE_DBNAME,config.CORE_DBUSER,
                          config.CORE_DBPASSWORD)

        self.collector_namemap = {}
Exemplo n.º 13
0
async def test_pool_connect(event_loop):
    db = AsyncDB(DRIVER, params=params, loop=event_loop)
    pytest.assume(db.is_connected() is False)
    await db.connection()
    pytest.assume(db.is_connected() == True)
    result, error = await db.execute("SELECT 1")
    print(result)
    pytest.assume(result == 'SELECT 1')
    result, error = await db.test_connection()
    print(result, error)
    row = result[0]
    pytest.assume(row[0] == 1)
    await db.close()
    assert (not db.get_connection())
Exemplo n.º 14
0
    def __init__(self, mod_idendesc, get_link_fn, proid):
        self._proid = proid
        self._idendesc = mod_idendesc
        self.get_link = get_link_fn

        self._proinfo = mod.ProblemMg.get_problem_info_by_proid(self._proid)
        self._accessid = mod.ProblemMg.get_accessid_by_proid(self._proid)

        self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                          config.MOD_DBPASSWORD)

        self._reg_path = 'pro/' + str(self._proid) + '/'

        Proxy.instance.register_call(
            self._reg_path, 'view', self.view)
        Proxy.instance.register_call(
            self._reg_path, 'add_mode', self.add_mode)
        Proxy.instance.register_call(
            self._reg_path, 'del_mode', self.del_mode)
        Proxy.instance.register_call(
            self._reg_path, 'set_mode', self.set_mode)
        Proxy.instance.register_call(
            self._reg_path, 'get_mode', self.get_mode)
        Proxy.instance.register_call(
            self._reg_path, 'list_mode', self.list_mode)
        Proxy.instance.register_call(
            self._reg_path, 'add_testmode', self.add_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'del_testmode', self.del_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'set_testmode', self.set_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'get_testmode', self.get_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'list_testmode', self.list_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'create_testdata', self.create_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'delete_testdata', self.delete_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'get_testdata', self.get_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'list_testdata', self.list_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'set_testdata', self.set_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'set_testmode_testdata', self.set_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'get_testmode_testdata', self.get_testdata)
Exemplo n.º 15
0
    def delete_problem_data(proid):
        db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                     config.MOD_DBPASSWORD)

        cur = db.cursor()
        sqlstr = ('DELETE FROM "PMOD_TEST_MODE" WHERE "proid" = %s;')
        sqlarr = (proid, )
        cur.execute(sqlstr, sqlarr)

        sqlstr = ('DELETE FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s;')
        sqlarr = (proid, )
        cur.execute(sqlstr, sqlarr)

        sqlstr = ('DELETE FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s;')
        sqlarr = (proid, )
        cur.execute(sqlstr, sqlarr)
Exemplo n.º 16
0
    def __init__(self, mod_idendesc, get_link_fn, sqid):
        self._sqid = sqid
        self._idendesc = mod_idendesc
        self.get_link = get_link_fn

        self._accessid = mod.SquareMg.get_accessid_by_sqid(self._sqid)

        self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER,
                          config.MOD_DBPASSWORD)

        self._reg_path = 'sq/' + str(self._sqid) + '/'

        Proxy.instance.register_call(self._reg_path, 'list_jurank',
                                     self.list_jurank)
        Proxy.instance.register_call(self._reg_path, 'update_result',
                                     self.update_result)
    def __init__(self, pubkey, privkey=None):
        super().__init__()

        self.set_verifykey(pubkey)
        if privkey != None:
            self.set_signkey(privkey)

        TOJAuth.instance = self
        TOJAuth.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
                             config.CORE_DBPASSWORD)
Exemplo n.º 18
0
async def test_huge_query(event_loop):
    sql = 'SELECT * FROM trocplaces.stores'
    check_conn = None
    db = AsyncDB(DRIVER, params=params, loop=event_loop)
    async with await db.connection() as conn:
        result, error = await conn.execute("SET TIMEZONE TO 'America/New_York'")
        pytest.assume(not error)
        result, error = await conn.query(sql)
        pytest.assume(not error)
        pytest.assume(result is not None)
        check_conn = conn
    pytest.assume(check_conn is not None)
Exemplo n.º 19
0
 def __init__(self, dsn="", session: AbstractSession = None, loop=None):
     if loop:
         self._loop = loop
     else:
         self._loop = asyncio.get_event_loop()
     self._result = {}
     self._session_key = ""
     self._session_id = None
     self._loop.set_exception_handler(nav_exception_handler)
     # TODO: define other session backend
     self._cache = redis = AsyncDB("redis", dsn=dsn)
     self._session = session
    def __init__(self, mod_idendesc, get_link_fn):
        TestdataMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
                                config.CORE_DBPASSWORD)
        TestdataMg._idendesc = mod_idendesc
        self.get_link = get_link_fn

        Proxy.instance.register_call('core/testdata/', 'add_testdata',
                                     self.add_testdata)
        Proxy.instance.register_call('core/testdata/', 'update_testdata',
                                     self.update_testdata)
        Proxy.instance.register_call('core/testdata/', 'get_testdata',
                                     self.get_testdata)
        Proxy.instance.register_call('core/testdata/', 'del_testdata',
                                     self.del_testdata)
    def __init__(self, mod_idendesc, get_link_fn):
        Notice.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
                            config.CORE_DBPASSWORD)
        Notice._idendesc = mod_idendesc
        self.get_link = get_link_fn

        Proxy.instance.register_call('core/notice/', 'list_notice',
                                     self.list_notice)
        Proxy.instance.register_call('core/notice/', 'read_notice',
                                     self.read_notice)
        Proxy.instance.register_call('core/notice/', 'del_notice',
                                     self.del_notice)
        Proxy.instance.register_call('core/notice/', 'get_unseen_count',
                                     self.get_unseen_count)
    def __init__(self, mod_idendesc, get_link_fn, sqid):
        self._sqid = sqid;
        self._idendesc = mod_idendesc
        self.get_link = get_link_fn
        
        self._accessid = mod.SquareMg.get_accessid_by_sqid(self._sqid)

        self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                          config.MOD_DBPASSWORD)

        self._reg_path = 'sq/' + str(self._sqid) + '/'

        Proxy.instance.register_call(
            self._reg_path,'list_jurank',self.list_jurank)
        Proxy.instance.register_call(
            self._reg_path,'update_result',self.update_result)
Exemplo n.º 23
0
    def __init__(self, mod_idendesc, get_link_fn):
        Mail.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER, 
                config.CORE_DBPASSWORD)
        Mail._idendesc = mod_idendesc
        self.get_link = get_link_fn

        Proxy.instance.register_call(
            'core/mail/', 'send_mail', self.send_mail)
        Proxy.instance.register_call(
            'core/mail/', 'recv_mail', self.recv_mail)
        Proxy.instance.register_call(
            'core/mail/', 'list_mail', self.list_mail)
        Proxy.instance.register_call(
            'core/mail/', 'del_mail', self.del_mail)
        Proxy.instance.register_call(
            'core/mail/', 'get_mail_count', self.get_mail_count)
Exemplo n.º 24
0
    def __init__(self, mod_idendesc, get_link_fn):
        UserMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER, 
                config.CORE_DBPASSWORD)
        UserMg._idendesc = mod_idendesc
        self.get_link = get_link_fn

        Proxy.instance.register_call(
            'core/user/', 'register', self.register)
        Proxy.instance.register_call(
            'core/user/', 'login', self.login)
        Proxy.instance.register_call(
            'core/user/', 'cookie_login', self.cookie_login)
        Proxy.instance.register_call(
            'core/user/', 'get_user_info', self.get_user_info)
        Proxy.instance.register_call(
            'core/user/', 'set_user_info', self.set_user_info)
        Proxy.instance.register_call(
            'core/user/', 'change_user_password', self.change_user_password)
        Proxy.instance.register_call(
            'core/user/', 'list_auth', self.list_auth)
    def __init__(self, mod_idendesc, get_link_fn):
        ProblemMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
                               config.CORE_DBPASSWORD)
        ProblemMg._idendesc = mod_idendesc
        self.get_link = get_link_fn
        self._pmod_list = {}

        Proxy.instance.register_filter('pro/', self.pmod_filter)

        Proxy.instance.register_call('core/problem/', 'create_problem',
                                     self.create_problem)
        Proxy.instance.register_call('core/problem/', 'delete_problem',
                                     self.delete_problem)
        Proxy.instance.register_call('core/problem/', 'set_problem',
                                     self.imc_set_problem)
        Proxy.instance.register_call('core/problem/', 'list_problem',
                                     self.list_problem)
        Proxy.instance.register_call('core/problem/', 'get_problem_info',
                                     self.get_problem_info)
        Proxy.instance.register_call('core/problem/', 'list_pmod',
                                     self.list_pmod)
Exemplo n.º 26
0
class pmod_test(Problem):
    _pmod_name = 'pmod_test'

    def __init__(self, mod_idendesc, get_link_fn, proid):
        self._proid = proid
        self._idendesc = mod_idendesc
        self.get_link = get_link_fn

        self._proinfo = mod.ProblemMg.get_problem_info_by_proid(self._proid)
        self._accessid = mod.ProblemMg.get_accessid_by_proid(self._proid)

        self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                          config.MOD_DBPASSWORD)

        self._reg_path = 'pro/' + str(self._proid) + '/'

        Proxy.instance.register_call(
            self._reg_path, 'view', self.view)
        Proxy.instance.register_call(
            self._reg_path, 'add_mode', self.add_mode)
        Proxy.instance.register_call(
            self._reg_path, 'del_mode', self.del_mode)
        Proxy.instance.register_call(
            self._reg_path, 'set_mode', self.set_mode)
        Proxy.instance.register_call(
            self._reg_path, 'get_mode', self.get_mode)
        Proxy.instance.register_call(
            self._reg_path, 'list_mode', self.list_mode)
        Proxy.instance.register_call(
            self._reg_path, 'add_testmode', self.add_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'del_testmode', self.del_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'set_testmode', self.set_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'get_testmode', self.get_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'list_testmode', self.list_testmode)
        Proxy.instance.register_call(
            self._reg_path, 'create_testdata', self.create_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'delete_testdata', self.delete_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'get_testdata', self.get_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'list_testdata', self.list_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'set_testdata', self.set_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'set_testmode_testdata', self.set_testdata)
        Proxy.instance.register_call(
            self._reg_path, 'get_testmode_testdata', self.get_testdata)

    def unload(self, force):
        Proxy.instance.unregister_call(
            self._reg_path, 'view')
        Proxy.instance.unregister_call(
            self._reg_path, 'add_mode')
        Proxy.instance.unregister_call(
            self._reg_path, 'del_mode')
        Proxy.instance.unregister_call(
            self._reg_path, 'set_mode')
        Proxy.instance.unregister_call(
            self._reg_path, 'get_mode')
        Proxy.instance.unregister_call(
            self._reg_path, 'list_mode')
        Proxy.instance.unregister_call(
            self._reg_path, 'add_testmode')
        Proxy.instance.unregister_call(
            self._reg_path, 'del_testmode')
        Proxy.instance.unregister_call(
            self._reg_path, 'set_testmode')
        Proxy.instance.unregister_call(
            self._reg_path, 'get_testmode')
        Proxy.instance.unregister_call(
            self._reg_path, 'create_testdata')
        Proxy.instance.unregister_call(
            self._reg_path, 'delete_testdata')
        Proxy.instance.unregister_call(
            self._reg_path, 'get_testdata')
        Proxy.instance.unregister_call(
            self._reg_path, 'list_testdata')
        Proxy.instance.unregister_call(
            self._reg_path, 'set_testdata')
        Proxy.instance.unregister_call(
            self._reg_path, 'set_testmode_testdata')
        Proxy.instance.unregister_call(
            self._reg_path, 'get_testmode_testdata')

    @staticmethod
    @TOJAuth.check_access(mod.ProblemMg._accessid, TOJAuth.ACCESS_CREATE)
    def create_problem_data(proid):
        db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                     config.MOD_DBPASSWORD)

        cur = db.cursor()
        sqlstr = ('INSERT INTO "PMOD_TEST_MODE" ("proid", "modeid", '
                  '"content", "testmodeid") VALUES (%s, %s, %s, %s);')
        sqlarr = (proid, 1, '', None)
        cur.execute(sqlstr, sqlarr)        

    @staticmethod
    @TOJAuth.check_access(mod.ProblemMg._accessid, TOJAuth.ACCESS_DELETE)
    def delete_problem_data(proid):
        db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                     config.MOD_DBPASSWORD)

        cur = db.cursor()
        sqlstr = ('DELETE FROM "PMOD_TEST_MODE" WHERE "proid" = %s;')
        sqlarr = (proid, )
        cur.execute(sqlstr, sqlarr)

        sqlstr = ('DELETE FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s;')
        sqlarr = (proid, )
        cur.execute(sqlstr, sqlarr)

        sqlstr = ('DELETE FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s;')
        sqlarr = (proid, )
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def view(self):
        with TOJAuth.change_current_iden(self._idendesc):
            mode = self._get_mode_by_modeid(1)

            if mode == None:
                return 'Emodeid'

            testmode = self._get_testmode_info(mode['testmodeid'])

        ret = {
            'content':mode['content'],
            'timelimit':testmode['timelimit'],
            'memlimit':testmode['memlimit']
        }

        return ret

    @imc.async.caller
    def add_mode(self, content, testmodeid):
        if(
            (content != None and type(content) != str) or
            (testmodeid != None and type(testmodeid) != int)
        ):
            return 'Eparameter'

        if testmodeid != None and not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        self._add_mode(None, content, testmodeid)

        return 'Success'

    def _add_mode(self, modeid, content, testmodeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqltab = ('INSERT INTO "PMOD_TEST_MODE" (')
        sqlcol = ('"proid", "content", "testmodeid"')
        sqlval = (') VALUES (%s, %s, %s')
        sqlend = (');')
        sqlarr = [self._proid, content, testmodeid]

        if modeid != None:
            sqlcol = sqlcol + ', "modeid"'
            sqlval = sqlval + ', %s'
            sqlarr.append(modeid)

        sqlstr = sqltab + sqlcol + sqlval + sqlend
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def del_mode(self, modeid):
        if(
            type(modeid) != int
        ):
            return 'Eparameter'

        if modeid == 1 or not self._does_modeid_exist(modeid):
            return 'Emodeid'

        self._del_mode(modeid)

        return 'Success'

    def _del_mode(self, modeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('DELETE FROM "PMOD_TEST_MODE" WHERE "proid" = %s AND '
                  '"modeid" = %s;')
        sqlarr = (self._proid, modeid)
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def set_mode(self, modeid, content, testmodeid):
        if(
            type(modeid) != int or
            (content != None and type(content) != str) or
            (testmodeid != None and type(testmodeid) != int)
        ):
            return 'Eparameter'

        if not self._does_modeid_exist(modeid):
            return 'Emodeid'

        if testmodeid != None and not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        self._set_mode(modeid, content, testmodeid)

        return 'Success'

    def _set_mode(self, modeid, content, testmodeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('UPDATE "PMOD_TEST_MODE" SET "content" = %s, '
                  '"testmodeid" = %s WHERE "proid" = %s AND "modeid" = %s;')
        sqlarr = (content, testmodeid, self._proid, modeid)
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def get_mode(self, modeid):
        if(
            type(modeid) != int
        ):
            return 'Eparameter'

        mode = self._get_mode_by_modeid(modeid)

        if mode == None:
            return 'Emodeid'

        return mode

    @imc.async.caller
    def list_mode(self):
        mode_list = self._list_mode()

        return mode_list        

    def _list_mode(self):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('SELECT "modeid", "testmodeid" FROM "PMOD_TEST_MODE" '
                  'WHERE "proid" = %s ORDER BY "modeid" ASC;')
        sqlarr = (self._proid, )
        cur.execute(sqlstr, sqlarr)

        mode_list = []
        for data in cur:
            obj = {}
            obj['modeid'] = data[0]
            obj['testmodeid'] = data[1]

            mode_list.append(obj)

        return mode_list
    
    @imc.async.caller
    def add_testmode(self, testmodename, timelimit, memlimit):
        if(
            type(testmodename) != str or
            (timelimit != None and type(timelimit) != int) or
            (memlimit != None and type(memlimit) != int)
        ):
            return 'Eparameter'

        if timelimit != None and timelimit < 0:
            return 'Etimelimit'
        if memlimit != None and memlimit < 0:
            return 'Ememlimit'

        self._add_testmode(testmodename, timelimit, memlimit)

        return 'Success'

    def _add_testmode(self, testmodename, timelimit, memlimit):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('INSERT INTO "PMOD_TEST_TESTMODE" ("proid", "testmodename", '
                  '"timelimit", "memlimit") VALUES (%s, %s, %s, %s);')
        sqlarr = (self._proid, testmodename, timelimit, memlimit)
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def del_testmode(self, testmodeid):
        if(
            type(testmodeid) != int
        ):
            return 'Eparameter'

        if not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        self._del_testmode(testmodeid)

        return 'Success'

    def _del_testmode(self, testmodeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('DELETE FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s AND '
                  '"testmodeid" = %s;')
        sqlarr = (self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

        sqlstr = ('DELETE FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s AND '
                  '"testmodeid" = %s;')
        sqlarr = (self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def set_testmode(self, testmodeid, testmodename, timelimit, memlimit):
        if(
            type(testmodeid) != int or
            type(testmodename) != str or
            (timelimit != None and type(timelimit) != int) or
            (memlimit != None and type(memlimit) != int)
        ):
            return 'Eparameter'

        if not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        if timelimit != None and timelimit < 0:
            return 'Etimelimit'
        if memlimit != None and memlimit < 0:
            return 'Ememlimit'

        self._set_testmode(testmodeid, testmodename, timelimit, memlimit)

        return 'Success'

    def _set_testmode(self, testmodeid, testmodename, timelimit, memlimit):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('UPDATE "PMOD_TEST_TESTMODE" SET "testmodename" = %s, '
                  '"timelimit" = %s, "memlimit" = %s WHERE "proid" = %s AND '
                  '"testmodeid" = %s;')
        sqlarr = (testmodename, timelimit, memlimit, self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def get_testmode(self, testmodeid):
        if(
            type(testmodeid) != int
        ):
            return 'Eparameter'

        if not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        testmode = self._get_testmode(testmodeid)

        return testmode

    def _get_testmode(self, testmodeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('SELECT "testmodeid", "testmodename", "timelimit", '
                  '"memlimit" FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s AND '
                  '"testmodeid" = %s;')
        sqlarr = (self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

        testmode = None
        for data in cur:
            testmode = {}
            testmode['testmodeid'] = data[0]
            testmode['testmodename'] = data[1]
            testmode['timelimit'] = data[2]
            testmode['memlimit'] = data[3]

        return testmode

    @imc.async.caller
    def list_testmode(self):
        testmode_list = self._list_testmode()

        return testmode_list

    def _list_testmode(self):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('SELECT "testmodeid", "testmodename", "timelimit", '
                  '"memlimit" FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s '
                  'ORDER BY "testmodeid" ASC;')
        sqlarr = (self._proid, )
        cur.execute(sqlstr, sqlarr)

        testmode_list = []
        for data in cur:
            obj = {}
            obj['testmodeid'] = data[0]
            obj['testmodename'] = data[1]
            obj['timelimit'] = data[2]
            obj['memlimit'] = data[3]

            testmode_list.append(obj)

        return testmode_list

    @imc.async.caller
    def create_testdata(self, info, filekey, expire = None):
        if expire != None:
            expire = com.isoptime(expire)
            if expire == None:
                return 'Eparameter'

        if(
            type(info) != str or
            type(filekey) != str
        ):
            return 'Eparameter'

        testid = self._create_testdata(info, filekey, expire)

        if testid == None:
            return 'Eupload'

        return {'testid': testid}

    def _create_testdata(self, info, filekey, expire):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        # Upload file

        blobname = 'TEST_BLOBNAME'

        with TOJAuth.change_current_iden(self._idendesc):
            testid = mod.TestdataMg.instance._add_testdata(
                blobname, expire, self._proid, info)

        return testid

    @imc.async.caller
    def delete_testdata(self, testid):
        if(
            type(testid) != int
        ):
            return 'Eparameter'

        with TOJAuth.change_current_iden(self._idendesc):
            test = mod.TestdataMg.instance._get_testdata(testid)

        if test == None:
            return 'Etestid'

        if test['proid'] != self._proid:
            return 'Eother_proid'

        self._delete_testdata(testid)

        return 'Success'

    def _delete_testdata(self, testid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_DELETE)

        with TOJAuth.change_current_iden(self._idendesc):
            mod.TestdataMg.instance._del_testdata(testid)

    @imc.async.caller
    def get_testdata(self, testid):
        if(
            type(testid) != int
        ):
            return 'Eparameter'

        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        with TOJAuth.change_current_iden(self._idendesc):
            test = mod.TestdataMg.instance._get_testdata(testid)

        if test == None:
            return 'Etestid'

        if test['proid'] != self._proid:
            return 'Eother_proid'

        del test['blobname']
        del test['proid']

        return test

    @imc.async.caller
    def list_testdata(self):
        testdata_list = self._list_testdata()

        return testdata_list

    def _list_testdata(self):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        with TOJAuth.change_current_iden(self._idendesc):
            testdata_list = mod.TestdataMg.instance._list_testdata(self._proid)

        for test in testdata_list:
            del test['blobname']
            del test['proid']

        return testdata_list

    @imc.async.caller
    def set_testdata(self, testid, info, filekey = None, expire = None):
        if expire != None:
            expire = com.isoptime(expire)
            if expire == None:
                return 'Eparameter'

        if(
            type(testid) != int or
            type(info) != str or
            (filekey != None and type(filekey) != str)
        ):
            return 'Eparameter'

        with TOJAuth.change_current_iden(self._idendesc):
            test = mod.TestdataMg.instance._get_testdata(testid)

        if test == None:
            return 'Etestid'

        if test['proid'] != self._proid:
            return 'Eother_proid'

        result = self._set_testdata(testid, info, filekey, expire)

        if result == None:
            return 'Efailed'

        if result == False:
            return 'Eupload'

        return 'Success'

    def _set_testdata(self, testid, info, filekey, expire):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
        
        with TOJAuth.change_current_iden(self._idendesc):
            test = mod.TestdataMg.instance._get_testdata(testid)
        
        blobname = test['blobname']
        if test['proid'] != self._proid:
            return None

        if filekey != None:
            # Upload file
            # Update blob 'blobname'
            # If failed return False

        with TOJAuth.change_current_iden(self._idendesc):
            mod.TestdataMg.instance._update_testdata(
                testid, blobname, expire, self._proid, info)

        return True

    @imc.async.caller
    def set_testmode_testdata(self, testmodeid, testdata):
        if(
            type(testmodeid) != int or
            type(testdata) != list
        ):
            return 'Eparameter'

        for test in testdata:
            if type(test) != list:
                return 'Eparameter'
            if(
                'testid' not in test or
                type(test['testid']) != int or
                'timelimit' not in test or
                type(test['timelimit']) != int or
                'memlimit' not in test or
                type(test['memlimit']) != int or
                'subtask' not in test or
                type(test['subtask']) != int
            ):
                return 'Eparameter'

            if test['timelimit'] != None and test['timelimit'] < 0:
                return 'Etimelimit'
            if test['memlimit'] != None and test['memlimit'] < 0:
                return 'Ememlimit'

        if not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        self._set_testdata(testmodeid, testdata)

        return 'Success'

    def _set_testmode_testdata(self, testmodeid, testdata):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('DELETE FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s AND '
                  '"testmodeid" = %s;')
        sqlarr = (self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

        if len(testdata) == 0:
            return

        sqltab = ('INSERT INTO "PMOD_TEST_TESTDATA" ("proid", "testmodeid", '
                  '"order", "testid", "timelimit", "memlimit", "subtask") '
                  'VALUES')
        sqlval = ()
        sqlend = (';')
        sqlarr = []

        cnt = 0
        for test in testdata:
            if cnt == 0:
                sqlval = sqlval + ' '
            else:
                sqlval = sqlval + ', '

            cnt = cnt + 1
            sqlval = sqlval + '(%s, %s, %s, %s, %s, %s, %s)'
            sqlarr.append(self._proid)
            sqlarr.append(testmodeid)
            sqlarr.append(cnt)
            sqlarr.append(test['testid'])
            sqlarr.append(test['timelimit'])
            sqlarr.append(test['memlimit'])
            sqlarr.append(test['subtask'])

        sqlstr = sqltab + sqlval + sqlend
        cur.execute(sqlstr, sqlarr)

    @imc.async.caller
    def get_testmode_testdata(self, testmodeid):
        if(
            type(testmodeid) != int
        ):
            return 'Eparameter'

        if not self._does_testmodeid_exist(testmodeid):
            return 'Etestmodeid'

        testdata = self._get_testdata(testmodeid)

        return testdata

    def _get_testmode_testdata(self, testmodeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('SELECT "order", "testid", "timelimit", "memlimit", '
                  '"subtask" FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s AND '
                  '"testmodeid" = %s ORDER BY "order" ASC;')
        sqlarr = (self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

        testdata = []
        for data in cur:
            obj = {}
            obj['order'] = data[0]
            obj['testid'] = data[1]
            obj['timelimit'] = data[2]
            obj['memlimit'] = data[3]
            obj['subtask'] = data[4]

            testdata.append(obj)

        return testdata

    def _does_modeid_exist(self, modeid):
        mode = self._get_mode_by_modeid(modeid)

        return mode != None

    def _get_mode_by_modeid(self, modeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('SELECT "proid", "modeid", "content", "testmodeid" FROM '
                  '"PMOD_TEST_MODE" WHERE "proid" = %s AND "modeid" = %s;')
        sqlarr = (self._proid, modeid)
        cur.execute(sqlstr, sqlarr)

        mode = None
        for data in cur:
            mode = {}
            mode['proid'] = data[0]
            mode['modeid'] = data[1]
            mode['content'] = data[2]
            mode['testmodeid'] = data[3]

        return mode

    def _does_testmodeid_exist(self, testmodeid):
        testmode_info = self._get_testmode_info(testmodeid)

        return testmode_info != None

    def _get_testmode_info(self, testmodeid):
        TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)

        cur = self.db.cursor()
        sqlstr = ('SELECT "proid", "testmodeid", "testmodename", "timelimit",'
                  ' "memlimit" FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s '
                  'AND "testmodeid" = %s;')
        sqlarr = (self._proid, testmodeid)
        cur.execute(sqlstr, sqlarr)

        testmode_info = None
        for data in cur:
            testmode_info = {}
            testmode_info['proid'] = data[0]
            testmode_info['testmodeid'] = data[1]
            testmode_info['testmodename'] = data[2]
            testmode_info['timelimit'] = data[3]
            testmode_info['memlimit'] = data[4]

        return testmode_info
Exemplo n.º 27
0
    "host": "localhost",
    "port": "3306",
    "database": "test",
    "DEBUG": True,
}

# With mysqlPool
pool = mysqlPool(loop=loop, params=params)
loop.run_until_complete(pool.connect())
db = loop.run_until_complete(pool.acquire())
conn = db.get_connection()
loop.run_until_complete(pool.release())
pool.terminate()

# With AsyncDB
pool = AsyncDB("mysql", loop=loop, params=params)
conn = loop.run_until_complete(pool.connection())
cursor = loop.run_until_complete(pool.cursor())

result, error = loop.run_until_complete(pool.execute("TRUNCATE TABLE color"))
print("-- execute", result)

data = [
    ("Red", "#ff0000"),
    ("Green", "#00ff00"),
    ("Blue", "#0000ff"),
    ("Cyan", "#00ffff"),
    ("Magenta", "#ff00ff"),
    ("Yellow", "#ffff00"),
    ("Black", "#000000"),
    ("White", "#ffffff"),
Exemplo n.º 28
0
async def conn(event_loop):
    db = AsyncDB('pg', dsn=asyncpg_url, loop=event_loop)
    await db.connection()
    yield db
    await db.close()
class sqmod_test(Square):
    _sqmod_name = 'sqmod_test'

    def __init__(self, mod_idendesc, get_link_fn, sqid):
        self._sqid = sqid;
        self._idendesc = mod_idendesc
        self.get_link = get_link_fn
        
        self._accessid = mod.SquareMg.get_accessid_by_sqid(self._sqid)

        self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER, 
                          config.MOD_DBPASSWORD)

        self._reg_path = 'sq/' + str(self._sqid) + '/'

        Proxy.instance.register_call(
            self._reg_path,'list_jurank',self.list_jurank)
        Proxy.instance.register_call(
            self._reg_path,'update_result',self.update_result)

    def unload(self):
        pass

    def join_square(self,uid):
        return mod.SquareMg.JOIN_ACCEPT

    def quit_square(self,uid):
        pass

    @staticmethod
    def create_square_data():
        pass
    
    @staticmethod
    def delete_square_data():
        pass


    @imc.async.caller
    def list_jurank(self):
        #TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_READ)

        cur = self.db.cursor();
        cur.execute('SELECT "name","song","score","maxcombo" FROM "SQMOD_TEST_JURANK" ORDER BY "score" DESC')

        ret = []
        for data in cur:
            ret.append({
                'name':data[0],
                'song':data[1],
                'score':data[2],
                'maxcombo':data[3],
            })

        return ret

    @imc.async.caller
    def update_result(self,name,song,score,maxcombo):
        #TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_READ)

        cur = self.db.cursor();
        cur.execute('SELECT "score" FROM "SQMOD_TEST_JURANK" WHERE "name"=%s AND "song"=%s',
                    (name,song))

        if cur.rowcount == 1:
            if cur.fetchone()[0] > score:
                return 'Success'

        cur.upsert('SQMOD_TEST_JURANK',
                   {'name':name,'song':song},
                   {'score':score,'maxcombo':maxcombo})

        client_links = self.get_link('client')
        subpath = 'sq/' + str(self._sqid) + '/'
        for link in client_links:
            Proxy.instance.call_async(
                link + subpath, 'update_jurank', 10000, None)

        return 'Success'
Exemplo n.º 30
0
async def test_pool_by_params(driver, event_loop):
    db = AsyncDB(driver, params=params, loop=event_loop)
    assert db.is_connected() is False
Exemplo n.º 31
0
async def conn(event_loop):
    db = AsyncDB(DRIVER, params=params, loop=event_loop)
    await db.connection()
    yield db
    await db.close()
Exemplo n.º 32
0
            ("SVO", "Moscow", "Russia"),
        ]
        airports = "INSERT INTO airports VALUES(?, ?, ?)"
        await conn.executemany(airports, data)
        a_country = "United States"
        a_city = "Moscow"
        query = "SELECT * FROM airports WHERE country=? OR city=?"
        async with await conn.fetch(query, (a_country, a_city)) as result:
            async for row in result:
                print(row)
        # using prepare
        print('Using Cursor Objects: ')
        b_country = 'France'
        b_city = 'London'
        async with conn.cursor(query, (b_country, b_city)) as cursor:
            print("using iterator: ")
            async for row in cursor:
                print(row)
            # its an iterable
            print("Using Context Manager: ")
            async with cursor:
                print(await cursor.fetchall())
            # this returns a cursor based object


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.set_exception_handler(default_exception_handler)
    driver = AsyncDB("sqlite", params={"database": ":memory:"}, loop=loop)
    asyncio.run(connect(driver))