from sfa.util.faults import *
from sfa.util.prefixTree import prefixTree
from sfa.util.record import SfaRecord
-from sfa.util.table import SfaTable
+from sfa.senslab.table_slab import SfaTable
from sfa.util.record import SfaRecord
from sfa.trust.gid import GID
from sfa.util.xrn import Xrn, get_leaf, get_authority, hrn_to_urn, urn_to_hrn
from sfa.trust.certificate import Certificate, Keypair
from sfa.trust.gid import create_uuid
from sfa.util.version import version_core
+from sfa.senslab.api import *
+myapi=SfaAPI()
# The GENI GetVersion call
def GetVersion(api):
- peers =dict ([ (peername,v._ServerProxy__host) for (peername,v) in api.registries.iteritems()
- if peername != api.hrn])
- xrn=Xrn(api.hrn)
+
+ peers =dict ([ (peername,v._ServerProxy__host) for (peername,v) in myapi.registries.iteritems()
+ if peername != myapi.hrn])
+ xrn=Xrn(myapi.hrn)
return version_core({'interface':'registry',
'hrn':xrn.get_hrn(),
'urn':xrn.get_urn(),
hrn, type = urn_to_hrn(xrn)
# Is this a root or sub authority
- auth_hrn = api.auth.get_authority(hrn)
- print>> sys.stderr , " \r\n REGISTRY get_credential auth_hrn" , auth_hrn
- if not auth_hrn or hrn == api.config.SFA_INTERFACE_HRN:
+ auth_hrn = myapi.auth.get_authority(hrn)
+ print>> sys.stderr , " \r\n REGISTRY get_credential auth_hrn:" , auth_hrn,"hrn : ", hrn, " Type : ", type, "is self : " , is_self,"<<"
+ if not auth_hrn or hrn == myapi.config.SFA_INTERFACE_HRN:
auth_hrn = hrn
# get record info
- auth_info = api.auth.get_auth_info(auth_hrn)
+ auth_info = myapi.auth.get_auth_info(auth_hrn)
table = SfaTable()
+ print >> sys.stderr , " findObject ", type, hrn
records = table.findObjects({'type': type, 'hrn': hrn})
print>> sys.stderr , " \r\n ++ REGISTRY get_credential hrn %s records %s " %(hrn, records)
if not records:
# verify_cancreate_credential requires that the member lists
# (researchers, pis, etc) be filled in
- api.fill_record_info(record)
+ myapi.fill_record_info(record)
record['enabled'] = True
print>> sys.stderr , " \r\n ++ REGISTRY get_credential hrn %s record['enabled'] %s is_self %s" %(hrn, record['enabled'], is_self)
if record['type']=='user':
print>>sys.stderr, " \r\n REGISTRY IS SELF OK caller_hrn %s--- \r\n caller_gid %s---------" %(caller_hrn,caller_gid)
else:
print>> sys.stderr , " \r\n ++ ELSE "
- caller_gid = api.auth.client_cred.get_gid_caller()
+ caller_gid = myapi.auth.client_cred.get_gid_caller()
print>> sys.stderr , " \r\n ++ ELSE caller_gid %s record %s" %(caller_gid, record)
caller_hrn = caller_gid.get_hrn()
print>> sys.stderr , " \r\n ++ ELSE caller_hrn %s " %(caller_hrn)
object_hrn = record.get_gid_object().get_hrn()
print>> sys.stderr , " \r\n ++ ELSE object_hrn %s " %(object_hrn)
- rights = api.auth.determine_user_rights(caller_hrn, record)
+ rights = myapi.auth.determine_user_rights(caller_hrn, record)
print>> sys.stderr , " \r\n ++ After rights record: %s \r\n ====RIGHTS %s " %(record , rights)
# make sure caller has rights to this object
new_cred.set_expiration(int(record['expires']))
auth_kind = "authority,ma,sa"
# Parent not necessary, verify with certs
- #new_cred.set_parent(api.auth.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
+ #new_cred.set_parent(myapi.auth.hierarchy.get_auth_cred(auth_hrn, kind=auth_kind))
new_cred.encode()
new_cred.sign()
# hrns at that registry (determined by the known prefix tree).
xrn_dict = {}
print >>sys.stderr, '\r\n REGISTRY MANAGER : resolve xrns ' , xrns #api.__dict__.keys()
- registries = api.registries
+ registries = myapi.registries
tree = prefixTree()
registry_hrns = registries.keys()
print >>sys.stderr, '\r\n \t\t REGISTRY MANAGER registry_hrns' , registry_hrns
# if the best match (longest matching hrn) is not the local registry,
# forward the request
xrns = xrn_dict[registry_hrn]
- if registry_hrn != api.hrn:
- credential = api.getCredential()
+ if registry_hrn != myapi.hrn:
+ credential = myapi.getCredential()
peer_records = registries[registry_hrn].Resolve(xrns, credential)
print >>sys.stderr , '\t\t peer_records ', peer_records
records.extend([SfaRecord(dict=record).as_dict() for record in peer_records])
print >>sys.stderr, '\t\t resolve regmanager : rec ', rec
if full:
- print >>sys.stderr, '\r\n \r\n REGISTRY:_FULL', api
- api.fill_record_info(local_records)
+ print >>sys.stderr, '\r\n \r\n REGISTRY:_FULL', myapi
+ myapi.fill_record_info(local_records)
# convert local record objects to dicts
# load all know registry names into a prefix tree and attempt to find
# the longest matching prefix
records = []
- registries = api.registries
+ registries = myapi.registries
registry_hrns = registries.keys()
tree = prefixTree()
tree.load(registry_hrns)
# if the best match (longest matching hrn) is not the local registry,
# forward the request
records = []
- if registry_hrn != api.hrn:
- credential = api.getCredential()
+ if registry_hrn != myapi.hrn:
+ credential = myapi.getCredential()
record_list = registries[registry_hrn].List(xrn, credential)
records = [SfaRecord(dict=record).as_dict() for record in record_list]
# if we still have not found the record yet, try the local registry
if not records:
- if not api.auth.hierarchy.auth_exists(hrn):
+ if not myapi.auth.hierarchy.auth_exists(hrn):
raise MissingAuthority(hrn)
table = SfaTable()
record['authority'] = get_authority(record['hrn'])
type = record['type']
hrn = record['hrn']
- api.auth.verify_object_permission(hrn)
- auth_info = api.auth.get_auth_info(record['authority'])
+ myapi.auth.verify_object_permission(hrn)
+ auth_info = myapi.auth.get_auth_info(record['authority'])
pub_key = None
# make sure record has a gid
if 'gid' not in record:
pub_key = record['key']
pkey = convert_public_key(pub_key)
- gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
+ gid_object = myapi.auth.hierarchy.create_gid(urn, uuid, pkey)
gid = gid_object.save_to_string(save_parents=True)
record['gid'] = gid
record.set_gid(gid)
if type in ["authority"]:
# update the tree
- if not api.auth.hierarchy.auth_exists(hrn):
- api.auth.hierarchy.create_auth(hrn_to_urn(hrn,'authority'))
+ if not myapi.auth.hierarchy.auth_exists(hrn):
+ myapi.auth.hierarchy.create_auth(hrn_to_urn(hrn,'authority'))
# get the GID from the newly created authority
gid = auth_info.get_gid_object()
record.set_gid(gid.save_to_string(save_parents=True))
- pl_record = api.sfa_fields_to_pl_fields(type, hrn, record)
- sites = api.oar.GetSites( [pl_record['login_base']])
+ pl_record = myapi.sfa_fields_to_pl_fields(type, hrn, record)
+ sites = myapi.oar.GetSites( [pl_record['login_base']])
if not sites:
- pointer = api.oar.AddSite( pl_record)
+ pointer = myapi.oar.AddSite( pl_record)
else:
pointer = sites[0]['site_id']
elif (type == "slice"):
acceptable_fields=['url', 'instantiation', 'name', 'description']
- pl_record = api.sfa_fields_to_pl_fields(type, hrn, record)
+ pl_record = myapi.sfa_fields_to_pl_fields(type, hrn, record)
print>>sys.stderr, " \r\n \r\n ----------- registry_manager_slab register slice pl_record %s"%(pl_record)
for key in pl_record.keys():
if key not in acceptable_fields:
pl_record.pop(key)
- slices = api.users.GetSlices( [pl_record['name']])
+ slices = myapi.users.GetSlices( [pl_record['name']])
if not slices:
- pointer = api.users.AddSlice(pl_record)
+ pointer = myapi.users.AddSlice(pl_record)
else:
pointer = slices[0]['slice_id']
record.set_pointer(pointer)
record['pointer'] = pointer
elif (type == "user"):
- persons = api.users.GetPersons( [record['email']])
+ persons = myapi.users.GetPersons( [record['email']])
if not persons:
print>>sys.stderr, " \r\n \r\n ----------- registry_manager_slab register NO PERSON ADD TO LDAP?"
#if not persons:
- #pointer = api.users.AddPerson( dict(record))
+ #pointer = myapi.users.AddPerson( dict(record))
#else:
#pointer = persons[0]['person_id']
if 'enabled' in record and record['enabled']:
- api.users.UpdatePerson( pointer, {'enabled': record['enabled']})
+ myapi.users.UpdatePerson( pointer, {'enabled': record['enabled']})
# add this persons to the site only if he is being added for the first
# time by sfa and doesont already exist in plc
if not persons or not persons[0]['site_ids']:
login_base = get_leaf(record['authority'])
- api.users.AddPersonToSite( pointer, login_base)
+ myapi.users.AddPersonToSite( pointer, login_base)
# What roles should this user have?
- api.users.AddRoleToPerson( 'user', pointer)
+ myapi.users.AddRoleToPerson( 'user', pointer)
# Add the user's key
if pub_key:
- api.users.AddPersonKey( pointer, {'key_type' : 'ssh', 'key' : pub_key})
+ myapi.users.AddPersonKey( pointer, {'key_type' : 'ssh', 'key' : pub_key})
#elif (type == "node"):
- #pl_record = api.sfa_fields_to_pl_fields(type, hrn, record)
+ #pl_record = myapi.sfa_fields_to_pl_fields(type, hrn, record)
#login_base = hrn_to_pl_login_base(record['authority'])
- #nodes = api.oar.GetNodes( [pl_record['hostname']])
+ #nodes = myapi.oar.GetNodes( [pl_record['hostname']])
#if not nodes:
- #pointer = api.oar.AddNode(login_base, pl_record)
+ #pointer = myapi.oar.AddNode(login_base, pl_record)
#else:
#pointer = nodes[0]['node_id']
record['record_id'] = record_id
# update membership for researchers, pis, owners, operators
- api.update_membership(None, record)
+ myapi.update_membership(None, record)
return record.get_gid_object().save_to_string(save_parents=True)
type = new_record['type']
hrn = new_record['hrn']
urn = hrn_to_urn(hrn,type)
- api.auth.verify_object_permission(hrn)
+ myapi.auth.verify_object_permission(hrn)
table = SfaTable()
# make sure the record exists
records = table.findObjects({'type': type, 'hrn': hrn})
# Update_membership needs the membership lists in the existing record
# filled in, so it can see if members were added or removed
- api.fill_record_info(record)
+ myapi.fill_record_info(record)
# Use the pointer from the existing record, not the one that the user
# gave us. This prevents the user from inserting a forged pointer
# update the PLC information that was specified with the record
if (type == "authority"):
- api.oar.UpdateSite( pointer, new_record)
+ myapi.oar.UpdateSite( pointer, new_record)
elif type == "slice":
- pl_record=api.sfa_fields_to_pl_fields(type, hrn, new_record)
+ pl_record=myapi.sfa_fields_to_pl_fields(type, hrn, new_record)
if 'name' in pl_record:
pl_record.pop('name')
- api.users.UpdateSlice( pointer, pl_record)
+ myapi.users.UpdateSlice( pointer, pl_record)
elif type == "user":
# SMBAKER: UpdatePerson only allows a limited set of fields to be
'password', 'phone', 'url', 'bio', 'accepted_aup',
'enabled']:
update_fields[key] = all_fields[key]
- api.users.UpdatePerson( pointer, update_fields)
+ myapi.users.UpdatePerson( pointer, update_fields)
if 'key' in new_record and new_record['key']:
# must check this key against the previous one if it exists
- persons = api.users.GetPersons( [pointer], ['key_ids'])
+ persons = myapi.users.GetPersons( [pointer], ['key_ids'])
person = persons[0]
keys = person['key_ids']
- keys = api.users.GetKeys( person['key_ids'])
+ keys = myapi.users.GetKeys( person['key_ids'])
key_exists = False
if isinstance(new_record['key'], types.ListType):
new_key = new_record['key'][0]
# Delete all stale keys
for key in keys:
if new_record['key'] != key['key']:
- api.users.DeleteKey( key['key_id'])
+ myapi.users.DeleteKey( key['key_id'])
else:
key_exists = True
if not key_exists:
- api.users.AddPersonKey( pointer, {'key_type': 'ssh', 'key': new_key})
+ myapi.users.AddPersonKey( pointer, {'key_type': 'ssh', 'key': new_key})
# update the openssl key and gid
pkey = convert_public_key(new_key)
uuid = create_uuid()
- gid_object = api.auth.hierarchy.create_gid(urn, uuid, pkey)
+ gid_object = myapi.auth.hierarchy.create_gid(urn, uuid, pkey)
gid = gid_object.save_to_string(save_parents=True)
record['gid'] = gid
record = SfaRecord(dict=record)
table.update(record)
elif type == "node":
- api.oar.UpdateNode( pointer, new_record)
+ myapi.oar.UpdateNode( pointer, new_record)
else:
raise UnknownSfaType(type)
# update membership for researchers, pis, owners, operators
- api.update_membership(record, new_record)
+ myapi.update_membership(record, new_record)
return 1
record = records[0]
type = record['type']
- credential = api.getCredential()
- registries = api.registries
+ credential = myapi.getCredential()
+ registries = myapi.registries
# Try to remove the object from the PLCDB of federated agg.
# This is attempted before removing the object from the local agg's PLCDB and sfa table
- if hrn.startswith(api.hrn) and type in ['user', 'slice', 'authority']:
+ if hrn.startswith(myapi.hrn) and type in ['user', 'slice', 'authority']:
for registry in registries:
- if registry not in [api.hrn]:
+ if registry not in [myapi.hrn]:
try:
result=registries[registry].remove_peer_object(credential, record, origin_hrn)
except:
pass
if type == "user":
- persons = api.users.GetPersons(record['pointer'])
+ persons = myapi.users.GetPersons(record['pointer'])
# only delete this person if he has site ids. if he doesnt, it probably means
# he was just removed from a site, not actually deleted
if persons and persons[0]['site_ids']:
- api.users.DeletePerson(record['pointer'])
+ myapi.users.DeletePerson(record['pointer'])
elif type == "slice":
- if api.users.GetSlices( record['pointer']):
- api.users.DeleteSlice( record['pointer'])
+ if myapi.users.GetSlices( record['pointer']):
+ myapi.users.DeleteSlice( record['pointer'])
elif type == "node":
- if api.oar.GetNodes( record['pointer']):
- api.oar.DeleteNode( record['pointer'])
+ if myapi.oar.GetNodes( record['pointer']):
+ myapi.oar.DeleteNode( record['pointer'])
elif type == "authority":
- if api.oar.GetSites( record['pointer']):
- api.oar.DeleteSite( record['pointer'])
+ if myapi.oar.GetSites( record['pointer']):
+ myapi.oar.DeleteSite( record['pointer'])
else:
raise UnknownSfaType(type)
git://git.onelab.eu / sfa.git / commitdiff