from sfa.client.candidates import Candidates
from sfa.client.manifolduploader import ManifoldUploader
from sfa.client.candidates import Candidates
from sfa.client.manifolduploader import ManifoldUploader
from sfa.client.common import optparse_listvalue_callback, optparse_dictvalue_callback, \
terminal_render, filter_records
from sfa.client.common import optparse_listvalue_callback, optparse_dictvalue_callback, \
terminal_render, filter_records
def display_records(recordList, dump=False):
''' Print all fields in the record'''
def display_records(recordList, dump=False):
''' Print all fields in the record'''
- 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):
- if filename == "-":
- # if filename is "-", send it to stdout
- f = sys.stdout
+### raw
+def save_raw_to_file(var, filename, format='text', banner=None):
+ if filename == '-':
+ _save_raw_to_file(var, sys.stdout, format, banner)
- f = open(filename, "w")
- if banner:
- f.write(banner+"\n")
+ with open(filename, w) as fileobj:
+ _save_raw_to_file(var, fileobj, format, banner)
+ print("(Over)wrote {}".format(filename))
+
+def _save_raw_to_file(var, f, format, banner):
- if hasattr(json, "dumps"):
- f.write(json.dumps(var)) # python 2.6
- else:
- f.write(json.write(var)) # python 2.5
+ f.write(json.dumps(var)) # python 2.6
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"
- f = open(filename, 'w')
- f.write("%s"%rspec)
- f.close()
- return
+ with open(filename, 'w') as f:
+ f.write("{}".format(rspec))
+ print("(Over)wrote {}".format(filename))
+
+def save_record_to_file(filename, record_dict):
+ record = Record(dict=record_dict)
+ xml = record.save_as_xml()
+ with codecs.open(filename, encoding='utf-8',mode="w") as f:
+ f.write(xml)
+ print("(Over)wrote {}".format(filename))
- index = 0
- for record_dict in record_dicts:
- if index > 0:
- save_record_to_file(filename + "." + str(index), record_dict)
- else:
- save_record_to_file(filename, record_dict)
- index = index + 1
+ for index, record_dict in enumerate(record_dicts):
+ save_record_to_file(filename + "." + str(index), record_dict)
- f = open(filename, "w")
- f.write("<recordlist>\n")
- for record_dict in record_dicts:
- record_obj=Record(dict=record_dict)
- f.write('<record hrn="' + record_obj.hrn + '" type="' + record_obj.type + '" />\n')
- f.write("</recordlist>\n")
- f.close()
+ with open(filename, "w") as f:
+ f.write("<recordlist>\n")
+ for record_dict in record_dicts:
+ record_obj = Record(dict=record_dict)
+ f.write('<record hrn="' + record_obj.hrn + '" type="' + record_obj.type + '" />\n')
+ f.write("</recordlist>\n")
+ print("(Over)wrote {}".format(filename))
+
- f = open(filename, "w")
- for record_dict in record_dicts:
- record_obj=Record(dict=record_dict)
- f.write(record_obj.hrn + "\n")
- f.close()
+ with open(filename, "w") as f:
+ for record_dict in record_dicts:
+ record_obj = Record(dict=record_dict)
+ f.write(record_obj.hrn + "\n")
+ print("(Over)wrote {}".format(filename))
+
- print "unknown output format", format
-
-def save_record_to_file(filename, record_dict):
- record = Record(dict=record_dict)
- xml = record.save_as_xml()
- f=codecs.open(filename, encoding='utf-8',mode="w")
- f.write(xml)
- f.close()
- return
+ print("unknown output format", format)
+def normalize_type (type):
+ if type.startswith('au'):
+ return 'authority'
+ elif type.startswith('us'):
+ return 'user'
+ elif type.startswith('sl'):
+ return 'slice'
+ elif type.startswith('no'):
+ return 'node'
+ elif type.startswith('ag'):
+ return 'aggregate'
+ elif type.startswith('al'):
+ return 'all'
+ else:
+ print('unknown type {} - should start with one of au|us|sl|no|ag|al'.format(type))
+ return None
+
def load_record_from_opts(options):
record_dict = {}
if hasattr(options, 'xrn') and options.xrn:
def load_record_from_opts(options):
record_dict = {}
if hasattr(options, 'xrn') and options.xrn:
pubkey = options.key
if not check_ssh_key (pubkey):
raise SfaInvalidArgument(name='key',msg="Could not find file, or wrong key format")
pubkey = options.key
if not check_ssh_key (pubkey):
raise SfaInvalidArgument(name='key',msg="Could not find file, or wrong key format")
if hasattr(options, 'slices') and options.slices:
record_dict['slices'] = options.slices
if hasattr(options, 'reg_researchers') and options.reg_researchers is not None:
record_dict['reg-researchers'] = options.reg_researchers
if hasattr(options, 'email') and options.email:
record_dict['email'] = options.email
if hasattr(options, 'slices') and options.slices:
record_dict['slices'] = options.slices
if hasattr(options, 'reg_researchers') and options.reg_researchers is not None:
record_dict['reg-researchers'] = options.reg_researchers
if hasattr(options, 'email') and options.email:
record_dict['email'] = options.email
if hasattr(options, 'reg_pis') and options.reg_pis:
record_dict['reg-pis'] = options.reg_pis
if hasattr(options, 'reg_pis') and options.reg_pis:
record_dict['reg-pis'] = options.reg_pis
- f=codecs.open(filename, encoding="utf-8", mode="r")
- xml_string = f.read()
- f.close()
- return Record(xml=xml_string)
-
+ with codecs.open(filename, encoding="utf-8", mode="r") as f:
+ xml_str = f.read()
+ return Record(xml=xml_str)
self.create_parser_global().print_help()
# preserve order from the code
for command in commands_list:
try:
(doc, args_string, example, canonical) = commands_dict[command]
except:
self.create_parser_global().print_help()
# preserve order from the code
for command in commands_list:
try:
(doc, args_string, example, canonical) = commands_dict[command]
except:
- doc=doc.replace("\n","\n"+format3offset*' ')
- print format3%(command,args_string,doc)
+ doc = doc.replace("\n", "\n" + format3offset * ' ')
+ print(format3 % (command,args_string,doc))
- (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 doc
- print "\n==================== Specific usage for %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(doc)
+ print("\n==================== Specific usage for {}".format(self.command))
def create_parser_global(self):
# Generate command line parser
parser = OptionParser(add_help_option=False,
usage="sfi [sfi_options] command [cmd_options] [cmd_args]",
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")
if canonical in ("register", "update"):
parser.add_option('-x', '--xrn', dest='xrn', metavar='<xrn>', help='object hrn/urn (mandatory)')
if canonical in ("register", "update"):
parser.add_option('-x', '--xrn', dest='xrn', metavar='<xrn>', help='object hrn/urn (mandatory)')
- parser.add_option('-t', '--type', dest='type', metavar='<type>', help='object type', default=None)
+ parser.add_option('-t', '--type', dest='type', metavar='<type>', help='object type (2 first chars is enough)', default=None)
parser.add_option('-e', '--email', dest='email', default="", help="email (mandatory for users)")
parser.add_option('-e', '--email', dest='email', default="", help="email (mandatory for users)")
parser.add_option('-k', '--key', dest='key', metavar='<key>', help='public key string or file',
default=None)
parser.add_option('-s', '--slices', dest='slices', metavar='<slices>', help='Set/replace slice xrns',
parser.add_option('-k', '--key', dest='key', metavar='<key>', help='public key string or file',
default=None)
parser.add_option('-s', '--slices', dest='slices', metavar='<slices>', help='Set/replace slice xrns',
if canonical in ("list","resources", "describe", "provision", "allocate", "register","update","remove","delete","status","renew"):
parser.add_option("-C","--credential",dest='show_credential',action='store_true',default=False,
help="show credential(s) used in human-readable form")
if canonical in ("list","resources", "describe", "provision", "allocate", "register","update","remove","delete","status","renew"):
parser.add_option("-C","--credential",dest='show_credential',action='store_true',default=False,
help="show credential(s) used in human-readable form")
+ if canonical in ("renew"):
+ parser.add_option("-l","--as-long-as-possible",dest='alap',action='store_true',default=False,
+ help="renew as long as possible")
- parser.add_option("-t", "--type", dest="type", type="choice",
- help="type filter ([all]|user|slice|authority|node|aggregate)",
- choices=("all", "user", "slice", "authority", "node", "aggregate"),
- default="all")
+ parser.add_option("-t", "--type", dest="type", metavar="<type>",
+ default="all",
+ help="type filter - 2 first chars is enough ([all]|user|slice|authority|node|aggregate)")
if canonical in ("show"):
parser.add_option("-k","--key",dest="keys",action="append",default=[],
help="specify specific keys to be displayed from record")
if canonical in ("show"):
parser.add_option("-k","--key",dest="keys",action="append",default=[],
help="specify specific keys to be displayed from record")
help="call Resolve without the 'details' option")
if canonical in ("resources", "describe"):
# rspec version
help="call Resolve without the 'details' option")
if canonical in ("resources", "describe"):
# rspec version
- parser.add_option("-r", "--rspec-version", dest="rspec_version", default="GENI 3",
- help="schema type and version of resulting RSpec")
+ parser.add_option("-r", "--rspec-version", dest="rspec_version", default=DEFAULT_RSPEC_VERSION,
+ help="schema type and version of resulting RSpec (default:{})".format(DEFAULT_RSPEC_VERSION))
# disable/enable cached rspecs
parser.add_option("-c", "--current", dest="current", default=False,
action="store_true",
# disable/enable cached rspecs
parser.add_option("-c", "--current", dest="current", default=False,
action="store_true",
#panos: a new option to define the type of information about resources a user is interested in
parser.add_option("-i", "--info", dest="info",
help="optional component information", default=None)
#panos: a new option to define the type of information about resources a user is interested in
parser.add_option("-i", "--info", dest="info",
help="optional component information", default=None)
parser.add_option("-l", "--list_leases", dest="list_leases", type="choice",
parser.add_option("-l", "--list_leases", dest="list_leases", type="choice",
choices=("all", "resources", "leases"), default="resources")
choices=("all", "resources", "leases"), default="resources")
(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))
+ for arg in command_args:
+ if 'help' in arg or arg == '-h':
+ self.print_help()
+ sys.exit(1)
+ # allow incoming types on 2 characters only
+ if hasattr(command_options, 'type'):
+ command_options.type = normalize_type(command_options.type)
+ if not command_options.type:
+ sys.exit(1)
+
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:
client_bootstrap = SfaClientBootstrap (self.user, self.reg_url, self.options.sfi_dir,
logger=self.logger)
# if -k is provided, use this to initialize private key
client_bootstrap = SfaClientBootstrap (self.user, self.reg_url, self.options.sfi_dir,
logger=self.logger)
# if -k is provided, use this to initialize private key
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)
+ # helper function to analyze raw output
+ # for main : return 0 if everything is fine, something else otherwise (mostly 1 for now)
+ def success (self, raw):
+ return_value=ReturnValue (raw)
+ output=ReturnValue.get_output(return_value)
+ # means everything is fine
+ if not output:
+ return 0
+ # something went wrong
+ print('ERROR:', output)
+ return 1
+
#==========================================================================
# Following functions implement the commands
#
#==========================================================================
# Following functions implement the commands
#
@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:
- for (external_name, internal_name) in tuples:
- print "%-20s = %s"%(external_name,getattr(self,internal_name))
+ for external_name, internal_name in tuples:
+ print("{:<20} = {}".format(external_name, getattr(self, internal_name)))
- for name in tuples:
- varname="%s_%s"%(section.upper(),name.upper())
- value=getattr(self.config_instance,varname)
- print "%-20s = %s"%(name,value)
+ for external_name, internal_name in tuples:
+ varname = "{}_{}".format(section.upper(), external_name.upper())
+ value = getattr(self.config_instance,varname)
+ print("{:<20} = {}".format(external_name, value))
+ # xxx should analyze result
+ return 0
@declare_command("authority","")
def list(self, options, args):
@declare_command("authority","")
def list(self, options, args):
terminal_render (list, options)
if options.file:
save_records_to_file(options.file, list, options.fileformat)
terminal_render (list, options)
if options.file:
save_records_to_file(options.file, list, options.fileformat)
@declare_command("name","")
def show(self, options, args):
@declare_command("name","")
def show(self, options, args):
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:
records = [ Record(dict=record_dict) for record_dict in record_dicts ]
for record in records:
if (options.format == "text"): record.dump(sort=True)
records = [ Record(dict=record_dict) for record_dict in record_dicts ]
for record in records:
if (options.format == "text"): record.dump(sort=True)
# this historically was named 'add', it is now 'register' with an alias for legacy
@declare_command("[xml-filename]","",['add'])
# this historically was named 'add', it is now 'register' with an alias for legacy
@declare_command("[xml-filename]","",['add'])
record_dict['first_name'] = record_dict['hrn']
if 'last_name' not in record_dict:
record_dict['last_name'] = record_dict['hrn']
record_dict['first_name'] = record_dict['hrn']
if 'last_name' not in record_dict:
record_dict['last_name'] = record_dict['hrn']
- return self.registry().Register(record_dict, auth_cred)
+ register = self.registry().Register(record_dict, auth_cred)
+ # xxx looks like the result here is not ReturnValue-compatible
+ #return self.success (register)
+ # xxx should analyze result
+ return 0
@declare_command("[xml-filename]","")
def update(self, options, args):
@declare_command("[xml-filename]","")
def update(self, options, args):
- return self.registry().Update(record_dict, cred)
+ update = self.registry().Update(record_dict, cred)
+ # xxx looks like the result here is not ReturnValue-compatible
+ #return self.success(update)
+ # xxx should analyze result
+ return 0
@declare_command("hrn","")
def remove(self, options, args):
@declare_command("hrn","")
def remove(self, options, args):
- return self.registry().Remove(hrn, auth_cred, type)
+ remove = self.registry().Remove(hrn, auth_cred, type)
+ # xxx looks like the result here is not ReturnValue-compatible
+ #return self.success (remove)
+ # xxx should analyze result
+ return 0
# ==================================================================
# Slice-related commands
# ==================================================================
# show rspec for named slice
# ==================================================================
# Slice-related commands
# ==================================================================
# show rspec for named slice
def resources(self, options, args):
"""
discover available resources (ListResources)
def resources(self, options, args):
"""
discover available resources (ListResources)
# just request the version the client wants
api_options['geni_rspec_version'] = version_manager.get_version(options.rspec_version).to_dict()
else:
# just request the version the client wants
api_options['geni_rspec_version'] = version_manager.get_version(options.rspec_version).to_dict()
else:
- result = server.ListResources (creds, api_options)
- value = ReturnValue.get_value(result)
+
+ list_resources = server.ListResources (creds, api_options)
+ value = ReturnValue.get_value(list_resources)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(list_resources, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
save_rspec_to_file(value, options.file)
if (self.options.raw is None) and (options.file is None):
display_rspec(value, options.format)
if options.file is not None:
save_rspec_to_file(value, options.file)
if (self.options.raw is None) and (options.file is None):
display_rspec(value, options.format)
@declare_command("slice_hrn","")
def describe(self, options, args):
@declare_command("slice_hrn","")
def describe(self, options, args):
'list_leases': options.list_leases,
'geni_rspec_version': {'type': 'geni', 'version': '3'},
}
'list_leases': options.list_leases,
'geni_rspec_version': {'type': 'geni', 'version': '3'},
}
api_options['geni_rspec_version'] = version_manager.get_version(options.rspec_version).to_dict()
else:
api_options['geni_rspec_version'] = {'type': 'geni', 'version': '3'}
api_options['geni_rspec_version'] = version_manager.get_version(options.rspec_version).to_dict()
else:
api_options['geni_rspec_version'] = {'type': 'geni', 'version': '3'}
- urn = Xrn(args[0], type='slice').get_urn()
- result = server.Describe([urn], creds, api_options)
- value = ReturnValue.get_value(result)
+ urn = Xrn(args[0], type='slice').get_urn()
+ remove_none_fields(api_options)
+ describe = server.Describe([urn], creds, api_options)
+ value = ReturnValue.get_value(describe)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(describe, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
save_rspec_to_file(value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
if options.file is not None:
save_rspec_to_file(value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
@declare_command("slice_hrn [<sliver_urn>...]","")
def delete(self, options, args):
@declare_command("slice_hrn [<sliver_urn>...]","")
def delete(self, options, args):
- result = server.Delete(sliver_urns, creds, *self.ois(server, api_options ) )
- value = ReturnValue.get_value(result)
+ delete = server.Delete(sliver_urns, creds, *self.ois(server, api_options ) )
+ value = ReturnValue.get_value(delete)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(delete, self.options.raw, self.options.rawformat, self.options.rawbanner)
@declare_command("slice_hrn rspec","")
def allocate(self, options, args):
@declare_command("slice_hrn rspec","")
def allocate(self, options, args):
api_options = {}
api_options ['call_id'] = unique_call_id()
# users
sfa_users = []
geni_users = []
slice_records = self.registry().Resolve(slice_urn, [self.my_credential_string])
api_options = {}
api_options ['call_id'] = unique_call_id()
# users
sfa_users = []
geni_users = []
slice_records = self.registry().Resolve(slice_urn, [self.my_credential_string])
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']
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']
- result = server.Allocate(slice_urn, creds, rspec, api_options)
- value = ReturnValue.get_value(result)
+ with open(rspec_file) as rspec:
+ rspec_xml = rspec.read()
+ allocate = server.Allocate(slice_urn, creds, rspec_xml, api_options)
+ value = ReturnValue.get_value(allocate)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(allocate, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
save_rspec_to_file (value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
if options.file is not None:
save_rspec_to_file (value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
@declare_command("slice_hrn [<sliver_urn>...]","")
def provision(self, options, args):
@declare_command("slice_hrn [<sliver_urn>...]","")
def provision(self, options, args):
- result = server.Provision(sliver_urns, creds, api_options)
- value = ReturnValue.get_value(result)
+ provision = server.Provision(sliver_urns, creds, api_options)
+ value = ReturnValue.get_value(provision)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(provision, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
save_rspec_to_file (value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
if options.file is not None:
save_rspec_to_file (value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
@declare_command("slice_hrn","")
def status(self, options, args):
@declare_command("slice_hrn","")
def status(self, options, args):
- result = server.Status([slice_urn], creds, *self.ois(server,api_options))
- value = ReturnValue.get_value(result)
+ status = server.Status([slice_urn], creds, *self.ois(server,api_options))
+ value = ReturnValue.get_value(status)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(status, self.options.raw, self.options.rawformat, self.options.rawbanner)
@declare_command("slice_hrn [<sliver_urn>...] action","")
def action(self, options, args):
@declare_command("slice_hrn [<sliver_urn>...] action","")
def action(self, options, args):
delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
creds.append(delegated_cred)
delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
creds.append(delegated_cred)
- result = server.PerformOperationalAction(sliver_urns, creds, action , api_options)
- value = ReturnValue.get_value(result)
+ perform_action = server.PerformOperationalAction(sliver_urns, creds, action , api_options)
+ value = ReturnValue.get_value(perform_action)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(perform_action, self.options.raw, self.options.rawformat, self.options.rawbanner)
- print value
- return value
-
- @declare_command("slice_hrn [<sliver_urn>...] time","")
+ print(value)
+ return self.success (perform_action)
+
+ @declare_command("slice_hrn [<sliver_urn>...] time",
+ "\n".join(["sfi renew onelab.ple.heartbeat 2015-04-31",
+ "sfi renew onelab.ple.heartbeat 2015-04-31T14:00:00Z",
+ "sfi renew onelab.ple.heartbeat +5d",
+ "sfi renew onelab.ple.heartbeat +3w",
+ "sfi renew onelab.ple.heartbeat +2m",]))
- result = server.Renew(sliver_urns, creds, input_time, *self.ois(server,api_options))
- value = ReturnValue.get_value(result)
+ renew = server.Renew(sliver_urns, creds, input_time, *self.ois(server,api_options))
+ value = ReturnValue.get_value(renew)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(renew, self.options.raw, self.options.rawformat, self.options.rawbanner)
@declare_command("slice_hrn","")
def shutdown(self, options, args):
@declare_command("slice_hrn","")
def shutdown(self, options, args):
- result = server.Shutdown(slice_urn, creds)
- value = ReturnValue.get_value(result)
+ shutdown = server.Shutdown(slice_urn, creds)
+ value = ReturnValue.get_value(shutdown)
- save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
+ save_raw_to_file(shutdown, self.options.raw, self.options.rawformat, self.options.rawbanner)
@declare_command("[name]","")
def gid(self, options, args):
@declare_command("[name]","")
def gid(self, options, args):
- 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
# it is probably not helpful as people would not
# need to run 'sfi delegate' at all anymore
if count_success != count_all: sys.exit(1)
# at first I thought we would want to save these,
# like 'sfi delegate does' but on second thought
# it is probably not helpful as people would not
# need to run 'sfi delegate' at all anymore
if count_success != count_all: sys.exit(1)
@declare_command("cred","")
def trusted(self, options, args):
@declare_command("cred","")
def trusted(self, options, args):
- self.logger.debug('Sfi.trusted -> %r'%cert.get_subject())
- print "Certificate:\n%s\n\n"%trusted_cert
- return
-
+ self.logger.debug('Sfi.trusted -> {}'.format(cert.get_subject()))
+ print("Certificate:\n{}\n\n".format(trusted_cert))
+ # xxx should analyze result
+ return 0