self._username=username
self._password=password
self.logger=logger
+ self._proxy=None
def username (self):
- if not self._username:
+ if not self._username:
self._username=raw_input("Enter your manifold username: ")
- return self._username
+ return self._username
def password (self):
- if not self._password:
+ if not self._password:
username=self.username()
self._password=getpass.getpass("Enter password for manifold user %s: "%username)
- return self._password
+ return self._password
def platform (self):
- if not self._platform:
+ if not self._platform:
self._platform=raw_input("Enter your manifold platform [%s]: "%DEFAULT_PLATFORM)
if self._platform.strip()=="": self._platform = DEFAULT_PLATFORM
- return self._platform
+ return self._platform
def url (self):
- if not self._url:
+ if not self._url:
self._url=raw_input("Enter the URL for your manifold API [%s]: "%DEFAULT_URL)
if self._url.strip()=="": self._url = DEFAULT_URL
- return self._url
+ return self._url
+
+ def prompt_all(self):
+ self.username(); self.password(); self.platform(); self.url()
+
+ def proxy (self):
+ if not self._proxy:
+ url=self.url()
+ self.logger.debug("Connecting manifold url %s"%url)
+ self._proxy = xmlrpclib.ServerProxy(url, allow_none = True)
+ return self._proxy
# does the job for one credential
# expects the credential (string) and an optional message for reporting
# return True upon success and False otherwise
def upload (self, delegated_credential, message=None):
- url=self.url()
platform=self.platform()
username=self.username()
password=self.password()
if not message: message=""
try:
+# manifold=self.proxy()
+ url=self.url()
self.logger.debug("Connecting manifold url %s"%url)
manifold = xmlrpclib.Server(url, allow_none = 1)
# the code for a V2 interface
- query= { 'action': 'update',
- 'fact_table': 'local:account',
- 'filters': [ ['platform', '=', platform] ] ,
- 'params': {'credential': delegated_credential, },
+ query= { 'action': 'update',
+ 'object': 'local:account',
+ 'filters': [ ['platform', '=', platform] ] ,
+ 'params': {'credential': delegated_credential, },
}
try:
- self.logger.debug("Trying v2 method Update %s"%message)
+ self.logger.debug("Trying v2 method Update@%s %s"%(platform,message))
retcod2=manifold.Update (auth, query)
except Exception,e:
# xxx we need a constant constant for UNKNOWN, how about using 1
MANIFOLD_UNKNOWN=1
- retcod2={'code':MANIFOLD_UNKNOWN,'output':"%s"%e}
+ retcod2={'code':MANIFOLD_UNKNOWN,'description':"%s"%e}
if retcod2['code']==0:
info=""
if message: info += message+" "
info += 'v2 upload OK'
self.logger.info(info)
return True
- #print delegated_credential, "upload failed,",retcod['output'], \
+ #print delegated_credential, "upload failed,",retcod['description'], \
# "with code",retcod['code']
# the code for V1
try:
- self.logger.debug("Trying v1 method AddCredential %s"%message)
+ self.logger.debug("Trying v1 method AddCredential@%s %s"%(platform,message))
retcod1=manifold.AddCredential(auth, delegated_credential, platform)
except Exception,e:
retcod1=e
# everything has failed, let's report
if message: self.logger.error("Could not upload %s"%message)
else: self.logger.error("Could not upload credential")
- self.logger.info(" V2 Update returned code %s and error %s"%(retcod2['code'],retcod2['output']))
+ if 'code' in retcod2 and 'description' in retcod2:
+ self.logger.info(" V2 Update returned code %s and error >>%s<<"%(retcod2['code'],retcod2['description']))
+ self.logger.debug("****** full retcod2")
+ for (k,v) in retcod2.items(): self.logger.debug("**** %s: %s"%(k,v))
+ else:
+ self.logger.info(" V2 Update returned %s"%retcod2)
self.logger.info(" V1 AddCredential returned code %s (expected 1)"%retcod1)
return False
except Exception, e:
help='the manifold username')
parser.add_argument ('-P','--password',dest='password',action='store',default=None,
help='the manifold password')
+ parser.add_argument ('-v','--verbose',dest='verbose',action='count',default=0,
+ help='more and more verbose')
args = parser.parse_args ()
from sfa.util.sfalogging import sfi_logger
+ sfi_logger.enable_console()
+ sfi_logger.setLevelFromOptVerbose(args.verbose)
uploader = ManifoldUploader (url=args.url, platform=args.platform,
username=args.username, password=args.password,
logger=sfi_logger)
+
for filename in args.credential_files:
with file(filename) as f:
result=uploader.upload (f.read(),filename)
print line
else:
print line
- self.create_global_parser().print_help()
+ self.create_parser_global().print_help()
# preserve order from the code
for command in commands_list:
(doc, args_string, example) = commands_dict[command]
doc=doc.replace("\n","\n"+35*' ')
print format3%(command,args_string,doc)
if verbose:
- self.create_command_parser(command).print_help()
+ self.create_parser_command(command).print_help()
### now if a known command was found we can be more verbose on that one
def print_help (self):
print "\n==================== %s example(s)"%self.command
print example
- def create_global_parser(self):
+ def create_parser_global(self):
# Generate command line parser
parser = OptionParser(add_help_option=False,
usage="sfi [sfi_options] command [cmd_options] [cmd_args]",
return parser
- def create_command_parser(self, command):
+ def create_parser_command(self, command):
if command not in commands_dict:
msg="Invalid command\n"
msg+="Commands: "
parser.add_option('-m', '--myslice', dest='myslice', action='store_true', default=False,
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"):
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("-A","--to-authority",dest='delegate_to_authority',action='store_true',default=False,
help="""by default the mandatory 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",
- 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 ("myslice"):
+ parser.add_option("-p","--password",dest='password',action='store',default=None,
+ help="specify mainfold password on the command line")
+
return parser
return method(command_options, command_args)
def main(self):
- self.sfi_parser = self.create_global_parser()
+ self.sfi_parser = self.create_parser_global()
(options, args) = self.sfi_parser.parse_args()
if options.help:
self.print_commands_help(options)
sys.exit(1)
# second pass options parsing
self.command=command
- self.command_parser = self.create_command_parser(command)
+ self.command_parser = self.create_parser_command(command)
(command_options, command_args) = self.command_parser.parse_args(args[1:])
if command_options.help:
self.print_help()
delegatee_hrn=myslice_dict['delegate']
hrn_delegated_credentials = []
for (hrn, htype, credential) in hrn_credentials:
- sfi_logger.info("Computing delegated credential for %s (%s)"%(hrn,htype))
- hrn_delegated_credentials.append ((hrn, htype, self.client_bootstrap.delegate_credential_string (credential, delegatee_hrn, delegatee_type),))
+ delegated_credential = self.client_bootstrap.delegate_credential_string (credential, delegatee_hrn, delegatee_type)
+ hrn_delegated_credentials.append ((hrn, htype, delegated_credential, ))
+ # inspect
+ inspect=Credential(string=delegated_credential)
+ expire_datetime=inspect.get_expiration()
+ sfi_logger.info("Delegated credential for %s (%s) expires on %s"%(hrn,htype,expire_datetime))
# (f) and finally upload them to manifold server
# xxx todo add an option so the password can be set on the command line
uploader = ManifoldUploader (logger=sfi_logger,
url=myslice_dict['backend'],
platform=myslice_dict['platform'],
- username=myslice_dict['username'])
+ username=myslice_dict['username'],
+ password=options.password)
uploader.prompt_all()
for (hrn,htype,delegated_credential) in hrn_delegated_credentials:
sfi_logger.info("Uploading delegated credential for %s (%s)"%(hrn,htype))
- uploader.upload(delegated_credential,message=hrn)
+ uploader.upload(delegated_credential,message="%s (%s)"%(hrn,htype))
# 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
git://git.onelab.eu / sfa.git / commitdiff