# as we're overwriting some user data here
if driver_key in record:
logger.warning ("normalize_input: incoming record has both values, using %s"%reg_key)
- record[driver_key]=record[reg_key]
+ record[driver_key] = record[reg_key]
# we only have one key set, duplicate for the other one
elif driver_key in record:
logger.warning ("normalize_input: you should use '%s' instead of '%s'"%(reg_key,driver_key))
- record[reg_key]=record[driver_key]
+ record[reg_key] = record[driver_key]
def normalize_input_record (record):
_normalize_input (record, 'reg-researchers','researcher')
# xxx the keys thing could use a little bit more attention:
# some parts of the code are using 'keys' while they should use 'reg-keys'
# but I run out of time for now
- if 'reg-keys' in record: record['keys']=record['reg-keys']
+ if 'reg-keys' in record:
+ record['keys'] = record['reg-keys']
return record
class RegistryManager:
local_records=local_records.all()
for local_record in local_records:
- augment_with_sfa_builtins (local_record)
+ augment_with_sfa_builtins(local_record)
logger.info("Resolve, (details=%s,type=%s) local_records=%s "%(details,type,local_records))
local_dicts = [ record.__dict__ for record in local_records ]
# xxx somehow here calling dict(record) issues a weird error
# however record.todict() seems to work fine
# records.extend( [ dict(record) for record in local_records ] )
- records.extend( [ record.todict(exclude_types=[InstrumentedList]) for record in local_records ] )
+ records.extend( [ record.record_to_dict(exclude_types=(InstrumentedList,)) for record in local_records ] )
if not records:
raise RecordNotFound(str(hrns))
def List (self, api, xrn, origin_hrn=None, options=None):
if options is None: options={}
- dbsession=api.dbsession()
+ dbsession = api.dbsession()
# load all know registry names into a prefix tree and attempt to find
# the longest matching prefix
hrn, type = urn_to_hrn(xrn)
records = dbsession.query(RegRecord).filter_by(authority=hrn).all()
# logger.debug("non recursive mode, found %d local records"%(len(records)))
# so that sfi list can show more than plain names...
- for record in records: augment_with_sfa_builtins (record)
- record_dicts=[ record.todict(exclude_types=[InstrumentedList]) for record in records ]
+ for record in records:
+ # xxx mystery - again this useless statement is key here so that
+ # resulting records have their __dict__ field actually in line with the
+ # object's contents; was first observed with authorities' 'name' column
+ # that would be missing from result as received by client
+ # record.todict() is the place where __dict__ is used
+ print "DO NOT REMOVE ME before augment_with_sfa_builtins, record=%s"%record
+ augment_with_sfa_builtins(record)
+ record_dicts = [ record.record_to_dict(exclude_types=(InstrumentedList,)) for record in records ]
return record_dicts
-
def CreateGid(self, api, xrn, cert):
# get the authority
authority = Xrn(xrn=xrn).get_authority_hrn()
else:
certificate = Certificate(string=cert)
pkey = certificate.get_pubkey()
- gid = api.auth.hierarchy.create_gid(xrn, create_uuid(), pkey)
+
+ # Add the email of the user to SubjectAltName in the GID
+ email = None
+ hrn = Xrn(xrn).get_hrn()
+ dbsession = api.dbsession()
+ record=dbsession.query(RegUser).filter_by(hrn=hrn).first()
+ if record:
+ email = getattr(record,'email',None)
+ gid = api.auth.hierarchy.create_gid(xrn, create_uuid(), pkey, email=email)
return gid.save_to_string(save_parents=True)
####################
# hrns is the list of hrns that should be linked to the subject from now on
# target_type would be e.g. 'user' in the 'slice' x 'researcher' example
def update_driver_relation (self, api, record_obj, hrns, target_type, relation_name):
- dbsession=api.dbsession()
+ dbsession = api.dbsession()
# locate the linked objects in our db
subject_type=record_obj.type
subject_id=record_obj.pointer
normalize_input_record (record_dict)
logger.debug("Register: normalized record_dict=%s"%printable(record_dict))
- dbsession=api.dbsession()
+ dbsession = api.dbsession()
hrn, type = record_dict['hrn'], record_dict['type']
urn = hrn_to_urn(hrn,type)
# validate the type
if pub_key and isinstance(pub_key, types.ListType): pub_key = pub_key[0]
pkey = convert_public_key(pub_key)
- gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
+ email = getattr(record,'email',None)
+ gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey, email = email)
gid = gid_object.save_to_string(save_parents=True)
record.gid = gid
normalize_input_record (record_dict)
logger.debug("Update: normalized record_dict=%s"%printable(record_dict))
- dbsession=api.dbsession()
+ dbsession = api.dbsession()
assert ('type' in record_dict)
- new_record=make_record(dict=record_dict)
- (type,hrn) = (new_record.type, new_record.hrn)
+ new_record = make_record(dict=record_dict)
+ (type, hrn) = (new_record.type, new_record.hrn)
# make sure the record exists
- record = dbsession.query(RegRecord).filter_by(type=type,hrn=hrn).first()
+ record = dbsession.query(RegRecord).filter_by(type=type, hrn=hrn).first()
if not record:
- raise RecordNotFound("hrn=%s, type=%s"%(hrn,type))
+ raise RecordNotFound("hrn={}, type={}".format(hrn, type))
record.just_updated()
# Use the pointer from the existing record, not the one that the user
# gave us. This prevents the user from inserting a forged pointer
pointer = record.pointer
-
+
# is there a change in keys ?
- new_key=None
- if type=='user':
- if getattr(new_record,'keys',None):
- new_key=new_record.keys
- if isinstance (new_key,types.ListType):
- new_key=new_key[0]
+ new_key = None
+ if type == 'user':
+ if getattr(new_record, 'keys', None):
+ new_key = new_record.keys
+ if isinstance (new_key, types.ListType):
+ new_key = new_key[0]
# take new_key into account
if new_key:
pkey = convert_public_key(new_key)
uuid = create_uuid()
urn = hrn_to_urn(hrn,type)
- gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
+
+ email = getattr(new_record, 'email', None)
+ if email is None:
+ email = getattr(record, 'email', None)
+ gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey, email = email)
gid = gid_object.save_to_string(save_parents=True)
# xxx should do side effects from new_record to record
# not too big a deal with planetlab as the driver is authoritative, but...
# update native relations
- if isinstance (record, RegSlice):
- researcher_hrns = getattr(new_record,'reg-researchers',None)
- if researcher_hrns is not None: record.update_researchers (researcher_hrns, dbsession)
-
- elif isinstance (record, RegAuthority):
- pi_hrns = getattr(new_record,'reg-pis',None)
- if pi_hrns is not None: record.update_pis (pi_hrns, dbsession)
+ if isinstance(record, RegSlice):
+ researcher_hrns = getattr(new_record, 'reg-researchers', None)
+ if researcher_hrns is not None:
+ record.update_researchers (researcher_hrns, dbsession)
+
+ elif isinstance(record, RegAuthority):
+ pi_hrns = getattr(new_record, 'reg-pis', None)
+ if pi_hrns is not None:
+ record.update_pis(pi_hrns, dbsession)
+ name = getattr(new_record, 'name', None)
+ if name is not None:
+ record.name = name
+
+ elif isinstance(record, RegUser):
+ email = getattr(new_record, 'email', None)
+ if email is not None:
+ record.email = email
# update the PLC information that was specified with the record
- # xxx oddly enough, without this useless statement,
+ # xxx mystery: oddly enough, without this useless statement,
# record.__dict__ as received by the driver seems to be off
# anyway the driver should receive an object
# (and then extract __dict__ itself if needed)
except:
pass
if new_key and new_key_pointer:
- record.reg_keys=[ RegKey (new_key, new_key_pointer)]
+ record.reg_keys = [ RegKey (new_key, new_key_pointer)]
record.gid = gid
dbsession.commit()
# update membership for researchers, pis, owners, operators
- self.update_driver_relations (api, record, new_record)
+ self.update_driver_relations(api, record, new_record)
return 1
# expecting an Xrn instance
def Remove(self, api, xrn, origin_hrn=None):
- dbsession=api.dbsession()
+ dbsession = api.dbsession()
hrn=xrn.get_hrn()
type=xrn.get_type()
request=dbsession.query(RegRecord).filter_by(hrn=hrn)
# This is a PLC-specific thing, won't work with other platforms
def get_key_from_incoming_ip (self, api):
- dbsession=api.dbsession()
+ dbsession = api.dbsession()
# verify that the callers's ip address exist in the db and is an interface
# for a node in the db
(ip, port) = api.remote_addr
uuid = create_uuid()
pkey = Keypair(create=True)
urn = hrn_to_urn(record.hrn, record.type)
- gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
+
+ email = getattr(record, 'email', None)
+ gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey, email)
gid = gid_object.save_to_string(save_parents=True)
record.gid = gid
git://git.onelab.eu / sfa.git / blobdiff