2 # Implements support for geni records
4 # TODO: Use existing PLC database methods? or keep this separate?
8 from types import StringTypes
10 from geni.util.rspec import *
12 # The GeniRecord class implements a Geni Record. A GeniRecord is a tuple
13 # (Name, GID, Type, Info).
15 # Name specifies the HRN of the object
16 # GID is the GID of the object
17 # Type is user | sa | ma | slice | component
19 # Info is comprised of the following sub-fields
20 # pointer = a pointer to the record in the PL database
21 # pl_info = planetlab-specific info (when talking to client)
22 # geni_info = geni-specific info (when talking to client)
24 # The pointer is interpreted depending on the type of the record. For example,
25 # if the type=="user", then pointer is assumed to be a person_id that indexes
26 # into the persons table.
28 # A given HRN may have more than one record, provided that the records are
29 # of different types. For example, planetlab.us.arizona may have both an SA
30 # and a MA record, but cannot have two SA records.
35 # Create a Geni Record
37 # @param name if !=None, assign the name of the record
38 # @param gid if !=None, assign the gid of the record
39 # @param type one of user | sa | ma | slice | component
40 # @param pointer is a pointer to a PLC record
41 # @param dict if !=None, then fill in this record from the dictionary
43 def __init__(self, name=None, gid=None, type=None, pointer=None, dict=None, string=None):
58 self.set_pointer(pointer)
60 self.load_from_dict(dict)
62 self.load_from_string(string)
65 # Set the name of the record
67 # @param name is a string containing the HRN
69 def set_name(self, name):
74 # Set the GID of the record
76 # @param gid is a GID object or the string representation of a GID object
78 def set_gid(self, gid):
79 if isinstance(gid, StringTypes):
82 self.gid = gid.save_to_string(save_parents=True)
86 # Set the type of the record
88 # @param type is a string: user | sa | ma | slice | component
90 def set_type(self, type):
95 # Set the pointer of the record
97 # @param pointer is an integer containing the ID of a PLC record
99 def set_pointer(self, pointer):
100 self.pointer = pointer
104 # Set the PLC info of the record
106 # @param pl_info is a dictionary containing planetlab info
108 def set_pl_info(self, pl_info):
109 self.pl_info = pl_info
113 # Set the geni info the record
115 # @param geni_info is a dictionary containing geni info
117 def set_geni_info(self, geni_info):
118 self.geni_info = geni_info
122 # Return the pl_info of the record, or an empty dictionary if none exists
124 def get_pl_info(self):
131 # Return the geni_info of the record, or an empty dictionary if none exists
133 def get_geni_info(self):
135 return self.geni_info
140 # Return the name (HRN) of the record
146 # Return the type of the record
152 # Return the pointer of the record. The pointer is an integer that may be
153 # used to look up the record in the PLC database. The evaluation of pointer
154 # depends on the type of the record
156 def get_pointer(self):
160 # Return the GID of the record, in the form of a GID object
161 # TODO: not the best name for the function, because we have things called
162 # gidObjects in the Cred
164 def get_gid_object(self):
165 return GID(string=self.gid)
168 # Return a key that uniquely identifies this record among all records in
169 # Geni. This key is used to uniquely identify the record in the Geni
173 return self.name + "#" + self.type
176 # Returns a list of field names in this record. pl_info, geni_info are not
177 # included because they are not part of the record that is stored in the
178 # database, but are rather computed values from other entities
180 def get_field_names(self):
181 return ["name", "gid", "type", "pointer"]
184 # Given a field name ("name", "gid", ...) return the value of that field.
186 # @param name is the name of field to be returned
188 def get_field_value_string(self, fieldname):
189 if fieldname == "key":
192 val = getattr(self, fieldname)
193 if isinstance(val, str):
194 return "'" + str(val) + "'"
199 # Given a list of field names, return a list of values for those fields.
201 # @param fieldnames is a list of field names
203 def get_field_value_strings(self, fieldnames):
205 for fieldname in fieldnames:
206 strs.append(self.get_field_value_string(fieldname))
210 # Return the record in the form of a dictionary
214 names = self.get_field_names()
216 dict[name] = getattr(self, name)
219 dict['pl_info'] = self.pl_info
222 dict['geni_info'] = self.geni_info
227 # Load the record from a dictionary
229 # @param dict dictionary to load record fields from
231 def load_from_dict(self, dict):
232 self.set_name(dict['name'])
233 gidstr = dict.get("gid", None)
235 self.set_gid(dict['gid'])
237 self.set_type(dict['type'])
238 self.set_pointer(dict['pointer'])
239 if "pl_info" in dict:
240 self.set_pl_info(dict["pl_info"])
241 if "geni_info" in dict:
242 self.set_geni_info(dict["geni_info"])
245 # Save the record to a string. The string contains an XML representation of
248 def save_to_string(self):
250 dict = self.as_dict()
251 record = RecordSpec()
252 record.parseDict(dict)
254 #str = xmlrpclib.dumps((dict,), allow_none=True)
258 # Load the record from a string. The string is assumed to contain an XML
259 # representation of the record.
261 def load_from_string(self, str):
262 #dict = xmlrpclib.loads(str)[0][0]
264 record = RecordSpec()
265 record.parseString(str)
266 record_dict = record.toDict()
267 geni_dict = record_dict['record']
268 self.load_from_dict(geni_dict)
271 # Dump the record to stdout
273 # @param dump_parents if true, then the parents of the GID will be dumped
275 def dump(self, dump_parents=False):
276 print "RECORD", self.name
277 print " hrn:", self.name
278 print " type:", self.type
283 self.get_gid_object().dump(8, dump_parents)
284 print " pointer:", self.pointer
287 geni_info = getattr(self, "geni_info", {})
289 for key in geni_info.keys():
290 print " ", key, ":", geni_info[key]
293 pl_info = getattr(self, "pl_info", {})
296 for key in pl_info.keys():
297 print " ", key, ":", pl_info[key]
301 info = {'hrn': self.name, 'type': self.type, 'gid': self.gid}
302 info.update(getattr(self, "geni_info", {}))
303 info.update(getattr(self, "pl_info", {}))