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