- result += "type=%s\n" % credential.type
- result += "version=%s\n" % credential.version
- result += "rights=%s\n" % rights
+ result += "type={}\n".format(credential.type)
+ result += "version={}\n".format(credential.version)
+ result += "rights={}\n".format(rights)
return result
def show_credentials (cred_s):
if not isinstance (cred_s,list): cred_s = [cred_s]
for cred in cred_s:
return result
def show_credentials (cred_s):
if not isinstance (cred_s,list): cred_s = [cred_s]
for cred in cred_s:
# save methods
def save_raw_to_file(var, filename, format="text", banner=None):
# save methods
def save_raw_to_file(var, filename, format="text", banner=None):
def save_rspec_to_file(rspec, filename):
if not filename.endswith(".rspec"):
filename = filename + ".rspec"
def save_rspec_to_file(rspec, filename):
if not filename.endswith(".rspec"):
filename = filename + ".rspec"
- doc=doc.replace("\n","\n"+format3offset*' ')
- print format3%(command,args_string,doc)
+ doc = doc.replace("\n", "\n" + format3offset * ' ')
+ print format3 % (command,args_string,doc)
### now if a known command was found we can be more verbose on that one
def print_help (self):
print "==================== Generic sfi usage"
self.sfi_parser.print_help()
### now if a known command was found we can be more verbose on that one
def print_help (self):
print "==================== Generic sfi usage"
self.sfi_parser.print_help()
- (doc,_,example,canonical)=commands_dict[self.command]
+ (doc, _, example, canonical) = commands_dict[self.command]
- print "\n==================== NOTE: %s is an alias for genuine %s"%(self.command,canonical)
- self.command=canonical
- print "\n==================== Purpose of %s"%self.command
+ print "\n==================== NOTE: {} is an alias for genuine {}"\
+ .format(self.command, canonical)
+ self.command = canonical
+ print "\n==================== Purpose of {}".format(self.command)
print example
def create_parser_global(self):
# Generate command line parser
parser = OptionParser(add_help_option=False,
usage="sfi [sfi_options] command [cmd_options] [cmd_args]",
print example
def create_parser_global(self):
# Generate command line parser
parser = OptionParser(add_help_option=False,
usage="sfi [sfi_options] command [cmd_options] [cmd_args]",
parser.add_option("-r", "--registry", dest="registry",
help="root registry", metavar="URL", default=None)
parser.add_option("-s", "--sliceapi", dest="sm", default=None, metavar="URL",
parser.add_option("-r", "--registry", dest="registry",
help="root registry", metavar="URL", default=None)
parser.add_option("-s", "--sliceapi", dest="sm", default=None, metavar="URL",
(_, args_string, __,canonical) = commands_dict[command]
parser = OptionParser(add_help_option=False,
(_, args_string, __,canonical) = commands_dict[command]
parser = OptionParser(add_help_option=False,
- usage="sfi [sfi_options] %s [cmd_options] %s"
- % (command, args_string))
+ usage="sfi [sfi_options] {} [cmd_options] {}"\
+ .format(command, args_string))
parser.add_option ("-h","--help",dest='help',action='store_true',default=False,
help="Summary of one command usage")
parser.add_option ("-h","--help",dest='help',action='store_true',default=False,
help="Summary of one command usage")
(doc, args_string, example, canonical) = commands_dict[command]
method=getattr(self, canonical, None)
if not method:
(doc, args_string, example, canonical) = commands_dict[command]
method=getattr(self, canonical, None)
if not method:
- print "sfi: unknown command %s"%command
- raise SystemExit,"Unknown command %s"%command
+ print "sfi: unknown command {}".format(command)
+ raise SystemExit("Unknown command {}".format(command))
self.logger.info("Make sure to remove the export clauses and to add quotes")
if self.options.verbose==0:
self.logger.info("Re-run with -v for more details")
else:
self.logger.info("Make sure to remove the export clauses and to add quotes")
if self.options.verbose==0:
self.logger.info("Re-run with -v for more details")
else:
elif hasattr(config, "SFI_SM"):
self.sm_url = config.SFI_SM
else:
elif hasattr(config, "SFI_SM"):
self.sm_url = config.SFI_SM
else:
elif hasattr(config, "SFI_REGISTRY"):
self.reg_url = config.SFI_REGISTRY
else:
elif hasattr(config, "SFI_REGISTRY"):
self.reg_url = config.SFI_REGISTRY
else:
elif hasattr(config, "SFI_USER"):
self.user = config.SFI_USER
else:
elif hasattr(config, "SFI_USER"):
self.user = config.SFI_USER
else:
elif hasattr(config, "SFI_AUTH"):
self.authority = config.SFI_AUTH
else:
elif hasattr(config, "SFI_AUTH"):
self.authority = config.SFI_AUTH
else:
if not os.path.isfile(client_bootstrap.private_key_filename()):
self.logger.info ("private key not found, trying legacy name")
try:
if not os.path.isfile(client_bootstrap.private_key_filename()):
self.logger.info ("private key not found, trying legacy name")
try:
- legacy_private_key = os.path.join (self.options.sfi_dir, "%s.pkey"%Xrn.unescape(get_leaf(self.user)))
- self.logger.debug("legacy_private_key=%s"%legacy_private_key)
+ legacy_private_key = os.path.join (self.options.sfi_dir, "{}.pkey"
+ .format(Xrn.unescape(get_leaf(self.user))))
+ self.logger.debug("legacy_private_key={}"
+ .format(legacy_private_key))
- self.logger.info("Contacting Registry at: %s"%self.reg_url)
- self.registry_proxy = SfaServerProxy(self.reg_url, self.private_key, self.my_gid,
- timeout=self.options.timeout, verbose=self.options.debug)
+ self.logger.info("Contacting Registry at: {}".format(self.reg_url))
+ self.registry_proxy \
+ = SfaServerProxy(self.reg_url, self.private_key, self.my_gid,
+ timeout=self.options.timeout, verbose=self.options.debug)
records = self.registry().Resolve(node_hrn, self.my_credential_string)
records = filter_records('node', records)
if not records:
records = self.registry().Resolve(node_hrn, self.my_credential_string)
records = filter_records('node', records)
if not records:
self.sliceapi_proxy=SfaServerProxy(cm_url, self.private_key, self.my_gid)
else:
# otherwise use what was provided as --sliceapi, or SFI_SM in the config
if not self.sm_url.startswith('http://') or self.sm_url.startswith('https://'):
self.sm_url = 'http://' + self.sm_url
self.sliceapi_proxy=SfaServerProxy(cm_url, self.private_key, self.my_gid)
else:
# otherwise use what was provided as --sliceapi, or SFI_SM in the config
if not self.sm_url.startswith('http://') or self.sm_url.startswith('https://'):
self.sm_url = 'http://' + self.sm_url
- self.logger.info("Contacting Slice Manager at: %s"%self.sm_url)
- self.sliceapi_proxy = SfaServerProxy(self.sm_url, self.private_key, self.my_gid,
- timeout=self.options.timeout, verbose=self.options.debug)
+ self.logger.info("Contacting Slice Manager at: {}".format(self.sm_url))
+ self.sliceapi_proxy \
+ = SfaServerProxy(self.sm_url, self.private_key, self.my_gid,
+ timeout=self.options.timeout, verbose=self.options.debug)
return self.sliceapi_proxy
def get_cached_server_version(self, server):
return self.sliceapi_proxy
def get_cached_server_version(self, server):
version= ReturnValue.get_value(result)
# cache version for 20 minutes
cache.add(cache_key, version, ttl= 60*20)
version= ReturnValue.get_value(result)
# cache version for 20 minutes
cache.add(cache_key, version, ttl= 60*20)
@declare_command("","")
def config (self, options, args):
"Display contents of current config"
@declare_command("","")
def config (self, options, args):
"Display contents of current config"
flags=[ ('sfi', [ ('registry','reg_url'),
('auth','authority'),
('user','user'),
flags=[ ('sfi', [ ('registry','reg_url'),
('auth','authority'),
('user','user'),
flags.append ( ('myslice', ['backend', 'delegate', 'platform', 'username'] ) )
for (section, tuples) in flags:
flags.append ( ('myslice', ['backend', 'delegate', 'platform', 'username'] ) )
for (section, tuples) in flags:
- varname="%s_%s"%(section.upper(),name.upper())
- value=getattr(self.config_instance,varname)
- print "%-20s = %s"%(name,value)
+ varname = "{}_{}".format(section.upper(), name.upper())
+ value = getattr(self.config_instance,varname)
+ print "{:-20} = {}".format(name, value)
record_dicts = self.registry().Resolve(hrn, self.my_credential_string, resolve_options)
record_dicts = filter_records(options.type, record_dicts)
if not record_dicts:
record_dicts = self.registry().Resolve(hrn, self.my_credential_string, resolve_options)
record_dicts = filter_records(options.type, record_dicts)
if not record_dicts:
rec_file = self.get_record_file(record_filepath)
record_dict.update(load_record_from_file(rec_file).todict())
except:
rec_file = self.get_record_file(record_filepath)
record_dict.update(load_record_from_file(rec_file).todict())
except:
- filename = os.sep.join([self.options.sfi_dir, '%s.gid' % target_hrn])
- self.logger.info("writing %s gid to %s" % (target_hrn, filename))
+ filename = os.sep.join([self.options.sfi_dir, '{}.gid'.format(target_hrn)])
+ self.logger.info("writing {} gid to {}".format(target_hrn, filename))
original = self.slice_credential_string(slice_hrn)
tuples.append ( (message, original,) )
if options.delegate_pi:
my_authority=self.authority
original = self.slice_credential_string(slice_hrn)
tuples.append ( (message, original,) )
if options.delegate_pi:
my_authority=self.authority
original = self.my_authority_credential_string()
tuples.append ( (message, original,) )
for auth_hrn in options.delegate_auths:
original = self.my_authority_credential_string()
tuples.append ( (message, original,) )
for auth_hrn in options.delegate_auths:
tuples.append ( (message, original, ) )
# if nothing was specified at all at this point, let's assume -u
if not tuples: options.delegate_user=True
# this user cred
if options.delegate_user:
tuples.append ( (message, original, ) )
# if nothing was specified at all at this point, let's assume -u
if not tuples: options.delegate_user=True
# this user cred
if options.delegate_user:
original = self.my_credential_string
tuples.append ( (message, original, ) )
original = self.my_credential_string
tuples.append ( (message, original, ) )
for (message,original) in tuples:
delegated_string = self.client_bootstrap.delegate_credential_string(original, to_hrn, to_type)
delegated_credential = Credential (string=delegated_string)
for (message,original) in tuples:
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))
+ filename = os.path.join(self.options.sfi_dir,
+ "{}_for_{}.{}.cred".format(message, to_hrn, to_type))
- self.logger.info("delegated credential for %s to %s and wrote to %s"%(message,to_hrn,filename))
+ self.logger.info("delegated credential for {} to {} and wrote to {}"
+ .format(message, to_hrn, filename))
else:
full_key="MYSLICE_" + key.upper()
value=getattr(self.config_instance,full_key,None)
else:
full_key="MYSLICE_" + key.upper()
value=getattr(self.config_instance,full_key,None)
- if value: myslice_dict[key]=value
- else: print "Unsufficient config, missing key %s in [myslice] section of sfi_config"%key
+ if value:
+ myslice_dict[key]=value
+ else:
+ print "Unsufficient config, missing key {} in [myslice] section of sfi_config"\
+ .format(key)
if len(myslice_dict) != len(myslice_keys):
sys.exit(1)
# (b) figure whether we are PI for the authority where we belong
if len(myslice_dict) != len(myslice_keys):
sys.exit(1)
# (b) figure whether we are PI for the authority where we belong
- if len(my_records)!=1: print "Cannot Resolve %s -- exiting"%self.user; sys.exit(1)
- my_record=my_records[0]
+ if len(my_records) != 1:
+ print "Cannot Resolve {} -- exiting".format(self.user)
+ sys.exit(1)
+ my_record = my_records[0]
- self.logger.info("Found %d authorities that we are PI for"%len(my_auths_all))
- self.logger.debug("They are %s"%(my_auths_all))
+ self.logger.info("Found {} authorities that we are PI for".format(len(my_auths_all)))
+ self.logger.debug("They are {}".format(my_auths_all))
my_auths = my_auths_all
if options.delegate_auths:
my_auths = list(set(my_auths_all).intersection(set(options.delegate_auths)))
my_auths = my_auths_all
if options.delegate_auths:
my_auths = list(set(my_auths_all).intersection(set(options.delegate_auths)))
- self.logger.info("Found %d slices that we are member of"%len(my_slices_all))
- self.logger.debug("They are: %s"%(my_slices_all))
+ self.logger.info("Found {} slices that we are member of".format(len(my_slices_all)))
+ self.logger.debug("They are: {}".format(my_slices_all))
my_slices = my_slices_all
# if user provided slices, deal only with these - if they are found
if options.delegate_slices:
my_slices = list(set(my_slices_all).intersection(set(options.delegate_slices)))
my_slices = my_slices_all
# if user provided slices, deal only with these - if they are found
if options.delegate_slices:
my_slices = list(set(my_slices_all).intersection(set(options.delegate_slices)))
delegated_credential = self.client_bootstrap.delegate_credential_string (credential, delegatee_hrn, delegatee_type)
# save these so user can monitor what she's uploaded
filename = os.path.join ( self.options.sfi_dir,
delegated_credential = self.client_bootstrap.delegate_credential_string (credential, delegatee_hrn, delegatee_type)
# save these so user can monitor what she's uploaded
filename = os.path.join ( self.options.sfi_dir,
- "%s.%s_for_%s.%s.cred"%(hrn,htype,delegatee_hrn,delegatee_type))
+ "{}.{}_for_{}.{}.cred"\
+ .format(hrn, htype, delegatee_hrn, delegatee_type))
with file(filename,'w') as f:
f.write(delegated_credential)
with file(filename,'w') as f:
f.write(delegated_credential)
hrn_delegated_credentials.append ((hrn, htype, delegated_credential, filename, ))
# (f) and finally upload them to manifold server
# xxx todo add an option so the password can be set on the command line
# (but *NOT* in the config file) so other apps can leverage this
hrn_delegated_credentials.append ((hrn, htype, delegated_credential, filename, ))
# (f) and finally upload them to manifold server
# xxx todo add an option so the password can be set on the command line
# (but *NOT* in the config file) so other apps can leverage this
uploader = ManifoldUploader (logger=self.logger,
url=myslice_dict['backend'],
platform=myslice_dict['platform'],
uploader = ManifoldUploader (logger=self.logger,
url=myslice_dict['backend'],
platform=myslice_dict['platform'],
# at first I thought we would want to save these,
# like 'sfi delegate does' but on second thought
# at first I thought we would want to save these,
# like 'sfi delegate does' but on second thought
- self.logger.debug('Sfi.trusted -> %r'%cert.get_subject())
- print "Certificate:\n%s\n\n"%trusted_cert
+ self.logger.debug('Sfi.trusted -> {}'.format(cert.get_subject()))
+ print "Certificate:\n{}\n\n".format(trusted_cert)