type=record['type']
if type not in grouped_by_type: grouped_by_type[type]=[]
grouped_by_type[type].append(record)
- for (type, list) in grouped_by_type.items():
+ group_types=grouped_by_type.keys()
+ group_types.sort()
+ for type in group_types:
+ group=grouped_by_type[type]
# print 20 * '-', type
try: renderer=eval('terminal_render_'+type)
except: renderer=terminal_render_default
- for record in list: renderer(record,options)
+ for record in group: renderer(record,options)
+
+def render_plural (how_many, name,names=None):
+ if not names: names="%ss"%name
+ if how_many<=0: return "No %s"%name
+ elif how_many==1: return "1 %s"%name
+ else: return "%d %s"%(how_many,names)
def terminal_render_default (record,options):
print "%s (%s)" % (record['hrn'], record['type'])
print "%s (User)"%record['hrn'],
if record.get('reg-pi-authorities',None): print " [PI at %s]"%(" and ".join(record['reg-pi-authorities'])),
if record.get('reg-slices',None): print " [IN slices %s]"%(" and ".join(record['reg-slices'])),
- print ""
+ user_keys=record.get('reg-keys',[])
+ if not options.verbose:
+ print " [has %s]"%(render_plural(len(user_keys),"key"))
+ else:
+ print ""
+ for key in user_keys: print 8*' ',key.strip("\n")
+
def terminal_render_slice (record, options):
print "%s (Slice)"%record['hrn'],
if record.get('reg-researchers',None): print " [USERS %s]"%(" and ".join(record['reg-researchers'])),
action="callback", callback=optparse_dictvalue_callback, nargs=1,
help="set extra/testbed-dependent flags, e.g. --extra enabled=true")
- # user specifies remote aggregate/sm/component
- if command in ("resources", "slices", "create", "delete", "start", "stop",
- "restart", "shutdown", "get_ticket", "renew", "status"):
- parser.add_option("-d", "--delegate", dest="delegate", default=None,
- action="store_true",
- help="Include a credential delegated to the user's root"+\
- "authority in set of credentials for this call")
-
# show_credential option
if command in ("list","resources","create","add","update","remove","slices","delete","status","renew"):
parser.add_option("-C","--credential",dest='show_credential',action='store_true',default=False,
if command == 'list':
parser.add_option("-r", "--recursive", dest="recursive", action='store_true',
help="list all child records", default=False)
+ parser.add_option("-v", "--verbose", dest="verbose", action='store_true',
+ help="gives details, like user keys", default=False)
if command in ("delegate"):
parser.add_option("-u", "--user",
action="store_true", dest="delegate_user", default=False,
- help="delegate user credential")
+ help="delegate your own credentials")
parser.add_option("-s", "--slice", dest="delegate_slice",
help="delegate slice credential", metavar="HRN", default=None)
+ parser.add_option("-a", "--authority", dest='delegate_to_authority', default=None, action='store_true',
+ help="""by default the only argument is expected to be a user,
+use this if you mean an authority instead""")
if command in ("version"):
parser.add_option("-R","--registry-version",
def slice_credential_string(self, name):
return self.client_bootstrap.slice_credential_string (name)
- # xxx should be supported by sfaclientbootstrap as well
- def delegate_cred(self, object_cred, hrn, type='authority'):
- # the gid and hrn of the object we are delegating
- if isinstance(object_cred, str):
- object_cred = Credential(string=object_cred)
- object_gid = object_cred.get_gid_object()
- object_hrn = object_gid.get_hrn()
-
- if not object_cred.get_privileges().get_all_delegate():
- self.logger.error("Object credential %s does not have delegate bit set"%object_hrn)
- return
-
- # the delegating user's gid
- caller_gidfile = self.my_gid()
-
- # the gid of the user who will be delegated to
- delegee_gid = self.client_bootstrap.gid(hrn,type)
- delegee_hrn = delegee_gid.get_hrn()
- dcred = object_cred.delegate(delegee_gid, self.private_key, caller_gidfile)
- return dcred.save_to_string(save_parents=True)
-
#
# Management of the servers
#
server = self.sliceapi()
# creds
creds = [self.my_credential_string]
- if options.delegate:
- delegated_cred = self.delegate_cred(self.my_credential_string, get_authority(self.authority))
- creds.append(delegated_cred)
# options and call_id when supported
api_options = {}
api_options['call_id']=unique_call_id()
# set creds
creds = []
if args:
- creds.append(self.slice_credential_string(args[0]))
+ the_credential=self.slice_credential_string(args[0])
+ creds.append(the_credential)
else:
- creds.append(self.my_credential_string)
- if options.delegate:
- creds.append(self.delegate_cred(cred, get_authority(self.authority)))
+ the_credential=self.my_credential_string
+ creds.append(the_credential)
if options.show_credential:
show_credentials(creds)
# xxx Thierry 2012 sept. 21
# contrary to what I was first thinking, calling Resolve with details=False does not yet work properly here
# I am turning details=True on again on a - hopefully - temporary basis, just to get this whole thing to work again
- slice_records = self.registry().Resolve(slice_urn, [self.my_credential_string], {'details':True})
+ slice_records = self.registry().Resolve(slice_urn, [self.my_credential_string])
+ # slice_records = self.registry().Resolve(slice_urn, [self.my_credential_string], {'details':True})
if slice_records and 'reg-researchers' in slice_records[0] and slice_records[0]['reg-researchers']:
slice_record = slice_records[0]
user_hrns = slice_record['reg-researchers']
# creds
slice_cred = self.slice_credential_string(slice_hrn)
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
# options and call_id when supported
api_options = {}
# creds
slice_cred = self.slice_credential_string(slice_hrn)
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
# options and call_id when supported
api_options = {}
# cred
slice_cred = self.slice_credential_string(args[0])
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
# xxx Thierry - does this not need an api_options as well ?
result = server.Start(slice_urn, creds)
value = ReturnValue.get_value(result)
# cred
slice_cred = self.slice_credential_string(args[0])
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
result = server.Stop(slice_urn, creds)
value = ReturnValue.get_value(result)
if self.options.raw:
# cred
slice_cred = self.slice_credential_string(args[0])
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
result = server.reset_slice(creds, slice_urn)
value = ReturnValue.get_value(result)
if self.options.raw:
# creds
slice_cred = self.slice_credential_string(args[0])
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
# options and call_id when supported
api_options = {}
api_options['call_id']=unique_call_id()
# creds
slice_cred = self.slice_credential_string(slice_hrn)
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
result = server.Shutdown(slice_urn, creds)
value = ReturnValue.get_value(result)
if self.options.raw:
# creds
slice_cred = self.slice_credential_string(slice_hrn)
creds = [slice_cred]
- if options.delegate:
- delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
- creds.append(delegated_cred)
# rspec
rspec_file = self.get_rspec_file(rspec_path)
rspec = open(rspec_file).read()
GID(string=gid).save_to_file(filename)
- def delegate(self, options, args):
+ def delegate (self, options, args):
"""
(locally) create delegate credential for use by given hrn
"""
- delegee_hrn = args[0]
+ if len(args) != 1:
+ self.print_help()
+ sys.exit(1)
+ to_hrn = args[0]
+ print 'to_hrn',to_hrn
+ if options.delegate_to_authority: to_type='authority'
+ else: to_type='user'
if options.delegate_user:
- cred = self.delegate_cred(self.my_credential_string, delegee_hrn, 'user')
+ message="%s.user"%self.user
+ original = self.my_credential_string
elif options.delegate_slice:
- slice_cred = self.slice_credential_string(options.delegate_slice)
- cred = self.delegate_cred(slice_cred, delegee_hrn, 'slice')
+ message="%s.slice"%options.delegate_slice
+ original = self.slice_credential_string(options.delegate_slice)
else:
self.logger.warning("Must specify either --user or --slice <hrn>")
return
- delegated_cred = Credential(string=cred)
- object_hrn = delegated_cred.get_gid_object().get_hrn()
- if options.delegate_user:
- dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
- + get_leaf(object_hrn) + ".cred")
- elif options.delegate_slice:
- dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
- + get_leaf(object_hrn) + ".cred")
-
- delegated_cred.save_to_file(dest_fn, save_parents=True)
-
- self.logger.info("delegated credential for %s to %s and wrote to %s"%(object_hrn, delegee_hrn,dest_fn))
+ delegated_string = self.client_bootstrap.delegate_credential_string(original, to_hrn, to_type)
+ delegated_credential = Credential (string=delegated_string)
+ filename = os.path.join ( self.options.sfi_dir,
+ "%s_for_%s.%s.cred"%(message,to_hrn,to_type))
+ delegated_credential.save_to_file(filename, save_parents=True)
+ self.logger.info("delegated credential for %s to %s and wrote to %s"%(message,to_hrn,filename))
def trusted(self, options, args):
"""