# this module is also used in sfascan
#
+from __future__ import print_function
+
import sys
sys.path.append('.')
else:
result = rspec
- print result
+ print(result)
return
def display_list(results):
for result in results:
- print result
+ print(result)
def display_records(recordList, dump=False):
''' Print all fields in the record'''
record.dump(sort=True)
else:
info = record.getdict()
- print "{} ({})".format(info['hrn'], info['type'])
+ print("{} ({})".format(info['hrn'], info['type']))
return
def show_credentials (cred_s):
if not isinstance (cred_s,list): cred_s = [cred_s]
for cred in cred_s:
- print "Using Credential {}".format(credential_printable(cred))
+ print("Using Credential {}".format(credential_printable(cred)))
+
+########## save methods
-# 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)
else:
- 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 format == "text":
- f.write(str(var))
+ if banner: f.write(banner+"\n")
+ f.write("{}".format(var))
+ if banner: f.write('\n'+banner+"\n")
elif format == "pickled":
f.write(pickle.dumps(var))
elif format == "json":
- 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
else:
# this should never happen
- print "unknown output format", format
- if banner:
- f.write('\n'+banner+"\n")
+ print("unknown output format", format)
+###
def save_rspec_to_file(rspec, filename):
if not filename.endswith(".rspec"):
filename = filename + ".rspec"
with open(filename, 'w') as f:
f.write("{}".format(rspec))
- return
+ 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))
def save_records_to_file(filename, record_dicts, format="xml"):
if format == "xml":
- 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)
elif format == "xmllist":
- 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))
+
elif format == "hrnlist":
- 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))
+
else:
# this should never happen
- 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)
# minimally check a key argument
def check_ssh_key (key):
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, 'type'):
- options.type = normalize_type(options.type)
if hasattr(options, 'xrn') and options.xrn:
if hasattr(options, 'type') and options.type:
xrn = Xrn(options.xrn, options.type)
return Record(dict=record_dict)
def load_record_from_file(filename):
- 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)
import uuid
def unique_call_id(): return uuid.uuid4().urn
format3offset=47
line=80*'-'
if not verbose:
- print format3%("command", "cmd_args", "description")
- print line
+ print(format3%("command", "cmd_args", "description"))
+ print(line)
else:
- print line
+ print(line)
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:
- print "Cannot find info on command %s - skipped"%command
+ print("Cannot find info on command %s - skipped"%command)
continue
if verbose:
- print line
+ print(line)
if command==canonical:
doc = doc.replace("\n", "\n" + format3offset * ' ')
- print format3 % (command,args_string,doc)
+ print(format3 % (command,args_string,doc))
if verbose:
self.create_parser_command(command).print_help()
else:
- print format3 % (command,"<<alias for %s>>"%canonical,"")
+ print(format3 % (command,"<<alias for %s>>"%canonical,""))
### now if a known command was found we can be more verbose on that one
def print_help (self):
- print "==================== Generic sfi usage"
+ print("==================== Generic sfi usage")
self.sfi_parser.print_help()
(doc, _, example, canonical) = commands_dict[self.command]
if canonical != self.command:
- print "\n==================== NOTE: {} is an alias for genuine {}"\
- .format(self.command, canonical)
+ 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)
+ print("\n==================== Purpose of {}".format(self.command))
+ print(doc)
+ print("\n==================== Specific usage for {}".format(self.command))
self.command_parser.print_help()
if example:
- print "\n==================== {} example(s)".format(self.command)
- print example
+ print("\n==================== {} example(s)".format(self.command))
+ print(example)
def create_parser_global(self):
# Generate command line parser
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('-n', '--name', dest='name', default="", help="name (optional for authorities)")
parser.add_option('-k', '--key', dest='key', metavar='<key>', help='public key string or file',
help="renew as long as possible")
# registy filter option
if canonical in ("list", "show", "remove"):
- 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")
#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)
- # a new option to retreive or not reservation-oriented RSpecs (leases)
+ # a new option to retrieve or not reservation-oriented RSpecs (leases)
parser.add_option("-l", "--list_leases", dest="list_leases", type="choice",
- help="Retreive or not reservation-oriented RSpecs ([resources]|leases|all )",
+ help="Retrieve or not reservation-oriented RSpecs ([resources]|leases|all)",
choices=("all", "resources", "leases"), default="resources")
(doc, args_string, example, canonical) = commands_dict[command]
method=getattr(self, canonical, None)
if not method:
- print "sfi: unknown command {}".format(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)
return method(command_options, command_args)
def main(self):
sys.exit(1)
self.command_options = command_options
+ # 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.read_config ()
self.bootstrap ()
self.logger.debug("Command={}".format(self.command))
if not output:
return 0
# something went wrong
- print 'ERROR:',output
+ print('ERROR:', output)
return 1
#==========================================================================
@declare_command("","")
def config (self, options, args):
"Display contents of current config"
- print "# From configuration file {}".format(self.config_file)
+ print("# From configuration file {}".format(self.config_file))
flags=[ ('sfi', [ ('registry','reg_url'),
('auth','authority'),
('user','user'),
flags.append ( ('myslice', ['backend', 'delegate', 'platform', 'username'] ) )
for (section, tuples) in flags:
- print "[{}]".format(section)
+ print("[{}]".format(section))
try:
- for (external_name, internal_name) in tuples:
- print "{:-20} = {}".format(external_name, getattr(self, internal_name))
+ for external_name, internal_name in tuples:
+ print("{:<20} = {}".format(external_name, getattr(self, internal_name)))
except:
- for name in tuples:
- varname = "{}_{}".format(section.upper(), name.upper())
+ for external_name, internal_name in tuples:
+ varname = "{}_{}".format(section.upper(), external_name.upper())
value = getattr(self.config_instance,varname)
- print "{:-20} = {}".format(name, value)
+ print("{:<20} = {}".format(external_name, value))
# xxx should analyze result
return 0
records = [ Record(dict=record_dict) for record_dict in record_dicts ]
for record in records:
if (options.format == "text"): record.dump(sort=True)
- else: print record.save_as_xml()
+ else: print(record.save_as_xml())
if options.file:
save_records_to_file(options.file, record_dicts, options.fileformat)
# xxx should analyze result
try:
record_filepath = args[0]
rec_file = self.get_record_file(record_filepath)
- record_dict.update(load_record_from_file(rec_file).todict())
+ record_dict.update(load_record_from_file(rec_file).record_to_dict())
except:
- print "Cannot load record file {}".format(record_filepath)
+ print("Cannot load record file {}".format(record_filepath))
sys.exit(1)
if options:
- record_dict.update(load_record_from_opts(options).todict())
+ record_dict.update(load_record_from_opts(options).record_to_dict())
# we should have a type by now
if 'type' not in record_dict :
self.print_help()
if len(args) > 0:
record_filepath = args[0]
rec_file = self.get_record_file(record_filepath)
- record_dict.update(load_record_from_file(rec_file).todict())
+ record_dict.update(load_record_from_file(rec_file).record_to_dict())
if options:
- record_dict.update(load_record_from_opts(options).todict())
+ record_dict.update(load_record_from_opts(options).record_to_dict())
# at the very least we need 'type' here
if 'type' not in record_dict or record_dict['type'] is None:
self.print_help()
# just request the version the client wants
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'] = {'type': options.rspec_version}
else:
api_options['geni_rspec_version'] = {'type': 'geni', 'version': '3'}
+
list_resources = server.ListResources (creds, api_options)
value = ReturnValue.get_value(list_resources)
if self.options.raw:
if self.options.raw:
save_raw_to_file(delete, self.options.raw, self.options.rawformat, self.options.rawbanner)
else:
- print value
+ print(value)
return self.success (delete)
@declare_command("slice_hrn rspec","")
"""
server = self.sliceapi()
server_version = self.get_cached_server_version(server)
+ if len(args) != 2:
+ self.print_help()
+ sys.exit(1)
slice_hrn = args[0]
+ rspec_file = self.get_rspec_file(args[1])
+
slice_urn = Xrn(slice_hrn, type='slice').get_urn()
# credentials
show_credentials(creds)
# rspec
- rspec_file = self.get_rspec_file(args[1])
- rspec = open(rspec_file).read()
api_options = {}
api_options ['call_id'] = unique_call_id()
# users
api_options['sfa_users'] = sfa_users
api_options['geni_users'] = geni_users
- allocate = server.Allocate(slice_urn, creds, rspec, api_options)
+ 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)
if self.options.raw:
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):
- print value
+ print(value)
return self.success(allocate)
@declare_command("slice_hrn [<sliver_urn>...]","")
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):
- print value
+ print(value)
return self.success(provision)
@declare_command("slice_hrn","")
if self.options.raw:
save_raw_to_file(status, self.options.raw, self.options.rawformat, self.options.rawbanner)
else:
- print value
+ print(value)
return self.success (status)
@declare_command("slice_hrn [<sliver_urn>...] action","")
if self.options.raw:
save_raw_to_file(perform_action, self.options.raw, self.options.rawformat, self.options.rawbanner)
else:
- print value
+ print(value)
return self.success (perform_action)
@declare_command("slice_hrn [<sliver_urn>...] time",
if self.options.raw:
save_raw_to_file(renew, self.options.raw, self.options.rawformat, self.options.rawbanner)
else:
- print value
+ print(value)
return self.success(renew)
@declare_command("slice_hrn","")
if self.options.raw:
save_raw_to_file(shutdown, self.options.raw, self.options.rawformat, self.options.rawbanner)
else:
- print value
+ print(value)
return self.success (shutdown)
@declare_command("[name]","")
if value:
myslice_dict[key]=value
else:
- print "Unsufficient config, missing key {} in [myslice] section of sfi_config"\
- .format(key)
+ print("Unsufficient config, missing key {} in [myslice] section of sfi_config"
+ .format(key))
if len(myslice_dict) != len(myslice_keys):
sys.exit(1)
self.logger.info("Resolving our own id {}".format(self.user))
my_records=self.registry().Resolve(self.user,self.my_credential_string)
if len(my_records) != 1:
- print "Cannot Resolve {} -- exiting".format(self.user)
+ print("Cannot Resolve {} -- exiting".format(self.user))
sys.exit(1)
my_record = my_records[0]
my_auths_all = my_record['reg-pi-authorities']
trusted_certs = ReturnValue.get_value(trusted_certs)
for trusted_cert in trusted_certs:
- print "\n===========================================================\n"
+ print("\n===========================================================\n")
gid = GID(string=trusted_cert)
gid.dump()
cert = Certificate(string=trusted_cert)
self.logger.debug('Sfi.trusted -> {}'.format(cert.get_subject()))
- print "Certificate:\n{}\n\n".format(trusted_cert)
+ print("Certificate:\n{}\n\n".format(trusted_cert))
# xxx should analyze result
return 0