from sqlalchemy.orm import validates
from sqlalchemy.ext.declarative import declarative_base
+from sfa.storage.record import Record
from sfa.util.sfalogging import logger
+from sfa.util.sfatime import utcparse, datetime_to_string
from sfa.util.xml import XML
from sfa.trust.gid import GID
# (*) finally for converting a dictionary into an sqlalchemy object, we provide
# obj.load_from_dict(dict)
-class AlchemyObj:
+class AlchemyObj(Record):
def __iter__(self):
self._i = iter(object_mapper(self).columns)
return self
def next(self):
n = self._i.next().name
return n, getattr(self, n)
- def todict (self):
- d=self.__dict__
- keys=[k for k in d.keys() if not k.startswith('_')]
- return dict ( [ (k,d[k]) for k in keys ] )
- def load_from_dict (self, d):
- for (k,v) in d.iteritems():
- # experimental
- if isinstance(v, StringTypes) and v.lower() in ['true']: v=True
- if isinstance(v, StringTypes) and v.lower() in ['false']: v=False
- setattr(self,k,v)
-
- # in addition we provide convenience for converting to and from xml records
- # for this purpose only, we need the subclasses to define 'fields' as either
- # a list or a dictionary
- def xml_fields (self):
- fields=self.fields
- if isinstance(fields,dict): fields=fields.keys()
- return fields
-
- def save_as_xml (self):
- # xxx not sure about the scope here
- input_dict = dict( [ (key, getattr(self.key), ) for key in self.xml_fields() if getattr(self,key,None) ] )
- xml_record=XML("<record />")
- xml_record.parse_dict (input_dict)
- return xml_record.toxml()
-
- def dump(self, dump_parents=False):
- for key in self.fields:
- if key == 'gid' and self.gid:
- gid = GID(string=self.gid)
- print " %s:" % key
- gid.dump(8, dump_parents)
- elif getattr(self,key,None):
- print " %s: %s" % (key, getattr(self,key))
-
+
# # only intended for debugging
# def inspect (self, logger, message=""):
# logger.info("%s -- Inspecting AlchemyObj -- attrs"%message)
record_id = Column (Integer, primary_key=True)
# this is the discriminator that tells which class to use
classtype = Column (String)
+ # in a first version type was the discriminator
+ # but that could not accomodate for 'authority+sa' and the like
type = Column (String)
hrn = Column (String)
gid = Column (String)
if dict: self.load_from_dict (dict)
def __repr__(self):
- result="[Record id=%s, type=%s, hrn=%s, authority=%s, pointer=%s" % \
+ result="<Record id=%s, type=%s, hrn=%s, authority=%s, pointer=%s" % \
(self.record_id, self.type, self.hrn, self.authority, self.pointer)
# skip the uniform '--- BEGIN CERTIFICATE --' stuff
if self.gid: result+=" gid=%s..."%self.gid[28:36]
else: result+=" nogid"
- result += "]"
+ result += ">"
return result
+ # shortcut - former implem. was record-based
+ def get (self, field, default):
+ return getattr(self,field,default)
+
@validates ('gid')
def validate_gid (self, key, gid):
if gid is None: return
elif isinstance(gid, StringTypes): return gid
else: return gid.save_to_string(save_parents=True)
+ def validate_datetime (self, key, incoming):
+ if isinstance (incoming, datetime): return incoming
+ elif isinstance (incoming, (int,float)):return datetime.fromtimestamp (incoming)
+
+ @validates ('date_created')
+ def validate_date_created (self, key, incoming): return self.validate_datetime (key, incoming)
+
+ @validates ('last_updated')
+ def validate_last_updated (self, key, incoming): return self.validate_datetime (key, incoming)
+
# xxx - there might be smarter ways to handle get/set'ing gid using validation hooks
def get_gid_object (self):
if not self.gid: return None
now=datetime.now()
self.last_updated=now
-##############################
-class RegUser (RegRecord):
- __tablename__ = 'users'
- # these objects will have type='user' in the records table
- __mapper_args__ = { 'polymorphic_identity' : 'user' }
- record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
- email = Column ('email', String)
-
- # append stuff at the end of the record __repr__
- def __repr__ (self):
- result = RegRecord.__repr__(self).replace("Record","User")
- result.replace ("]"," email=%s"%self.email)
- return result
-
- @validates('email')
- def validate_email(self, key, address):
- assert '@' in address
- return address
+#################### cross-relations tables
+# authority x user (pis) association
+authority_pi_table = \
+ Table ( 'authority_pi', Base.metadata,
+ Column ('authority_id', Integer, ForeignKey ('records.record_id'), primary_key=True),
+ Column ('pi_id', Integer, ForeignKey ('records.record_id'), primary_key=True),
+ )
+# slice x user (researchers) association
+slice_researcher_table = \
+ Table ( 'slice_researcher', Base.metadata,
+ Column ('slice_id', Integer, ForeignKey ('records.record_id'), primary_key=True),
+ Column ('researcher_id', Integer, ForeignKey ('records.record_id'), primary_key=True),
+ )
+##############################
+# all subclasses define a convenience constructor with a default value for type,
+# and when applicable a way to define local fields in a kwd=value argument
+####################
class RegAuthority (RegRecord):
__tablename__ = 'authorities'
__mapper_args__ = { 'polymorphic_identity' : 'authority' }
record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
+ #### extensions come here
+ reg_pis = relationship \
+ ('RegUser',
+ secondary=authority_pi_table,
+ primaryjoin=RegRecord.record_id==authority_pi_table.c.authority_id,
+ secondaryjoin=RegRecord.record_id==authority_pi_table.c.pi_id,
+ backref='reg_authorities_as_pis')
+ def __init__ (self, **kwds):
+ # fill in type if not previously set
+ if 'type' not in kwds: kwds['type']='authority'
+ # base class constructor
+ RegRecord.__init__(self, **kwds)
+
# no proper data yet, just hack the typename
def __repr__ (self):
return RegRecord.__repr__(self).replace("Record","Authority")
+####################
class RegSlice (RegRecord):
__tablename__ = 'slices'
__mapper_args__ = { 'polymorphic_identity' : 'slice' }
record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
-
+ #### extensions come here
+ reg_researchers = relationship \
+ ('RegUser',
+ secondary=slice_researcher_table,
+ primaryjoin=RegRecord.record_id==slice_researcher_table.c.slice_id,
+ secondaryjoin=RegRecord.record_id==slice_researcher_table.c.researcher_id,
+ backref='reg_slices_as_researcher')
+
+ def __init__ (self, **kwds):
+ if 'type' not in kwds: kwds['type']='slice'
+ RegRecord.__init__(self, **kwds)
+
def __repr__ (self):
return RegRecord.__repr__(self).replace("Record","Slice")
+####################
class RegNode (RegRecord):
__tablename__ = 'nodes'
__mapper_args__ = { 'polymorphic_identity' : 'node' }
record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
+ def __init__ (self, **kwds):
+ if 'type' not in kwds: kwds['type']='node'
+ RegRecord.__init__(self, **kwds)
+
def __repr__ (self):
return RegRecord.__repr__(self).replace("Record","Node")
+####################
+class RegUser (RegRecord):
+ __tablename__ = 'users'
+ # these objects will have type='user' in the records table
+ __mapper_args__ = { 'polymorphic_identity' : 'user' }
+ record_id = Column (Integer, ForeignKey ("records.record_id"), primary_key=True)
+ #### extensions come here
+ email = Column ('email', String)
+ # can't use name 'keys' here because when loading from xml we're getting
+ # a 'keys' tag, and assigning a list of strings in a reference column like this crashes
+ reg_keys = relationship \
+ ('RegKey', backref='reg_user',
+ cascade="all, delete, delete-orphan")
+
+ # so we can use RegUser (email=.., hrn=..) and the like
+ def __init__ (self, **kwds):
+ # handle local settings
+ if 'email' in kwds: self.email=kwds.pop('email')
+ if 'type' not in kwds: kwds['type']='user'
+ RegRecord.__init__(self, **kwds)
+
+ # append stuff at the end of the record __repr__
+ def __repr__ (self):
+ result = RegRecord.__repr__(self).replace("Record","User")
+ result.replace (">"," email=%s"%self.email)
+ result += ">"
+ return result
+
+ @validates('email')
+ def validate_email(self, key, address):
+ assert '@' in address
+ return address
+
+####################
+# xxx tocheck : not sure about eager loading of this one
+# meaning, when querying the whole records, we expect there should
+# be a single query to fetch all the keys
+# or, is it enough that we issue a single query to retrieve all the keys
+class RegKey (Base):
+ __tablename__ = 'keys'
+ key_id = Column (Integer, primary_key=True)
+ record_id = Column (Integer, ForeignKey ("records.record_id"))
+ key = Column (String)
+ pointer = Column (Integer, default = -1)
+
+ def __init__ (self, key, pointer=None):
+ self.key=key
+ if pointer: self.pointer=pointer
+
+ def __repr__ (self):
+ result="<key id=%s key=%s..."%(self.key_id,self.key[8:16],)
+ try: result += " user=%s"%self.reg_user.record_id
+ except: result += " no-user"
+ result += ">"
+ return result
+
##############################
-# although the db needs of course to be reachable,
+# although the db needs of course to be reachable for the following functions
# the schema management functions are here and not in alchemy
# because the actual details of the classes need to be known
-def init_tables(dbsession):
- logger.info("Initializing db schema and builtin types")
- # the doc states we could retrieve the engine this way
- # engine=dbsession.get_bind()
- # however I'm getting this
- # TypeError: get_bind() takes at least 2 arguments (1 given)
- # so let's import alchemy - but not from toplevel
- from sfa.storage.alchemy import engine
+# migrations: this code has no notion of the previous versions
+# of the data model nor of migrations
+# sfa.storage.migrations.db_init uses this when starting from
+# a fresh db only
+def init_tables(engine):
+ logger.info("Initializing db schema from current/latest model")
Base.metadata.create_all(engine)
-def drop_tables(dbsession):
- logger.info("Dropping tables")
- # same as for init_tables
- from sfa.storage.alchemy import engine
+def drop_tables(engine):
+ logger.info("Dropping tables from current/latest model")
Base.metadata.drop_all(engine)
##############################
elif type=='node':
result=RegNode (dict=record_dict)
else:
+ logger.debug("Untyped RegRecord instance")
result=RegRecord (dict=record_dict)
logger.info ("converting dict into Reg* with type=%s"%type)
logger.info ("returning=%s"%result)
xml_dict = xml_record.todict()
logger.info("load from xml, keys=%s"%xml_dict.keys())
return make_record_dict (xml_dict)
+
git://git.onelab.eu / sfa.git / blobdiff