import sys
-from sqlalchemy import create_engine
+from sqlalchemy import create_engine, and_
from sqlalchemy.orm import sessionmaker
from sfa.util.config import Config
from sqlalchemy.orm import relationship, backref
+from sqlalchemy.dialects import postgresql
+
from sqlalchemy import MetaData, Table
from sqlalchemy.exc import NoSuchTableError
+from sqlalchemy import String
+
#Dict holding the columns names of the table as keys
#and their type, used for creation of the table
slice_table = {'record_id_user':'integer PRIMARY KEY references X ON DELETE CASCADE ON UPDATE CASCADE','oar_job_id':'integer DEFAULT -1', 'record_id_slice':'integer', 'slice_hrn':'text NOT NULL'}
-class SlabSliceDB (SlabBase):
+class SliceSenslab (SlabBase):
__tablename__ = 'slice_senslab'
- record_id_user = Column(Integer, primary_key=True)
+ #record_id_user = Column(Integer, primary_key=True)
+ slice_hrn = Column(String,primary_key=True)
+ peer_authority = Column( String,nullable = True)
+ record_id_slice = Column(Integer)
+ record_id_user = Column(Integer)
oar_job_id = Column( Integer,default = -1)
- record_id_slice = Column(Integer)
- slice_hrn = Column(String,nullable = False)
+ node_list = Column(postgresql.ARRAY(String), nullable =True)
- def __init__ (self, slice_hrn =None, oar_job_id=None, record_id_slice=None, record_id_user= None):
+ def __init__ (self, slice_hrn =None, oar_job_id=None, record_id_slice=None, record_id_user= None,peer_authority=None):
+ self.node_list = []
if record_id_slice:
self.record_id_slice = record_id_slice
if slice_hrn:
self.slice_hrn = slice_hrn
if record_id_user:
self.record_id_user= record_id_user
+ if peer_authority:
+ self.peer_authority = peer_authority
+
def __repr__(self):
- result="<Record id user =%s, slice hrn=%s, oar_job id=%s,Record id slice =%s" % \
- (self.record_id_user, self.slice_hrn, self.oar_job_id, self.record_id_slice)
+ result="<Record id user =%s, slice hrn=%s, oar_job id=%s,Record id slice =%s node_list =%s peer_authority =%s"% \
+ (self.record_id_user, self.slice_hrn, self.oar_job_id, self.record_id_slice, self.node_list, self.peer_authority)
result += ">"
return result
+ def dumpquerytodict(self):
+ dict = {'slice_hrn':self.slice_hrn,
+ 'peer_authority':self.peer_authority,
+ 'record_id':self.record_id_slice,
+ 'record_id_user':self.record_id_user,
+ 'oar_job_id':self.oar_job_id,
+ 'record_id_slice':self.record_id_slice,
+ 'node_list':self.node_list}
+ return dict
+#class PeerSenslab(SlabBase):
+ #__tablename__ = 'peer_senslab'
+ #peername = Column(String, nullable = False)
+ #peerid = Column( Integer,primary_key=True)
+
+ #def __init__ (self,peername = None ):
+ #if peername:
+ #self.peername = peername
-
+
+ #def __repr__(self):
+ #result="<Peer id =%s, Peer name =%s" % (self.peerid, self.peername)
+ #result += ">"
+ #return result
class SlabDB:
def __init__(self,config):
self.sl_base = SlabBase
-
dbname="slab_sfa"
# will be created lazily on-demand
self.slab_session = None
pass
self.slab_engine=None
raise Exception,"Could not connect to database"
-
+
+
+
def check (self):
self.slab_engine.execute ("select 1").scalar()
-
-
+
+
+
def session (self):
if self.slab_session is None:
Session=sessionmaker ()
SlabBase.metadata.create_all(slab_engine)
return
+ #Updates the job_id and the nodes list
+ #The nodes list is never erased.
+ def update_job(self, hrn, job_id= None, nodes = None ):
+ slice_rec = slab_dbsession.query(SliceSenslab).filter_by(slice_hrn = hrn).first()
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES update_job slice_rec %s"%(slice_rec)
+ if job_id is not None:
+ slice_rec.oar_job_id = job_id
+ if nodes is not None :
+ slice_rec.node_list = nodes
+ slab_dbsession.commit()
def find (self, name = None, filter_dict = None):
- if filter_dict:
- filter_statement = "and_(SlabSliceDB."
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find filter_dict %s"%(filter_dict)
+
+ #Filter_by can not handle more than one argument, hence these functions
+ def filter_id_user(query, user_id):
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find filter_id_user"
+ return query.filter_by(record_id_user = user_id)
+
+ def filter_job(query, job):
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find filter_job "
+ return query.filter_by(oar_job_id = job)
+
+ def filer_id_slice (query, id_slice):
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find filer_id_slice"
+ return query.filter_by(record_id_slice = id_slice)
+
+ def filter_slice_hrn(query, hrn):
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find filter_slice_hrn"
+ return query.filter_by(slice_hrn = hrn)
+
+
+ extended_filter = {'record_id_user': filter_id_user,
+ 'oar_job_id':filter_job,
+ 'record_id_slice': filer_id_slice,
+ 'slice_hrn': filter_slice_hrn}
+
+ Q = slab_dbsession.query(SliceSenslab)
+
+ if filter_dict is not None:
for k in filter_dict:
- filter_statement += str(k)+ "==" + str(filter_dict[l])
- filter_statement +=')'
- print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find filter_statement %s"%(filter_statement)
- slab_dbsession.query(SlabSliceDB).filter(filter_statement)
+ try:
+ newQ= extended_filter[k](Q, filter_dict[k])
+ Q = newQ
+ except KeyError:
+ print>>sys.stderr, "\r\n \t\t FFFFFFFFFFFFFFFFUUUUUUUUFUFUFU!!!!!!!!"
+ print>>sys.stderr, " HEEEEEEEEEEEEY %s " %(Q.first())
+ rec = Q.first()
+ print>>sys.stderr, " \r\n \r\n \t SLABPOSTGRES find rec %s" %(rec)
+ return dict(zip(['record_id_user','oar_job_id', 'record_id_slice','slice_hrn'],[rec.record_id_user,rec.oar_job_id,rec.record_id_slice, rec.slice_hrn]))
+ #reclist = []
+ ##for rec in Q.all():
+ #reclist.append(dict(zip(['record_id_user','oar_job_id', 'record_id_slice','slice_hrn'],[rec.record_id_user,rec.oar_job_id,rec.record_id_slice, rec.slice_hrn])))
+ #return reclist
slab_alchemy= SlabDB(Config())
slab_engine=slab_alchemy.slab_engine
-slab_dbsession=slab_alchemy.session()
\ No newline at end of file
+slab_dbsession=slab_alchemy.session()
git://git.onelab.eu / sfa.git / blobdiff