sfa/senslab/table_slab.py

   1 #
   2 # implements support for SFA records stored in db tables
   3 #
   4 # TODO: Use existing PLC database methods? or keep this separate?
   5
   6 import ldap
   7 from sfa.trust.gid import *
   8 from sfa.util.record import *
   9 from sfa.util.config import *
  10 from sfa.util.filter import *
  11 from sfa.trust.hierarchy import *
  12 from sfa.trust.certificate import *
  13 from sfa.trust.auth import *
  14 from sfa.senslab.OARrestapi import *
  15
  16 class SfaTable(list):
  17
  18     def __init__(self, record_filter = None):
  19         self.oar = OARapi()
  20         self.ldapserv=ldap.open("192.168.0.251")
  21         self.senslabauth=Hierarchy()
  22         authinfo=self.senslabauth.get_auth_info("senslab")
  23         self.auth=Auth()
  24         gid=authinfo.get_gid_object()
  25
  26     def exists(self):
  27         return True
  28
  29     def db_fields(self, obj=None):
  30         return dict( [ ] )
  31
  32     @staticmethod
  33     def is_writable (key,value,dict):
  34         # if not mentioned, assume it's writable (e.g. deleted ...)
  35         if key not in dict: return True
  36         # if mentioned but not linked to a Parameter object, idem
  37         if not isinstance(dict[key], Parameter): return True
  38         # if not marked ro, it's writable
  39         if not dict[key].ro: return True
  40
  41         return False
  42
  43
  44     def create(self):
  45         return True
  46
  47     def remove(self, record):
  48         return 0
  49
  50     def insert(self, record):
  51         return 0
  52
  53     def update(self, record):
  54         return 0
  55
  56     def quote_string(self, value):
  57         return str(self.db.quote(value))
  58
  59     def quote(self, value):
  60         return self.db.quote(value)
  61
  62     def ldapFind(self, record_filter = None, columns=None):
  63
  64         results = []
  65
  66         #first, ldap for users
  67
  68         if 'authority' in record_filter:
  69                 # ask for authority
  70                 if record_filter['authority']=='senslab':
  71                         # which is senslab
  72                         # request all records which are under our authority, ie all ldap entries
  73                         ldapfilter="cn=*"
  74                 else:
  75                         #which is NOT senslab
  76                         return []
  77         else :
  78                 if not 'hrn' in record_filter:
  79                         print >>sys.stderr,"find : don't know how to handle filter ",record_filter
  80                         return []
  81                 else:
  82                         hrns=[]
  83                         h=record_filter['hrn']
  84                         if  isinstance(h,list):
  85                                 hrns=h
  86                         else :
  87                                 hrns.append(h)
  88
  89                         ldapfilter="(|"
  90                         for hrn in hrns:
  91                                 splited_hrn=hrn.split(".")
  92                                 if splited_hrn[0] != "senslab" :
  93                                         print >>sys.stderr,"i know nothing about",hrn
  94                                 else :
  95                                         login=splited_hrn[1]
  96                                         ldapfilter+="(uid="
  97                                         ldapfilter+=login
  98                                         ldapfilter+=")"
  99                         ldapfilter+=")"
 100
 101
 102         rindex=self.ldapserv.search("ou=people,dc=senslab,dc=info",ldap.SCOPE_SUBTREE,ldapfilter, ['mail','givenName', 'sn', 'uid','sshPublicKey'])
 103         ldapresponse=self.ldapserv.result(rindex,1)
 104         for ldapentry in ldapresponse[1]:
 105                 hrn="senslab."+ldapentry[1]['uid'][0]
 106                 uuid=create_uuid()
 107
 108                 RSA_KEY_STRING=ldapentry[1]['sshPublicKey'][0]
 109
 110                 pkey=convert_public_key(RSA_KEY_STRING)
 111
 112                 gid=self.senslabauth.create_gid("urn:publicid:IDN+senslab+user+"+ldapentry[1]['uid'][0], uuid, pkey, CA=False)
 113
 114                 parent_hrn = get_authority(hrn)
 115                 parent_auth_info = self.senslabauth.get_auth_info(parent_hrn)
 116
 117                 results.append(  {
 118                         'type': 'user',
 119 #                       'email': ldapentry[1]['mail'][0],
 120 #                       'first_name': ldapentry[1]['givenName'][0],
 121 #                       'last_name': ldapentry[1]['sn'][0],
 122 #                       'phone': 'none',
 123                         'gid': gid.save_to_string(),
 124                         'serial': 'none',
 125                         'authority': 'senslab',
 126                         'peer_authority': '',
 127                         'pointer' : '',
 128                         'hrn': hrn,
 129                         'date_created' : 'none',
 130                         'last_updated': 'none'
 131                         } )
 132         return results
 133
 134     def oarFind(self, record_filter = None, columns=None):
 135         results=[]
 136         node_ids=[]
 137
 138         if 'authority' in record_filter:
 139                 # ask for authority
 140                 if record_filter['authority']=='senslab':
 141                         # which is senslab
 142                         print>> sys.stderr , "ET MERDE !!!!"
 143                         node_ids=""
 144                 else:
 145                         # which is NOT senslab
 146                         return []
 147         else :
 148                 if not 'hrn' in record_filter:
 149                         print >>sys.stderr,"find : don't know how to handle filter ",record_filter
 150                         return []
 151                 else:
 152                         hrns=[]
 153                         h=record_filter['hrn']
 154                         if  isinstance(h,list):
 155                                 hrns=h
 156                         else :
 157                                 hrns.append(h)
 158
 159                         for hrn in hrns:
 160                                 head,sep,tail=hrn.partition(".")
 161                                 if head != "senslab" :
 162                                         print >>sys.stderr,"i know nothing about",hrn
 163                                 else :
 164                                         node_ids.append(tail)
 165
 166         node_list = self.oar.GetNodes( node_ids)
 167
 168         for node in node_list:
 169                 hrn="senslab."+node['hostname']
 170                 results.append(  {
 171                         'type': 'node',
 172 #                       'email': ldapentry[1]['mail'][0],
 173 #                       'first_name': ldapentry[1]['givenName'][0],
 174 #                       'last_name': ldapentry[1]['sn'][0],
 175 #                       'phone': 'none',
 176 #                       'gid': gid.save_to_string(),
 177 #                       'serial': 'none',
 178                         'authority': 'senslab',
 179                         'peer_authority': '',
 180                         'pointer' : '',
 181                         'hrn': hrn,
 182                         'date_created' : 'none',
 183                         'last_updated': 'none'
 184                         } )
 185
 186         return results
 187
 188     def find(self, record_filter = None, columns=None):
 189         # senslab stores its users in an ldap dictionnary
 190         # and nodes in a oar scheduller database
 191         # both should be interrogated.
 192         print >>sys.stderr,"find : ",record_filter
 193         if not isinstance(record_filter,dict):
 194                 print >>sys.stderr,"find : record_filter is not a dict"
 195                 print >>sys.stderr,record_filter.__class__
 196                 return []
 197         allResults=[]
 198         if 'type' in record_filter:
 199                 if record_filter['type'] == 'slice':
 200                         print >>sys.stderr,"find : don't know how to handle slices yet"
 201                         return []
 202                 if record_filter['type'] == 'authority':
 203                         if  'hrn' in  record_filter and record_filter['hrn']=='senslab':
 204                                 return []
 205                         else:
 206                                 print >>sys.stderr,"find which authority ?"
 207                                 return []
 208                 if record_filter['type'] == 'user':
 209                         return self.ldapFind(record_filter, columns)
 210                 if record_filter['type'] == 'node':
 211                         return self.ldapFind(record_filter, columns)
 212                 else:
 213                         print >>sys.stderr,"unknown type to find : ", record_filter['type']
 214                         return []
 215         else:
 216                 allResults = self.ldapFind(record_filter, columns)
 217                 allResults+= self.oarFind(record_filter, columns)
 218
 219         return allResults
 220
 221     def findObjects(self, record_filter = None, columns=None):
 222
 223         print >>sys.stderr,"find : ",record_filter
 224         #        print record_filter['type']
 225         #        if record_filter['type'] in  ['authority']:
 226         #            print "findObjectAuthority"
 227         results = self.find(record_filter, columns)
 228         result_rec_list = []
 229         for result in results:
 230                 if result['type'] in ['authority']:
 231                         result_rec_list.append(AuthorityRecord(dict=result))
 232                 elif result['type'] in ['node']:
 233                         result_rec_list.append(NodeRecord(dict=result))
 234                 elif result['type'] in ['slice']:
 235                         result_rec_list.append(SliceRecord(dict=result))
 236                 elif result['type'] in ['user']:
 237                         result_rec_list.append(UserRecord(dict=result))
 238                 else:
 239                         result_rec_list.append(SfaRecord(dict=result))
 240
 241         return result_rec_list
 242
 243
 244     def drop(self):
 245         return 0
 246
 247     def sfa_records_purge(self):
 248         return 0
 249