if not filename.endswith(".rspec"):
filename = filename + ".rspec"
f = open(filename, 'w')
- f.write(rspec)
+ f.write("%s"%rspec)
f.close()
return
commands_list=[]
commands_dict={}
-def register_command (args_string, example):
+def register_command (args_string, example,aliases=None):
def wrap(m):
name=getattr(m,'__name__')
doc=getattr(m,'__doc__',"-- missing doc --")
doc=doc.strip(" \t\n")
commands_list.append(name)
- commands_dict[name]=(doc, args_string, example)
+ # last item is 'canonical' name, so we can know which commands are aliases
+ command_tuple=(doc, args_string, example,name)
+ commands_dict[name]=command_tuple
+ if aliases is not None:
+ for alias in aliases:
+ commands_list.append(alias)
+ commands_dict[alias]=command_tuple
@wraps(m)
def new_method (*args, **kwds): return m(*args, **kwds)
return new_method
### suitable if no reasonable command has been provided
def print_commands_help (self, options):
verbose=getattr(options,'verbose')
- format3="%18s %-15s %s"
+ format3="%10s %-30s %s"
+ format3offset=42
line=80*'-'
if not verbose:
print format3%("command","cmd_args","description")
self.create_parser_global().print_help()
# preserve order from the code
for command in commands_list:
- (doc, args_string, example) = commands_dict[command]
+ try:
+ (doc, args_string, example, canonical) = commands_dict[command]
+ except:
+ print "Cannot find info on command %s - skipped"%command
+ continue
if verbose:
print line
- doc=doc.replace("\n","\n"+35*' ')
- print format3%(command,args_string,doc)
- if verbose:
- self.create_parser_command(command).print_help()
+ if command==canonical:
+ doc=doc.replace("\n","\n"+format3offset*' ')
+ print format3%(command,args_string,doc)
+ if verbose:
+ self.create_parser_command(command).print_help()
+ else:
+ 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"
self.sfi_parser.print_help()
- (doc,_,example)=commands_dict[self.command]
+ (doc,_,example,canonical)=commands_dict[self.command]
+ if canonical != 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
sys.exit(2)
# retrieve args_string
- (_, args_string, __) = commands_dict[command]
+ (_, args_string, __,___) = commands_dict[command]
parser = OptionParser(add_help_option=False,
usage="sfi [sfi_options] %s [cmd_options] %s"
help='how myslice config variables as well')
if command in ("version"):
- parser.add_option("-R","--registry-version",
- action="store_true", dest="version_registry", default=False,
- help="probe registry version instead of sliceapi")
parser.add_option("-l","--local",
action="store_true", dest="version_local", default=False,
help="display version of the local client")
- if command in ("add", "update"):
+ if command in ("version", "trusted"):
+ parser.add_option("-R","--registry_interface",
+ action="store_true", dest="registry_interface", default=False,
+ help="target the registry interface instead of slice interface")
+
+ if command 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('-e', '--email', dest='email', default="", help="email (mandatory for users)")
"authority in set of credentials for this call")
# show_credential option
- if command in ("list","resources", "describe", "provision", "allocate", "add","update","remove","delete","status","renew"):
+ if command 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")
# registy filter option
if command in ("show"):
parser.add_option("-k","--key",dest="keys",action="append",default=[],
help="specify specific keys to be displayed from record")
+ parser.add_option("-n","--no-details",dest="no_details",action="store_true",default=False,
+ help="call Resolve without the 'details' option")
if command in ("resources", "describe"):
# rspec version
- parser.add_option("-r", "--rspec-version", dest="rspec_version", default="SFA 1",
+ parser.add_option("-r", "--rspec-version", dest="rspec_version", default="GENI 3",
help="schema type and version of resulting RSpec")
# disable/enable cached rspecs
parser.add_option("-c", "--current", dest="current", default=False,
metavar="slice_hrn", help="delegate cred. for slice HRN")
parser.add_option("-a", "--auths", dest='delegate_auths',action='append',default=[],
metavar='auth_hrn', help="delegate PI cred for auth HRN")
+ parser.add_option('-d', '--delegate', dest='delegate', help="Override 'delegate' from the config file")
+ parser.add_option('-b', '--backend', dest='backend', help="Override 'backend' from the config file")
return parser
def version(self, options, args):
"""
display an SFA server version (GetVersion)
- or version information about sfi itself
+ or version information about sfi itself
"""
if options.version_local:
version=version_core()
else:
- if options.version_registry:
+ if options.registry_interface:
server=self.registry()
else:
server = self.sliceapi()
sys.exit(1)
hrn = args[0]
# explicitly require Resolve to run in details mode
- record_dicts = self.registry().Resolve(hrn, self.my_credential_string, {'details':True})
+ resolve_options={}
+ if not options.no_details: resolve_options['details']=True
+ record_dicts = self.registry().Resolve(hrn, self.my_credential_string, resolve_options)
record_dicts = filter_records(options.type, record_dicts)
if not record_dicts:
self.logger.error("No record of type %s"% options.type)
save_records_to_file(options.file, record_dicts, options.fileformat)
return
- @register_command("[xml-filename]","")
- def add(self, options, args):
- """add record into registry (Register)
- from command line options (recommended)
- old-school method involving an xml file still supported"""
+ # this historically was named 'add', it is now 'register' with an alias for legacy
+ @register_command("[xml-filename]","",['add'])
+ def register(self, options, args):
+ """create new record in registry (Register)
+ from command line options (recommended)
+ old-school method involving an xml file still supported"""
auth_cred = self.my_authority_credential_string()
if options.show_credential:
@register_command("[xml-filename]","")
def update(self, options, args):
"""update record into registry (Update)
- from command line options (recommended)
- old-school method involving an xml file still supported"""
+ from command line options (recommended)
+ old-school method involving an xml file still supported"""
record_dict = {}
if len(args) > 0:
record_filepath = args[0]
def describe(self, options, args):
"""
shows currently allocated/provisioned resources
- of the named slice or set of slivers (Describe)
+ of the named slice or set of slivers (Describe)
"""
server = self.sliceapi()
api_options = {'call_id': unique_call_id(),
'cached': True,
- 'info': options.info,
+ #'info': options.info,
'list_leases': options.list_leases,
'geni_rspec_version': {'type': 'geni', 'version': '3'},
}
+ if options.info:
+ api_options['info'] = options.info
+
if options.rspec_version:
version_manager = VersionManager()
server_version = self.get_cached_server_version(server)
if self.options.raw:
save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
- save_rspec_to_file(value, options.file)
+ save_rspec_to_file(value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
display_rspec(value, options.format)
return
- @register_command("slice_hrn","")
+ @register_command("slice_hrn [<sliver_urn>...]","")
def delete(self, options, args):
"""
- de-allocate and de-provision all or named slivers of the slice (Delete)
+ de-allocate and de-provision all or named slivers of the named slice (Delete)
"""
server = self.sliceapi()
slice_hrn = args[0]
slice_urn = hrn_to_urn(slice_hrn, 'slice')
+ if len(args) > 1:
+ # we have sliver urns
+ sliver_urns = args[1:]
+ else:
+ # we provision all the slivers of the slice
+ sliver_urns = [slice_urn]
+
# creds
slice_cred = self.slice_credential(slice_hrn)
creds = [slice_cred]
api_options ['call_id'] = unique_call_id()
if options.show_credential:
show_credentials(creds)
- result = server.Delete([slice_urn], creds, *self.ois(server, api_options ) )
+ result = server.Delete(sliver_urns, creds, *self.ois(server, api_options ) )
value = ReturnValue.get_value(result)
if self.options.raw:
save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
if self.options.raw:
save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
- save_rspec_to_file (value, options.file)
+ save_rspec_to_file (value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
print value
return value
- @register_command("slice_hrn","")
+ @register_command("slice_hrn [<sliver_urn>...]","")
def provision(self, options, args):
"""
- provision already allocated resources of named slice (Provision)
+ provision all or named already allocated slivers of the named slice (Provision)
"""
server = self.sliceapi()
server_version = self.get_cached_server_version(server)
slice_hrn = args[0]
slice_urn = Xrn(slice_hrn, type='slice').get_urn()
+ if len(args) > 1:
+ # we have sliver urns
+ sliver_urns = args[1:]
+ else:
+ # we provision all the slivers of the slice
+ sliver_urns = [slice_urn]
# credentials
creds = [self.slice_credential(slice_hrn)]
users = pg_users_arg(user_records)
api_options['geni_users'] = users
- result = server.Provision([slice_urn], creds, api_options)
+ result = server.Provision(sliver_urns, creds, api_options)
value = ReturnValue.get_value(result)
if self.options.raw:
save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
if options.file is not None:
- save_rspec_to_file (value, options.file)
+ save_rspec_to_file (value['geni_rspec'], options.file)
if (self.options.raw is None) and (options.file is None):
print value
return value
@register_command("slice_hrn","")
def status(self, options, args):
"""
- retrieve the status of the slivers belonging to tne named slice (Status)
+ retrieve the status of the slivers belonging to the named slice (Status)
"""
server = self.sliceapi()
# Thierry: seemed to be missing
return value
- @register_command("slice_hrn action","")
+ @register_command("slice_hrn [<sliver_urn>...] action","")
def action(self, options, args):
"""
- Perform the named operational action on these slivers
+ Perform the named operational action on all or named slivers of the named slice
"""
server = self.sliceapi()
api_options = {}
# slice urn
slice_hrn = args[0]
- action = args[1]
- slice_urn = Xrn(slice_hrn, type='slice').get_urn()
+ slice_urn = Xrn(slice_hrn, type='slice').get_urn()
+ if len(args) > 2:
+ # we have sliver urns
+ sliver_urns = args[1:-1]
+ else:
+ # we provision all the slivers of the slice
+ sliver_urns = [slice_urn]
+ action = args[-1]
# cred
slice_cred = self.slice_credential(args[0])
creds = [slice_cred]
delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
creds.append(delegated_cred)
- result = server.PerformOperationalAction([slice_urn], creds, action , api_options)
+ result = server.PerformOperationalAction(sliver_urns, creds, action , api_options)
value = ReturnValue.get_value(result)
if self.options.raw:
save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
print value
return value
- @register_command("slice_hrn time","")
+ @register_command("slice_hrn [<sliver_urn>...] time","")
def renew(self, options, args):
"""
- renew slice (RenewSliver)
+ renew slice (Renew)
"""
server = self.sliceapi()
- if len(args) != 2:
+ if len(args) < 2:
self.print_help()
sys.exit(1)
- [ slice_hrn, input_time ] = args
- # slice urn
- slice_urn = hrn_to_urn(slice_hrn, 'slice')
+ slice_hrn = args[0]
+ slice_urn = Xrn(slice_hrn, type='slice').get_urn()
+
+ if len(args) > 2:
+ # we have sliver urns
+ sliver_urns = args[1:-1]
+ else:
+ # we provision all the slivers of the slice
+ sliver_urns = [slice_urn]
+ input_time = args[-1]
+
# time: don't try to be smart on the time format, server-side will
# creds
slice_cred = self.slice_credential(args[0])
api_options['call_id']=unique_call_id()
if options.show_credential:
show_credentials(creds)
- result = server.Renew([slice_urn], creds, input_time, *self.ois(server,api_options))
+ result = server.Renew(sliver_urns, creds, input_time, *self.ois(server,api_options))
value = ReturnValue.get_value(result)
if self.options.raw:
save_raw_to_file(result, self.options.raw, self.options.rawformat, self.options.rawbanner)
def delegate (self, options, args):
"""
(locally) create delegate credential for use by given hrn
- make sure to check for 'sfi myslice' instead if you plan
- on using MySlice
+ make sure to check for 'sfi myslice' instead if you plan
+ on using MySlice
"""
if len(args) != 1:
self.print_help()
$ sfi -v myslice -- or sfi -vv myslice
same but with more and more verbosity
-$ sfi m
+$ sfi m -b http://mymanifold.foo.com:7080/
is synonym to sfi myslice as no other command starts with an 'm'
+ and uses a custom backend for this one call
"""
) # register_command
def myslice (self, options, args):
""" This helper is for refreshing your credentials at myslice; it will
- * compute all the slices that you currently have credentials on
- * refresh all your credentials (you as a user and pi, your slices)
- * upload them to the manifold backend server
- for last phase, sfi_config is read to look for the [myslice] section,
- and namely the 'backend', 'delegate' and 'user' settings"""
+ * compute all the slices that you currently have credentials on
+ * refresh all your credentials (you as a user and pi, your slices)
+ * upload them to the manifold backend server
+ for last phase, sfi_config is read to look for the [myslice] section,
+ and namely the 'backend', 'delegate' and 'user' settings"""
##########
if len(args)>0:
self.print_help()
sys.exit(1)
+ # enable info by default
+ self.logger.setLevelFromOptVerbose(self.options.verbose+1)
### the rough sketch goes like this
+ # (0) produce a p12 file
+ self.client_bootstrap.my_pkcs12()
+
# (a) rain check for sufficient config in sfi_config
- # we don't allow to override these settings for now
myslice_dict={}
- myslice_keys=['backend', 'delegate', 'platform', 'username']
+ myslice_keys=[ 'backend', 'delegate', 'platform', 'username']
for key in myslice_keys:
- full_key="MYSLICE_" + key.upper()
- value=getattr(self.config_instance,full_key,None)
+ value=None
+ # oct 2013 - I'm finding myself juggling with config files
+ # so a couple of command-line options can now override config
+ if hasattr(options,key) and getattr(options,key) is not None:
+ value=getattr(options,key)
+ 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 len(myslice_dict) != len(myslice_keys):
sys.exit(1)
# (b) figure whether we are PI for the authority where we belong
- self.logger.info("Resolving our own id")
+ self.logger.info("Resolving our own id %s"%self.user)
my_records=self.registry().Resolve(self.user,self.my_credential_string)
if len(my_records)!=1: print "Cannot Resolve %s -- exiting"%self.user; sys.exit(1)
my_record=my_records[0]
my_auths = my_auths_all
if options.delegate_auths:
my_auths = list(set(my_auths_all).intersection(set(options.delegate_auths)))
+ self.logger.debug("Restricted to user-provided auths"%(my_auths))
- self.logger.info("Delegate PI creds for authorities: %s"%my_auths )
# (c) get the set of slices that we are in
my_slices_all=my_record['reg-slices']
self.logger.info("Found %d slices that we are member of"%len(my_slices_all))
self.logger.debug("They are: %s"%(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)))
-
- self.logger.info("Delegate slice creds for slices: %s"%my_slices)
+ self.logger.debug("Restricted to user-provided slices: %s"%(my_slices))
# (d) make sure we have *valid* credentials for all these
hrn_credentials=[]
hrn_delegated_credentials = []
for (hrn, htype, credential) in hrn_credentials:
delegated_credential = self.client_bootstrap.delegate_credential_string (credential, delegatee_hrn, delegatee_type)
- hrn_delegated_credentials.append ((hrn, htype, delegated_credential, ))
+ # 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))
+ with file(filename,'w') as f:
+ f.write(delegated_credential)
+ self.logger.debug("(Over)wrote %s"%filename)
+ 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
+ self.logger.info("Uploading on backend at %s"%myslice_dict['backend'])
uploader = ManifoldUploader (logger=self.logger,
url=myslice_dict['backend'],
platform=myslice_dict['platform'],
password=options.password)
uploader.prompt_all()
(count_all,count_success)=(0,0)
- for (hrn,htype,delegated_credential) in hrn_delegated_credentials:
+ for (hrn,htype,delegated_credential,filename) in hrn_delegated_credentials:
# inspect
inspect=Credential(string=delegated_credential)
expire_datetime=inspect.get_expiration()
if uploader.upload(delegated_credential,message=message):
count_success+=1
count_all+=1
-
self.logger.info("Successfully uploaded %d/%d credentials"%(count_success,count_all))
+
# 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
"""
return the trusted certs at this interface (get_trusted_certs)
"""
- trusted_certs = self.registry().get_trusted_certs()
+ if options.registry_interface:
+ server=self.registry()
+ else:
+ server = self.sliceapi()
+ cred = self.my_authority_credential_string()
+ trusted_certs = server.get_trusted_certs(cred)
+ if not options.registry_interface:
+ trusted_certs = ReturnValue.get_value(trusted_certs)
+
for trusted_cert in trusted_certs:
+ print "\n===========================================================\n"
gid = GID(string=trusted_cert)
gid.dump()
cert = Certificate(string=trusted_cert)
git://git.onelab.eu / sfa.git / blobdiff