def findRoles(self, db):
'''find the roles that has this privilege
'''
from RoleHasPrivilege import RoleHasPrivilege
rs = db.query(RoleHasPrivilege).filter_by(privilege=self.id).all()
from Role import Role
return [db.query(Role).filter_by(id=r.role.id).one() for r in rs]
def findRoles(self, db):
'''find the roles that has this privilege
'''
from RoleHasPrivilege import RoleHasPrivilege
rs = db.query(RoleHasPrivilege).filter_by(privilege=self.id).all()
from Role import Role
return [db.query(Role).filter_by(id=r.role.id).one() for r in rs]
def test5(self):
'dsaw.db: make sure globalpointer is left blank when a record is created'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
from dsaw.db.GloballyReferrable import GloballyReferrable
class User(WithID, GloballyReferrable):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
# register and initialize
tables = [User]
for table in tables: db.registerTable(table)
db.createAllTables()
# insert a record
bob = User()
bob.id = bob.username = '******'
db.insertRow(bob)
# read
bob1 = db.query(User).filter_by(id=bob.id).one()
self.assertEqual(bob1.globalpointer, None)
# destroy
db.destroyAllTables()
return
def test1(self):
'dsaw.db.ReferenceSet: '
# create table
from dsaw.db.WithID import WithID
class Test(WithID):
name = "test"
import dsaw.db
# add more columns
import dsaw.db
address = dsaw.db.varchar(name='address', length=16)
Test.addColumn(address)
#
db = self.db
# create table
db.registerTable(Test)
db.createAllTables()
# create new record
t = Test()
t.id = '111'
t.address = 'abc'
db.insertRow(t)
# load from db and compare
t1 = db.query(Test).filter_by(id=t.id).one()
self.assertEqual(t.address, t1.address)
return
def test3c(self):
'dsaw.db.Psycopg2: table with reference. updateRecord'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class User(WithID):
name = 'users'
import dsaw.db
username = dsaw.db.varchar(name='username', length=100)
class Greeting(WithID):
name = 'greetings'
import dsaw.db
greeting = dsaw.db.varchar(name='greeting', length=100)
who = dsaw.db.reference(name='who', table=User)
db._tablemap.registerTable(User)
db._tablemap.TableToObject(User)
tables = [User, Greeting]
for table in tables:
db.registerTable(table)
db.createAllTables()
# create two users
userbob = User()
userbob.id = userbob.username = '******'
db.insertRow(userbob)
useralice = User()
useralice.id = useralice.username = '******'
db.insertRow(useralice)
# create a greeting
greeting = Greeting()
greeting.who = userbob
greeting.greeting = 'hello'
greeting.id = 'greeting1'
db.insertRow(greeting)
# update
greeting.who = useralice
greeting.greeting = 'aloha'
db.updateRecord(greeting)
# fetch it
greeting1 = db.query(Greeting).filter_by(id=greeting.id).one()
self.assertEqual(greeting1.greeting, 'aloha')
self.assertEqual(greeting1.who.id, useralice.id)
db.destroyAllTables()
return
def markResultFileStatusAndErrorMessage(self, filename, db, status, message=None):
message_len = _ComputationResultRetrievals.message.length
gp = self.globalpointer
gp = gp and gp.id
if not gp:
# no global address yet, means need new entry
neednewentry = True
else:
# look for the entries
where = "computation=%s and filename='%s'" % (gp, filename)
rs = db.query(_ComputationResultRetrievals).filter(where).all()
db.commit()
if len(rs) == 0:
# no entry, need one
neednewentry = True
elif len(rs) > 1:
# more than one entries, error
raise RuntimeError, \
"multiple entries in table %s for computation %s(%s), filename %s" % (
_ComputationResultRetrievals.getTableName(),
self.getTableName(), self.id,
filename)
else:
# found one entry
neednewentry = False
r = rs[0]
if neednewentry:
# create a new entry
r = _ComputationResultRetrievals()
r.computation = self
#db.insertRow(r)
r.status = status
#db.updateRecord(r)
r.filename = filename
#db.updateRecord(r)
if message is not None:
r.message = message[:message_len]
#db.updateRecord(r)
db.insertRow(r)
return
# update entry
r.status = status
if message is not None:
r.message = message[:message_len]
db.updateRecord(r)
return
def test2(self):
'dsaw.db.unpickler: table with a column being reference'
self.removeDB()
db = self.dbManager()
from dsaw.db.Unpickler import Unpickler
indir = 'unpickle-inputs/test2'
unpickler = Unpickler(db, indir)
unpickler.load([User, Simulation])
records = db.query(User).all()
self.assertEqual(len(records), 1)
user1 = records[0]
self.assertEqual(user1.id, 1)
self.assertEqual(user1.username, 'user1')
records = db.query(Simulation).all()
self.assertEqual(len(records), 1)
sim1 = records[0]
self.assertEqual(sim1.id, 5)
self.assertEqual(sim1.creator.dereference(db).id, user1.id)
return
def test3(self):
'dsaw.db.unpickler: table with a column being versatile reference'
self.removeDB()
db = self.dbManager()
from dsaw.db.Unpickler import Unpickler
indir = 'unpickle-inputs/test3'
unpickler = Unpickler(db, indir)
unpickler.load([Cylinder, Sample, global_pointer])
records = db.query(Cylinder).all()
self.assertEqual(len(records), 1)
cylinder1 = records[0]
self.assertEqual(cylinder1.id, 3)
records = db.query(Sample).all()
self.assertEqual(len(records), 1)
sample1 = records[0]
self.assertEqual(sample1.id, 5)
shape = sample1.shape.dereference(db)
self.assertEqual(shape.id, cylinder1.id)
self.assertEqual(shape.__class__, Cylinder)
return
def remove(role, user, db):
'remove a role from a user'
# find the record
try:
r = db.query(UserHasRole).filter_by(user=user.id, role=role.id).one()
except:
msg = "Could no find user/role relation: user: %s, role: %s.\n" % (
user, role)
import traceback
msg += 'traceback: %s' % traceback.format_exc()
raise RuntimeError, msg
#
db.deleteRow(UserHasRole, where="id='%s'" % r.id)
return
def revoke(privilege, role, db):
'revoke a privilege assigment from a role'
try:
r = db.query(RoleHasPrivilege).filter_by(role=role.id, privilege=privilege.id).one()
except:
msg = "Could no find role/privilege relation: role: %s, privilege: %s.\n" % (
role, privilege)
import traceback
msg += 'traceback: %s' % traceback.format_exc()
raise RuntimeError, msg
#
db.deleteRow(RoleHasPrivilege, where="id='%s'" % r.id)
return
def remove(role, user, db):
'remove a role from a user'
# find the record
try:
r = db.query(UserHasRole).filter_by(user=user.id, role=role.id).one()
except:
msg = "Could no find user/role relation: user: %s, role: %s.\n" % (
user, role)
import traceback
msg += 'traceback: %s' % traceback.format_exc()
raise RuntimeError, msg
#
db.deleteRow(UserHasRole, where="id='%s'" % r.id)
return
def leave(member, group, db):
'make the member leave from the given group'
# find the record
try:
r = db.query(RoleHasRole).filter_by(group=group.id, member=member.id).one()
except:
msg = "Could no find role/role relation: group: %s, member: %s.\n" % (
group, member)
import traceback
msg += 'traceback: %s' % traceback.format_exc()
raise RuntimeError, msg
#
db.deleteRow(RoleHasRole, where="id='%s'" % r.id)
return
def test1(self):
'dsaw.db.unpickler: basic table'
self.removeDB()
db = self.dbManager()
from dsaw.db.Unpickler import Unpickler
indir = 'unpickle-inputs/test1'
unpickler = Unpickler(db, indir)
unpickler.load([User])
records = db.query(User).all()
self.assertEqual(len(records), 1)
user1 = records[0]
self.assertEqual(user1.id, 1)
self.assertEqual(user1.username, 'user1')
return
def _hasRoleDirectly(self, role, db):
'''check if this role has the give role
role: could be either of following two
* a tuple of (context, name)
* a record in the roles table
db: dsaw.db db manager
'''
if isinstance(role, tuple):
context, name = role
role = db.query(Role).filter_by(context=context, rolename=name).one()
else:
# assume role is already a db record of roles table
pass
return bool(self._hasRoleQuery(role, db).all())
def revoke(privilege, role, db):
'revoke a privilege assigment from a role'
try:
r = db.query(RoleHasPrivilege).filter_by(role=role.id,
privilege=privilege.id).one()
except:
msg = "Could no find role/privilege relation: role: %s, privilege: %s.\n" % (
role, privilege)
import traceback
msg += 'traceback: %s' % traceback.format_exc()
raise RuntimeError, msg
#
db.deleteRow(RoleHasPrivilege, where="id='%s'" % r.id)
return
def test3(self):
'dsaw.db.unpickler: prompt'
dbname = 'test2'
self.preparedb(dbname)
db = self.dbManager(dbname)
from dsaw.db.Unpickler import Unpickler
indir = 'unpickle-inputs/test1a'
unpickler = Unpickler(db, indir)
unpickler.load([User], strategy='prompt')
records = db.query(User).all()
for r in records:
print r
return
def _hasPrivilegeDirectly(self, privilege, db):
'''check if this role has the given privilege directly
privilege: could be either of following two
* a tuple of (target, name)
* a record in the privileges table
db: dsaw.db db manager
'''
if isinstance(privilege, tuple):
target, name = privilege
from Privilege import Privilege
privilege = db.query(Privilege).filter_by(target=target, name=name).one()
else:
# assume privilege is already a db record of privileges table
pass
return bool(self._hasPrivilegeQuery(privilege, db).all())
def test2(self):
'dsaw.db.unpickler: skip'
dbname = 'test2'
self.preparedb(dbname)
db = self.dbManager(dbname)
from dsaw.db.Unpickler import Unpickler
indir = 'unpickle-inputs/test1a'
unpickler = Unpickler(db, indir)
unpickler.load([User], strategy='skip')
records = db.query(User).all()
self.assertEqual(len(records), 1)
user1 = records[0]
self.assertEqual(user1.id, 1)
self.assertEqual(user1.username, 'user1')
return
def getResultRetrievalEntry(self, filename, db):
gp = self.globalpointer
gp = gp and gp.id
if not gp: return
where = "computation=%s and filename='%s' " % (gp, filename)
rs = db.query(_ComputationResultRetrievals).filter(where).all()
db.commit()
if not rs: return
if len(rs)>1:
raise RuntimeError, \
"multiple entries in table %s for computation %s(%s), filename %s" % (
_ComputationResultRetrievals.getTableName(),
self.getTableName(), self.id,
filename)
return rs[0]
def test1(self):
'dsaw.db.Psycopg2: double array type'
db = self.dbManager()
# declare tables
from dsaw.db.WithID import WithID
class DoubleArrayTest(WithID):
name = 'doublearraytest'
import dsaw.db
arr = dsaw.db.doubleArray(name='arr')
m = dsaw.db.doubleArray(name='m', shape=(2, 3))
db.registerTable(DoubleArrayTest)
db.createAllTables()
t1 = DoubleArrayTest()
t1.id = 't1'
t1.arr = [1., 2.]
db.insertRow(t1)
t1.arr = [3., 4.]
db.updateRecord(t1)
t1.arr = [5., 6.]
t1.m = [[0, 1, 2], [3, 4, 5]]
self.assertEqual(t1.m.shape, (2, 3))
t1.m = [[0, 1. / 3, 2], [3, 4, 5]]
db.updateRecord(t1)
self.assert_(abs(t1.m[0, 1] - 1. / 3) < 1e-12)
t1a = db.query(DoubleArrayTest).filter_by(id='t1').one()
self.assert_(abs(t1a.m[0, 1] - 1. / 3) < 1e-12)
db.destroyAllTables()
return
def _getRole(self, role, db):
context, name = role
from Role import Role
role = db.query(Role).filter_by(context=context, rolename=name).one()
return role
def _getRole(self, role, db):
context, name = role
from Role import Role
role = db.query(Role).filter_by(context=context, rolename=name).one()
return role
def _queryUserHasRole(self, db):
from UserHasRole import UserHasRole
return db.query(UserHasRole)
def _getPrivilege(self, privilege, db):
target, name = privilege
from vnf.dom.Privilege import Privilege
privilege = db.query(Privilege).filter_by(target=target, name=name).one()
return privilege
def getPointed(self, db):
table = db.getTable(self.type)
return db.query(table).filter_by(globalpointer=self.id).one()
def _queryRoleHasRole(self, db):
from RoleHasRole import RoleHasRole
return db.query(RoleHasRole)
def _getPrivilege(self, privilege, db):
target, name = privilege
from vnf.dom.Privilege import Privilege
privilege = db.query(Privilege).filter_by(target=target,
name=name).one()
return privilege
def _queryUserHasRole(self, db):
from UserHasRole import UserHasRole
return db.query(UserHasRole)
def _queryRoleHasPrivilege(self, db):
from RoleHasPrivilege import RoleHasPrivilege
return db.query(RoleHasPrivilege)
