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
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)
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)
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())
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()
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()
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()
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()
async def test_pool_by_params(driver, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
assert db.is_connected() is False
class TokenAuth(BaseAuthBackend):
"""API Token Authentication Handler."""
connection = None
_scheme: str = 'Bearer'
def configure(self, app, router):
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)
asyncio.get_event_loop().run_until_complete(_make_connection())
# executing parent configurations
super(TokenAuth, self).configure(app, router)
async def get_payload(self, request):
token = None
tenant = None
id = None
try:
if 'Authorization' in request.headers:
try:
scheme, id = request.headers.get(
'Authorization').strip().split(' ', 1)
except ValueError:
raise web.HTTPForbidden(
reason='Invalid authorization Header', )
if scheme != self._scheme:
raise web.HTTPForbidden(
reason='Invalid Authorization Scheme', )
try:
tenant, token = id.split(':')
except ValueError:
raise web.HTTPForbidden(reason='Invalid Token Structure', )
except Exception as e:
print(e)
return None
return [tenant, token]
async def reconnect(self):
if not self.connection or not self.connection.is_connected():
await self.connection.connection()
async def check_credentials(self, request):
try:
tenant, token = await self.get_payload(request)
logging.debug(f'Tenant ID: {tenant}')
except Exception as err:
raise NavException(err, state=400)
if not token:
raise InvalidAuth('Invalid Credentials', state=401)
else:
payload = jwt.decode(token,
PARTNER_KEY,
algorithms=[JWT_ALGORITHM],
leeway=30)
logging.debug(f'Decoded Token: {payload!s}')
data = await self.check_token_info(request, tenant, payload)
if not data:
raise InvalidAuth(f'Invalid Session: {token!s}', state=401)
# getting user information
# making validation
try:
u = data['name']
username = data['partner']
grants = data['grants']
programs = data['programs']
except KeyError as err:
print(err)
raise InvalidAuth(
f'Missing attributes for Partner Token: {err!s}',
state=401)
# TODO: Validate that partner (tenants table):
# try:
# user = await self.validate_user(
# login=username
# )
# except UserDoesntExists as err:
# raise UserDoesntExists(err)
# except Exception as err:
# raise NavException(err, state=500)
try:
user = {
'name': data['name'],
'partner': username,
'issuer': 'Mobileinsight',
'programs': programs,
'grants': grants,
'tenant': tenant
}
userdata = dict(data)
# Create the User session and returned.
session = await self._session.create_session(
request, user, userdata)
session['partner'] = username
session['tenant'] = tenant
session['programs'] = programs
token = self.create_jwt(data=user)
return {'token': f'{tenant}:{token}'}
except Exception as err:
print(err)
return False
async def authenticate(self, request):
""" Authenticate, refresh or return the user credentials."""
pass
async def check_token_info(self, request, tenant, payload):
if not self.connection:
await self.reconnect()
try:
name = payload['name']
partner = payload['partner']
except KeyError as err:
return False
sql = f"""
SELECT name, partner, grants, programs FROM troc.api_keys
WHERE name='{name}' AND partner='{partner}'
AND enabled = TRUE AND revoked = FALSE AND '{tenant}'= ANY(programs)
"""
try:
result, error = await self.connection.queryrow(sql)
if error or not result:
return False
else:
return result
except Exception as err:
logging.exception(err)
return False
async def auth_middleware(self, app, handler):
async def middleware(request):
request.user = None
authz = await self.authorization_backends(app, handler, request)
if authz:
return await authz
tenant, token = await self.get_payload(request)
if token:
try:
payload = jwt.decode(token,
PARTNER_KEY,
algorithms=[JWT_ALGORITHM],
leeway=30)
logging.debug(f'Decoded Token: {payload!s}')
result = await self.check_token_info(
request, tenant, payload)
if not result:
raise web.HTTPForbidden(reason='Not Authorized', )
else:
session = await self._session.get_session(request)
session['grants'] = result['grants']
session['partner'] = result['partner']
session['tenant'] = tenant
except (jwt.DecodeError) as err:
raise web.HTTPBadRequest(
reason=f'Token Decoding Error: {err!r}')
except jwt.InvalidTokenError as err:
print(err)
raise web.HTTPBadRequest(
reason=f'Invalid authorization token {err!s}')
except (jwt.ExpiredSignatureError) as err:
print(err)
raise web.HTTPBadRequest(reason=f'Token Expired: {err!s}')
except Exception as err:
print(err, err.__class__.__name__)
raise web.HTTPBadRequest(
reason=f'Bad Authorization Request: {err!s}')
else:
if self.credentials_required is True:
print('Missing Token information')
raise web.HTTPUnauthorized(reason='Not Authorized', )
return await handler(request)
return middleware
async def test_pool_by_dsn(event_loop):
""" test creation using DSN """
db = AsyncDB(DRIVER, dsn=DSN, loop=event_loop)
assert db.is_connected() is False
