import repository from arizona
[raven.git] / our-sfa-build / sfa / util / record.py
1 ##
2 # Implements support for SFA records
3 #
4 # TODO: Use existing PLC database methods? or keep this separate?
5 ##
6
7 ### $Id$
8 ### $URL$
9
10 from types import StringTypes
11
12 from sfa.trust.gid import *
13
14 from sfa.util.rspec import *
15 from sfa.util.parameter import *
16 from sfa.util.xrn import get_authority
17 from sfa.util.row import Row
18
19 class SfaRecord(Row):
20     """ 
21     The SfaRecord class implements an SFA Record. A SfaRecord is a tuple
22     (Hrn, GID, Type, Info).
23  
24     Hrn specifies the Human Readable Name of the object
25     GID is the GID of the object
26     Type is user | authority | slice | component
27  
28     Info is comprised of the following sub-fields
29            pointer = a pointer to the record in the PL database
30  
31     The pointer is interpreted depending on the type of the record. For example,
32     if the type=="user", then pointer is assumed to be a person_id that indexes
33     into the persons table.
34  
35     A given HRN may have more than one record, provided that the records are
36     of different types.
37     """
38
39     table_name = 'sfa'
40     
41     primary_key = 'record_id'
42
43     ### the wsdl generator assumes this is named 'fields'
44     internal_fields = {
45         'record_id': Parameter(int, 'An id that uniquely identifies this record', ro=True),
46         'pointer': Parameter(int, 'An id that uniquely identifies this record in an external database ')
47     }
48
49     fields = {
50         'authority': Parameter(str, "The authority for this record"),
51         'peer_authority': Parameter(str, "The peer authority for this record"),
52         'hrn': Parameter(str, "Human readable name of object"),
53         'gid': Parameter(str, "GID of the object"),
54         'type': Parameter(str, "Record type"),
55         'last_updated': Parameter(int, 'Date and time of last update', ro=True),
56         'date_created': Parameter(int, 'Date and time this record was created', ro=True),
57     }
58     all_fields = dict(fields.items() + internal_fields.items())
59     ##
60     # Create an SFA Record
61     #
62     # @param name if !=None, assign the name of the record
63     # @param gid if !=None, assign the gid of the record
64     # @param type one of user | authority | slice | component
65     # @param pointer is a pointer to a PLC record
66     # @param dict if !=None, then fill in this record from the dictionary
67
68     def __init__(self, hrn=None, gid=None, type=None, pointer=None, peer_authority=None, dict=None, string=None):
69         self.dirty = True
70         self.hrn = None
71         self.gid = None
72         self.type = None
73         self.pointer = None
74         self.set_peer_auth(peer_authority)
75         if hrn:
76             self.set_name(hrn)
77         if gid:
78             self.set_gid(gid)
79         if type:
80             self.set_type(type)
81         if pointer:
82             self.set_pointer(pointer)
83         if dict:
84             self.load_from_dict(dict)
85         if string:
86             self.load_from_string(string)
87
88
89     def validate_last_updated(self, last_updated):
90         return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
91         
92     def update(self, new_dict):
93         if isinstance(new_dict, list):
94             new_dict = new_dict[0]
95
96         # Convert any boolean strings to real bools
97         for key in new_dict:
98             if isinstance(new_dict[key], StringTypes):
99                 if new_dict[key].lower() in ["true"]:
100                     new_dict[key] = True
101                 elif new_dict[key].lower() in ["false"]:
102                     new_dict[key] = False
103         dict.update(self, new_dict)
104
105     ##
106     # Set the name of the record
107     #
108     # @param hrn is a string containing the HRN
109
110     def set_name(self, hrn):
111         """
112         Set the name of the record
113         """
114         self.hrn = hrn
115         self['hrn'] = hrn
116         self.dirty = True
117
118     ##
119     # Set the GID of the record
120     #
121     # @param gid is a GID object or the string representation of a GID object
122
123     def set_gid(self, gid):
124         """
125         Set the GID of the record
126         """
127
128         if isinstance(gid, StringTypes):
129             self.gid = gid
130             self['gid'] = gid
131         else:
132             self.gid = gid.save_to_string(save_parents=True)
133             self['gid'] = gid.save_to_string(save_parents=True)
134         self.dirty = True
135
136     ##
137     # Set the type of the record
138     #
139     # @param type is a string: user | authority | slice | component
140
141     def set_type(self, type):
142         """
143         Set the type of the record
144         """
145         self.type = type
146         self['type'] = type
147         self.dirty = True
148
149     ##
150     # Set the pointer of the record
151     #
152     # @param pointer is an integer containing the ID of a PLC record
153
154     def set_pointer(self, pointer):
155         """
156         Set the pointer of the record
157         """
158         self.pointer = pointer
159         self['pointer'] = pointer
160         self.dirty = True
161
162
163     def set_peer_auth(self, peer_authority):
164         self.peer_authority = peer_authority
165         self['peer_authority'] = peer_authority
166         self.dirty = True
167
168     ##
169     # Return the name (HRN) of the record
170
171     def get_name(self):
172         """
173         Return the name (HRN) of the record
174         """
175         return self.hrn
176
177     ##
178     # Return the type of the record
179
180     def get_type(self):
181         """
182         Return the type of the record
183         """
184         return self.type
185
186     ##
187     # Return the pointer of the record. The pointer is an integer that may be
188     # used to look up the record in the PLC database. The evaluation of pointer
189     # depends on the type of the record
190
191     def get_pointer(self):
192         """
193         Return the pointer of the record. The pointer is an integer that may be
194         used to look up the record in the PLC database. The evaluation of pointer
195         depends on the type of the record
196         """
197         return self.pointer
198
199     ##
200     # Return the GID of the record, in the form of a GID object
201     # TODO: not the best name for the function, because we have things called
202     # gidObjects in the Cred
203
204     def get_gid_object(self):
205         """
206         Return the GID of the record, in the form of a GID object
207         """
208         return GID(string=self.gid)
209
210     ##
211     # Returns a list of field names in this record. 
212
213     def get_field_names(self):
214         """
215         Returns a list of field names in this record.
216         """
217         return self.fields.keys()
218
219     ##
220     # Given a field name ("hrn", "gid", ...) return the value of that field.
221     #
222     # @param fieldname is the name of field to be returned
223
224     def get_field_value_string(self, fieldname):
225         """
226         Given a field name ("hrn", "gid", ...) return the value of that field.
227         """
228         if fieldname == "authority":
229             val = get_authority(self['hrn'])
230         else:
231             try:
232                 val = getattr(self, fieldname)
233             except:
234                 val = self[fieldname] 
235         if isinstance(val, str):
236             return "'" + str(val) + "'"
237         else:
238             return str(val)
239
240     ##
241     # Given a list of field names, return a list of values for those public.
242     #
243     # @param fieldnames is a list of field names
244
245     def get_field_value_strings(self, fieldnames):
246         """
247         Given a list of field names, return a list of values for those public.
248         """
249         return [ self.get_field_value_string (fieldname) for fieldname in fieldnames ]
250
251     ##
252     # Return the record in the form of a dictionary
253
254     def as_dict(self):
255         """
256         Return the record in the form of a dictionary
257         """
258         return dict(self)
259
260     ##
261     # Load the record from a dictionary
262     #
263     # @param dict dictionary to load record public from
264
265     def load_from_dict(self, dict):
266         """
267         Load the record from a dictionary 
268         """
269         self.set_name(dict['hrn'])
270         gidstr = dict.get("gid", None)
271         if gidstr:
272             self.set_gid(dict['gid'])
273
274         if "pointer" in dict:
275            self.set_pointer(dict['pointer'])
276
277         self.set_type(dict['type'])
278         self.update(dict)        
279     
280     ##
281     # Save the record to a string. The string contains an XML representation of
282     # the record.
283
284     def save_to_string(self):
285         """
286         Save the record to a string. The string contains an XML representation of
287         the record.
288         """
289         recorddict = self.as_dict()
290         filteredDict = dict([(key, val) for (key, val) in recorddict.iteritems() if key in self.fields.keys()])
291         record = RecordSpec()
292         record.parseDict(filteredDict)
293         str = record.toxml()
294         #str = xmlrpclib.dumps((dict,), allow_none=True)
295         return str
296
297     ##
298     # Load the record from a string. The string is assumed to contain an XML
299     # representation of the record.
300
301     def load_from_string(self, str):
302         """
303         Load the record from a string. The string is assumed to contain an XML
304         representation of the record.
305         """
306         #dict = xmlrpclib.loads(str)[0][0]
307         
308         record = RecordSpec()
309         record.parseString(str)
310         record_dict = record.toDict()
311         sfa_dict = record_dict['record']
312         self.load_from_dict(sfa_dict)
313
314     ##
315     # Dump the record to stdout
316     #
317     # @param dump_parents if true, then the parents of the GID will be dumped
318
319     def dump(self, dump_parents=False):
320         """
321         Walk tree and dump records.
322         """
323         #print "RECORD", self.name
324         #print "        hrn:", self.name
325         #print "       type:", self.type
326         #print "        gid:"
327         #if (not self.gid):
328         #    print "        None"
329         #else:
330         #    self.get_gid_object().dump(8, dump_parents)
331         #print "    pointer:", self.pointer
332        
333         order = SfaRecord.fields.keys() 
334         for key in self.keys():
335             if key not in order:
336                 order.append(key)
337         for key in order:
338             if key in self and key in self.fields:
339                 if key in 'gid' and self[key]:
340                     gid = GID(string=self[key])
341                     print "     %s:" % key
342                     gid.dump(8, dump_parents)
343                 else:    
344                     print "     %s: %s" % (key, self[key])
345     
346     def getdict(self):
347         return dict(self)
348     
349
350 class UserRecord(SfaRecord):
351
352     fields = {
353         'email': Parameter(str, 'email'),
354         'first_name': Parameter(str, 'First name'),
355         'last_name': Parameter(str, 'Last name'),
356         'phone': Parameter(str, 'Phone Number'),
357         'keys': Parameter(str, 'Public key'),
358         'slices': Parameter([str], 'List of slices this user belongs to'),
359         }
360     fields.update(SfaRecord.fields)
361     
362 class SliceRecord(SfaRecord):
363     fields = {
364         'name': Parameter(str, 'Slice name'),
365         'url': Parameter(str, 'Slice url'),
366         'expires': Parameter(int, 'Date and time this slice exipres'),
367         'researcher': Parameter([str], 'List of users for this slice'),
368         'PI': Parameter([str], 'List of PIs responsible for this slice'),
369         'description': Parameter([str], 'Description of this slice'), 
370         }
371     fields.update(SfaRecord.fields)
372
373  
374 class NodeRecord(SfaRecord):
375     fields = {
376         'hostname': Parameter(str, 'This nodes dns name'),
377         'node_type': Parameter(str, 'Type of node this is'),
378         'node_type': Parameter(str, 'Type of node this is'),
379         'latitude': Parameter(str, 'latitude'),
380         'longitude': Parameter(str, 'longitude'),
381         }
382     fields.update(SfaRecord.fields)
383
384
385 class AuthorityRecord(SfaRecord):
386     fields =  {
387         'name': Parameter(str, 'Name'),
388         'login_base': Parameter(str, 'login base'),
389         'enabled': Parameter(bool, 'Is this site enabled'),
390         'url': Parameter(str, 'URL'),
391         'nodes': Parameter([str], 'List of nodes at this site'),  
392         'operator': Parameter([str], 'List of operators'),
393         'researcher': Parameter([str], 'List of researchers'),
394         'PI': Parameter([str], 'List of Principal Investigators'),
395         }
396     fields.update(SfaRecord.fields)
397     
398