from sfa.util.version import version_core
from sfa.util.sfalogging import logger
+from sfa.util.printable import printable
+
from sfa.trust.gid import GID
from sfa.trust.credential import Credential
from sfa.trust.certificate import Certificate, Keypair, convert_public_key
# them on the xmlrpc wire
from sqlalchemy.orm.collections import InstrumentedList
+### historical note -- april 2014
+# the myslice chaps rightfully complained about the following discrepancy
+# they found that
+# * read operations (resolve) expose stuff like e.g.
+# 'reg-researchers', or 'reg-pis', but that
+# * write operations (register, update) need e.g.
+# 'researcher' or 'pi' to be set - reg-* are just ignored
+#
+# the '_normalize_input' helper functions below aim at ironing this out
+# however in order to break as few code as possible we essentially make sure that *both* fields are set
+# upon entering the write methods (so again register and update) for legacy, as some driver code
+# might depend on the presence of, say, 'researcher'
+
+# normalize an input record to a write method - register or update
+# e.g. registry calls this 'reg-researchers'
+# while some drivers call this 'researcher'
+# we need to make sure that both keys appear and are the same
+def _normalize_input (record, reg_key, driver_key):
+ # this looks right, use this for both keys
+ if reg_key in record:
+ # and issue a warning if they were both set and different
+ # 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]
+ # 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]
+
+def normalize_input_record (record):
+ _normalize_input (record, 'reg-researchers','researcher')
+ _normalize_input (record, 'reg-pis','pi')
+ _normalize_input (record, 'reg-keys','keys')
+ # 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']
+ return record
+
class RegistryManager:
def __init__ (self, config):
def GetVersion(self, api, options):
peers = dict ( [ (hrn,interface.get_url()) for (hrn,interface) in api.registries.iteritems()
if hrn != api.hrn])
- xrn=Xrn(api.hrn)
+ xrn=Xrn(api.hrn,type='authority')
return version_core({'interface':'registry',
- 'sfa': 2,
- 'geni_api': 2,
+ 'sfa': 3,
'hrn':xrn.get_hrn(),
'urn':xrn.get_urn(),
'peers':peers})
- def GetCredential(self, api, xrn, type, caller_xrn=None):
- dbsession = api.dbsession()
+ def GetCredential(self, api, xrn, input_type, caller_xrn=None):
# convert xrn to hrn
- if type:
- hrn = urn_to_hrn(xrn)[0]
+ if input_type:
+ hrn, _ = urn_to_hrn(xrn)
+ type = input_type
else:
hrn, type = urn_to_hrn(xrn)
# Slivers don't have credentials but users should be able to
# specify a sliver xrn and receive the slice's credential
- if type == 'sliver' or '-' in Xrn(hrn).leaf:
+ # However if input_type is specified
+ if type == 'sliver' or ( not input_type and '-' in Xrn(hrn).leaf):
slice_xrn = api.driver.sliver_to_slice_xrn(hrn)
hrn = slice_xrn.hrn
if not auth_hrn or hrn == api.config.SFA_INTERFACE_HRN:
auth_hrn = hrn
auth_info = api.auth.get_auth_info(auth_hrn)
+
# get record info
+ dbsession = api.dbsession()
record=dbsession.query(RegRecord).filter_by(type=type,hrn=hrn).first()
if not record:
raise RecordNotFound("hrn=%s, type=%s"%(hrn,type))
return records
- def List (self, api, xrn, origin_hrn=None, options={}):
+ def List (self, api, xrn, origin_hrn=None, options=None):
+ if options is None: options={}
dbsession=api.dbsession()
# load all know registry names into a prefix tree and attempt to find
# the longest matching prefix
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)
####################
def Register(self, api, record_dict):
+ logger.debug("Register: entering with record_dict=%s"%printable(record_dict))
+ normalize_input_record (record_dict)
+ logger.debug("Register: normalized record_dict=%s"%printable(record_dict))
+
dbsession=api.dbsession()
hrn, type = record_dict['hrn'], record_dict['type']
urn = hrn_to_urn(hrn,type)
if not record.gid:
uuid = create_uuid()
pkey = Keypair(create=True)
- if getattr(record,'keys',None):
- pub_key=record.keys
+ pub_key=getattr(record,'reg-keys',None)
+ if pub_key is not None:
# use only first key in record
- if isinstance(record.keys, types.ListType):
- pub_key = record.keys[0]
+ 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
record.gid=gid.save_to_string(save_parents=True)
# locate objects for relationships
- pi_hrns = getattr(record,'pi',None)
+ pi_hrns = getattr(record,'reg-pis',None)
if pi_hrns is not None: record.update_pis (pi_hrns, dbsession)
elif isinstance (record, RegSlice):
- researcher_hrns = getattr(record,'researcher',None)
+ researcher_hrns = getattr(record,'reg-researchers',None)
if researcher_hrns is not None: record.update_researchers (researcher_hrns, dbsession)
elif isinstance (record, RegUser):
# create RegKey objects for incoming keys
- if hasattr(record,'keys'):
- logger.debug ("creating %d keys for user %s"%(len(record.keys),record.hrn))
- record.reg_keys = [ RegKey (key) for key in record.keys ]
+ if hasattr(record,'reg-keys'):
+ keys=getattr(record,'reg-keys')
+ # some people send the key as a string instead of a list of strings
+ if isinstance(keys,types.StringTypes): keys=[keys]
+ logger.debug ("creating %d keys for user %s"%(len(keys),record.hrn))
+ record.reg_keys = [ RegKey (key) for key in keys ]
# update testbed-specific data if needed
pointer = api.driver.register (record.__dict__, hrn, pub_key)
return record.get_gid_object().save_to_string(save_parents=True)
def Update(self, api, record_dict):
+
+ logger.debug("Update: entering with record_dict=%s"%printable(record_dict))
+ normalize_input_record (record_dict)
+ logger.debug("Update: normalized record_dict=%s"%printable(record_dict))
+
dbsession=api.dbsession()
assert ('type' in record_dict)
new_record=make_record(dict=record_dict)
# 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':
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
# update native relations
if isinstance (record, RegSlice):
- researcher_hrns = getattr(new_record,'researcher',None)
+ 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,'pi',None)
+ pi_hrns = getattr(new_record,'reg-pis',None)
if pi_hrns is not None: record.update_pis (pi_hrns, dbsession)
# update the PLC information that was specified with the record
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