X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fclient%2Fsfi.py;h=01071429a10199cb06b8cbc98f6e7cd508ee40ed;hb=725c637b3d6f4e41773b83f7977e2ba962b5b1b7;hp=8592ec1ae53a04c4d819472a5e20b027f50422df;hpb=952322d76247f8991f3c2688ed7e1f5a22ca4572;p=sfa.git diff --git a/sfa/client/sfi.py b/sfa/client/sfi.py index 8592ec1a..01071429 100755 --- a/sfa/client/sfi.py +++ b/sfa/client/sfi.py @@ -9,20 +9,26 @@ import tempfile import traceback import socket import random +import datetime from lxml import etree from StringIO import StringIO from types import StringTypes, ListType from optparse import OptionParser +import zlib + +from sfa.util.sfalogging import sfa_logger,sfa_logger_goes_to_console from sfa.trust.certificate import Keypair, Certificate +from sfa.trust.gid import GID from sfa.trust.credential import Credential from sfa.util.sfaticket import SfaTicket -from sfa.util.record import * -from sfa.util.namespace import * -from sfa.util.xmlrpcprotocol import ServerException +from sfa.util.record import SfaRecord, UserRecord, SliceRecord, NodeRecord, AuthorityRecord +from sfa.util.xrn import Xrn, get_leaf, get_authority, hrn_to_urn import sfa.util.xmlrpcprotocol as xmlrpcprotocol from sfa.util.config import Config -import zlib +from sfa.util.version import version_core +AGGREGATE_PORT=12346 +CM_PORT=12346 # utility methods here # display methods @@ -47,7 +53,6 @@ def display_list(results): for result in results: print result - def display_records(recordList, dump=False): ''' Print all fields in the record''' for record in recordList: @@ -112,30 +117,45 @@ def load_record_from_file(filename): return record +import uuid +def unique_call_id(): return uuid.uuid4().urn class Sfi: + + required_options=['verbose', 'debug', 'registry', 'sm', 'auth', 'user'] + + # dummy to meet Sfi's expectations for its 'options' field + # i.e. s/t we can do setattr on + class DummyOptions: + pass - geni_am = None - slicemgr = None - registry = None - user = None - authority = None - options = None - hashrequest = False + def __init__ (self,options=None): + if options is None: options=Sfi.DummyOptions() + for opt in Sfi.required_options: + if not hasattr(options,opt): setattr(options,opt,None) + if not hasattr(options,'sfi_dir'): options.sfi_dir=os.path.expanduser("~/.sfi/") + self.options = options + self.slicemgr = None + self.registry = None + self.user = None + self.authority = None + self.hashrequest = False + sfa_logger_goes_to_console() + self.logger=sfa_logger() def create_cmd_parser(self, command, additional_cmdargs=None): - cmdargs = {"gid": "", - "list": "name", + cmdargs = {"list": "authority", "show": "name", "remove": "name", "add": "record", "update": "record", "aggregates": "[name]", "registries": "[name]", + "get_gid": [], + "get_trusted_certs": "cred", "slices": "", "resources": "[name]", "create": "name rspec", - "get_trusted_certs": "cred", "get_ticket": "name rspec", "redeem_ticket": "ticket", "delete": "name", @@ -143,50 +163,50 @@ class Sfi: "start": "name", "stop": "name", "delegate": "name", - "GetVersion": "name", - "ListResources": "name", - "CreateSliver": "name", - "get_geni_aggregates": "name", - "DeleteSliver": "name", - "SliverStatus": "name", - "RenewSliver": "name", - "Shutdown": "name" + "status": "name", + "renew": "name", + "shutdown": "name", + "version": "", } if additional_cmdargs: cmdargs.update(additional_cmdargs) if command not in cmdargs: - print "Invalid command\n" - print "Commands: ", - for key in cmdargs.keys(): - print key + ",", - print "" + msg="Invalid command\n" + msg+="Commands: " + msg += ','.join(cmdargs.keys()) + self.logger.critical(msg) sys.exit(2) parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \ % (command, cmdargs[command])) - if command in ("resources"): - parser.add_option("-f", "--format", dest="format", type="choice", - help="display format ([xml]|dns|ip)", default="xml", - choices=("xml", "dns", "ip")) + # user specifies remote aggregate/sm/component + if command in ("resources", "slices", "create", "delete", "start", "stop", + "restart", "shutdown", "get_ticket", "renew", "status"): parser.add_option("-a", "--aggregate", dest="aggregate", - default=None, help="aggregate hrn") - - if command in ("create", "get_ticket"): - parser.add_option("-a", "--aggregate", dest="aggregate", default=None, - help="aggregate hrn") - - if command in ("start", "stop", "reset", "delete", "slices"): + default=None, help="aggregate host") + parser.add_option("-p", "--port", dest="port", + default=AGGREGATE_PORT, help="aggregate port") parser.add_option("-c", "--component", dest="component", default=None, help="component hrn") - + parser.add_option("-d", "--delegate", dest="delegate", default=None, + action="store_true", + help="Include a credential delegated to the user's root"+\ + "authority in set of credentials for this call") + + # registy filter option if command in ("list", "show", "remove"): parser.add_option("-t", "--type", dest="type", type="choice", - help="type filter ([all]|user|slice|sa|ma|node|aggregate)", - choices=("all", "user", "slice", "sa", "ma", "node", "aggregate"), + help="type filter ([all]|user|slice|authority|node|aggregate)", + choices=("all", "user", "slice", "authority", "node", "aggregate"), default="all") + # display formats + if command in ("resources"): + parser.add_option("-f", "--format", dest="format", type="choice", + help="display format ([xml]|dns|ip)", default="xml", + choices=("xml", "dns", "ip")) if command in ("resources", "show", "list"): parser.add_option("-o", "--output", dest="file", @@ -203,6 +223,14 @@ class Sfi: help="delegate user credential") parser.add_option("-s", "--slice", dest="delegate_slice", help="delegate slice credential", metavar="HRN", default=None) + + if command in ("version"): + parser.add_option("-R","--registry-version", + action="store_true", dest="version_registry", default=False, + help="probe registry version instead of slicemgr") + parser.add_option("-l","--local", + action="store_true", dest="version_local", default=False, + help="display version of the local client") return parser @@ -212,8 +240,6 @@ class Sfi: # Generate command line parser parser = OptionParser(usage="sfi [options] command [command_options] [command_args]", description="Commands: gid,list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset") - parser.add_option("-g", "--geni_am", dest="geni_am", - help="geni am", metavar="URL", default=None) parser.add_option("-r", "--registry", dest="registry", help="root registry", metavar="URL", default=None) parser.add_option("-s", "--slicemgr", dest="sm", @@ -226,14 +252,12 @@ class Sfi: help="user name", metavar="HRN", default=None) parser.add_option("-a", "--auth", dest="auth", help="authority name", metavar="HRN", default=None) - parser.add_option("-v", "--verbose", - action="store_true", dest="verbose", default=False, - help="verbose mode") + parser.add_option("-v", "--verbose", action="count", dest="verbose", default=0, + help="verbose mode - cumulative") parser.add_option("-D", "--debug", action="store_true", dest="debug", default=False, help="Debug (xml-rpc) protocol messages") - parser.add_option("-p", "--protocol", - dest="protocol", default="xmlrpc", + parser.add_option("-p", "--protocol", dest="protocol", default="xmlrpc", help="RPC protocol (xmlrpc or soap)") parser.add_option("-k", "--hashrequest", action="store_true", dest="hashrequest", default=False, @@ -243,54 +267,46 @@ class Sfi: return parser - # - # Establish Connection to SliceMgr and Registry Servers - # - def set_servers(self): + def read_config(self): config_file = self.options.sfi_dir + os.sep + "sfi_config" try: config = Config (config_file) except: - print "Failed to read configuration file", config_file - print "Make sure to remove the export clauses and to add quotes" - if not self.options.verbose: - print "Re-run with -v for more details" + self.logger.critical("Failed to read configuration file %s"%config_file) + 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: - traceback.print_exc() + self.logger.log_exc("Could not read config file %s"%config_file) sys.exit(1) errors = 0 # Set SliceMgr URL if (self.options.sm is not None): - sm_url = self.options.sm + self.sm_url = self.options.sm elif hasattr(config, "SFI_SM"): - sm_url = config.SFI_SM + self.sm_url = config.SFI_SM else: - print "You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s" % config_file + self.logger.error("You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s" % config_file) errors += 1 # Set Registry URL if (self.options.registry is not None): - reg_url = self.options.registry + self.reg_url = self.options.registry elif hasattr(config, "SFI_REGISTRY"): - reg_url = config.SFI_REGISTRY + self.reg_url = config.SFI_REGISTRY else: - print "You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s" % config_file + self.logger.errors("You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s" % config_file) errors += 1 - if (self.options.geni_am is not None): - geni_am_url = self.options.geni_am - elif hasattr(config, "SFI_GENI_AM"): - geni_am_url = config.SFI_GENI_AM - # Set user HRN if (self.options.user is not None): self.user = self.options.user elif hasattr(config, "SFI_USER"): self.user = config.SFI_USER else: - print "You need to set e.g. SFI_USER='plc.princeton.username' in %s" % config_file + self.logger.errors("You need to set e.g. SFI_USER='plc.princeton.username' in %s" % config_file) errors += 1 # Set authority HRN @@ -299,16 +315,19 @@ class Sfi: elif hasattr(config, "SFI_AUTH"): self.authority = config.SFI_AUTH else: - print "You need to set e.g. SFI_AUTH='plc.princeton' in %s" % config_file + self.logger.error("You need to set e.g. SFI_AUTH='plc.princeton' in %s" % config_file) errors += 1 if errors: sys.exit(1) - - if self.options.verbose : - print "Contacting Slice Manager at:", sm_url - print "Contacting Registry at:", reg_url - + + + # + # Establish Connection to SliceMgr and Registry Servers + # + def set_servers(self): + + self.read_config() # Get key and certificate key_file = self.get_key_file() cert_file = self.get_cert_file(key_file) @@ -317,9 +336,10 @@ class Sfi: self.cert_file = cert_file self.cert = Certificate(filename=cert_file) # Establish connection to server(s) - self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file, self.options.debug) - self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file, self.options.debug) - self.geni_am = xmlrpcprotocol.get_server(geni_am_url, key_file, cert_file, self.options.debug) + self.logger.info("Contacting Registry at: %s"%self.reg_url) + self.registry = xmlrpcprotocol.get_server(self.reg_url, key_file, cert_file, self.options) + self.logger.info("Contacting Slice Manager at: %s"%self.sm_url) + self.slicemgr = xmlrpcprotocol.get_server(self.sm_url, key_file, cert_file, self.options) return @@ -339,159 +359,132 @@ class Sfi: def get_key_file(self): file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey") - #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey") if (os.path.isfile(file)): return file else: - print "Key file", file, "does not exist" + self.logger.error("Key file %s does not exist"%file) sys.exit(-1) return def get_cert_file(self, key_file): - #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert") - file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert") - if (os.path.isfile(file)): - return file - else: - k = Keypair(filename=key_file) - cert = Certificate(subject=self.user) - cert.set_pubkey(k) - cert.set_issuer(k, self.user) - cert.sign() - if self.options.verbose : - print "Writing self-signed certificate to", file - cert.save_to_file(file) - return file - - def get_gid(self): - #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid") - file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".gid") + file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert") if (os.path.isfile(file)): - gid = GID(filename=file) - return gid + # use existing cert if it exists + return file else: - cert_str = self.cert.save_to_string(save_parents=True) - gid_str = self.registry.get_gid(cert_str, self.user, "user") - gid = GID(string=gid_str) - if self.options.verbose: - print "Writing user gid to", file - gid.save_to_file(file, save_parents=True) - return gid + try: + # attempt to use gid as the cert. + gid = self._get_gid() + self.logger.info("Writing certificate to %s"%file) + gid.save_to_file(file) + except: + # generate self signed certificate + k = Keypair(filename=key_file) + cert = Certificate(subject=self.user) + cert.set_pubkey(k) + cert.set_issuer(k, self.user) + cert.sign() + self.logger.info("Writing self-signed certificate to %s"%file) + cert.save_to_file(file) + + return file + + def get_cached_gid(self, file): + """ + Return a cached gid + """ + gid = None + if (os.path.isfile(file)): + gid = GID(filename=file) + return gid + + # xxx opts unused + def get_gid(self, opts, args): + """ + Get the specify gid and save it to file + """ + hrn = None + if args: + hrn = args[0] + gid = self._get_gid(hrn) + self.logger.debug("Sfi.get_gid-> %s",gid.save_to_string(save_parents=True)) + return gid + + def _get_gid(self, hrn=None): + """ + git_gid helper. Retrive the gid from the registry and save it to file. + """ + + if not hrn: + hrn = self.user + + gidfile = os.path.join(self.options.sfi_dir, hrn + ".gid") + gid = self.get_cached_gid(gidfile) + if not gid: + user_cred = self.get_user_cred() + records = self.registry.Resolve(hrn, user_cred.save_to_string(save_parents=True)) + if not records: + raise RecordNotFound(args[0]) + gid = GID(string=records[0]['gid']) + self.logger.info("Writing gid to %s"%gidfile) + gid.save_to_file(filename=gidfile) + return gid + + + def get_cached_credential(self, file): + """ + Return a cached credential only if it hasn't expired. + """ + if (os.path.isfile(file)): + credential = Credential(filename=file) + # make sure it isnt expired + if not credential.get_expiration or \ + datetime.datetime.today() < credential.get_expiration(): + return credential + return None def get_user_cred(self): - #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred") file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred") - if (os.path.isfile(file)): - user_cred = Credential(filename=file) - return user_cred - else: - # bootstrap user credential - cert_string = self.cert.save_to_string(save_parents=True) - user_name = self.user.replace(self.authority + ".", '') - if user_name.count(".") > 0: - user_name = user_name.replace(".", '_') - self.user = self.authority + "." + user_name - - user_cred = self.registry.get_self_credential(cert_string, "user", self.user) - if user_cred: - cred = Credential(string=user_cred) - cred.save_to_file(file, save_parents=True) - if self.options.verbose: - print "Writing user credential to", file - return cred - else: - print "Failed to get user credential" - sys.exit(-1) - + return self.get_cred(file, 'user', self.user) + def get_auth_cred(self): if not self.authority: - print "no authority specified. Use -a or set SF_AUTH" + self.logger.critical("no authority specified. Use -a or set SF_AUTH") sys.exit(-1) - - file = os.path.join(self.options.sfi_dir, get_leaf("authority") + ".cred") - if (os.path.isfile(file)): - auth_cred = Credential(filename=file) - return auth_cred - else: - # bootstrap authority credential from user credential - user_cred = self.get_user_cred().save_to_string(save_parents=True) - auth_cred = self.registry.get_credential(user_cred, "authority", self.authority) - if auth_cred: - cred = Credential(string=auth_cred) - cred.save_to_file(file, save_parents=True) - if self.options.verbose: - print "Writing authority credential to", file - return cred - else: - print "Failed to get authority credential" - sys.exit(-1) - + file = os.path.join(self.options.sfi_dir, self.authority + ".cred") + return self.get_cred(file, 'authority', self.authority) + def get_slice_cred(self, name): file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred") - if (os.path.isfile(file)): - slice_cred = Credential(filename=file) - return slice_cred - else: - # bootstrap slice credential from user credential - user_cred = self.get_user_cred().save_to_string(save_parents=True) - arg_list = [user_cred, "slice", name] - slice_cred_str = self.registry.get_credential(user_cred, "slice", name) - if slice_cred_str: - slice_cred = Credential(string=slice_cred_str) - slice_cred.save_to_file(file, save_parents=True) - if self.options.verbose: - print "Writing slice credential to", file - return slice_cred + return self.get_cred(file, 'slice', name) + + def get_cred(self, file, type, hrn): + # attempt to load a cached credential + cred = self.get_cached_credential(file) + if not cred: + if type in ['user']: + cert_string = self.cert.save_to_string(save_parents=True) + user_name = self.user.replace(self.authority + ".", '') + if user_name.count(".") > 0: + user_name = user_name.replace(".", '_') + self.user = self.authority + "." + user_name + cred_str = self.registry.GetSelfCredential(cert_string, hrn, "user") else: - print "Failed to get slice credential" + # bootstrap slice credential from user credential + user_cred = self.get_user_cred().save_to_string(save_parents=True) + cred_str = self.registry.GetCredential(user_cred, hrn, type) + + if not cred_str: + self.logger.critical("Failed to get %s credential" % type) sys.exit(-1) - - def delegate_cred(self, cred, hrn, type='authority'): - # the gid and hrn of the object we are delegating - user_cred = Credential(string=cred) - object_gid = user_cred.get_gid_object() - object_hrn = object_gid.get_hrn() - #cred.set_delegate(True) - #if not cred.get_delegate(): - # raise Exception, "Error: Object credential %(object_hrn)s does not have delegate bit set" % locals() - - - records = self.registry.resolve(cred, hrn) - records = filter_records(type, records) - - if not records: - raise Exception, "Error: Didn't find a %(type)s record for %(hrn)s" % locals() - - # the gid of the user who will be delegated too - record = SfaRecord(dict=records[0]) - delegee_gid = record.get_gid_object() - delegee_hrn = delegee_gid.get_hrn() - - # the key and hrn of the user who will be delegating - user_key = Keypair(filename=self.get_key_file()) - user_hrn = user_cred.get_gid_caller().get_hrn() - - dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn) - dcred.set_gid_caller(delegee_gid) - dcred.set_gid_object(object_gid) - dcred.set_privileges(user_cred.get_privileges()) - dcred.get_privileges().delegate_all_privileges(True) - + + cred = Credential(string=cred_str) + cred.save_to_file(file, save_parents=True) + self.logger.info("Writing %s credential to %s" %(type, file)) - # Save the issuer's gid to a file - fname = self.options.sfi_dir + os.sep + "gid_%d" % random.randint(0, 999999999) - f = open(fname, "w") - f.write(user_cred.get_gid_caller().save_to_string()) - f.close() - dcred.set_issuer_keys(self.get_key_file(), fname) - os.remove(fname) - - dcred.set_parent(user_cred) - dcred.encode() - dcred.sign() - - return dcred.save_to_string(save_parents=True) + return cred + def get_rspec_file(self, rspec): if (os.path.isabs(rspec)): @@ -501,7 +494,7 @@ class Sfi: if (os.path.isfile(file)): return file else: - print "No such rspec file", rspec + self.logger.critical("No such rspec file"%rspec) sys.exit(1) def get_record_file(self, record): @@ -512,7 +505,7 @@ class Sfi: if (os.path.isfile(file)): return file else: - print "No such registry record file", record + self.logger.critical("No such registry record file %s"%record) sys.exit(1) def load_publickey_string(self, fn): @@ -530,38 +523,62 @@ class Sfi: return key_string + # xxx opts undefined def get_component_server_from_hrn(self, hrn): # direct connection to the nodes component manager interface user_cred = self.get_user_cred().save_to_string(save_parents=True) - records = self.registry.resolve(user_cred, hrn) + records = self.registry.Resolve(hrn, user_cred) records = filter_records('node', records) if not records: - print "No such component:", opts.component + self.logger.warning("No such component:%r"% opts.component) record = records[0] - cm_port = "12346" - url = "https://%s:%s" % (record['hostname'], cm_port) - return xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug) - - # + + return self.get_server(record['hostname'], CM_PORT, self.key_file, self.cert_file) + + def get_server(self, host, port, keyfile, certfile): + """ + Return an instance of an xmlrpc server connection + """ + # port is appended onto the domain, before the path. Should look like: + # http://domain:port/path + host_parts = host.split('/') + host_parts[0] = host_parts[0] + ":" + str(port) + url = "http://%s" % "/".join(host_parts) + return xmlrpcprotocol.get_server(url, keyfile, certfile, self.options) + + # xxx opts could be retrieved in self.options + def get_server_from_opts(self, opts): + """ + Return instance of an xmlrpc connection to a slice manager, aggregate + or component server depending on the specified opts + """ + server = self.slicemgr + # direct connection to an aggregate + if hasattr(opts, 'aggregate') and opts.aggregate: + server = self.get_server(opts.aggregate, opts.port, self.key_file, self.cert_file) + # direct connection to the nodes component manager interface + if hasattr(opts, 'component') and opts.component: + server = self.get_component_server_from_hrn(opts.component) + + return server + #========================================================================== # Following functions implement the commands # # Registry-related commands - # + #========================================================================== def dispatch(self, command, cmd_opts, cmd_args): - getattr(self, command)(cmd_opts, cmd_args) - - def gid(self, opts, args): - gid = self.get_gid() - print "GID: %s" % (gid.save_to_string(save_parents=True)) - return + return getattr(self, command)(cmd_opts, cmd_args) # list entires in named authority registry def list(self, opts, args): - user_cred = self.get_user_cred().save_to_string(save_parents=True) + if len(args)!= 1: + self.print_help() + sys.exit(1) hrn = args[0] + user_cred = self.get_user_cred().save_to_string(save_parents=True) try: - list = self.registry.list(user_cred, hrn) + list = self.registry.List(hrn, user_cred) except IndexError: raise Exception, "Not enough parameters for the 'list' command" @@ -579,9 +596,12 @@ class Sfi: # show named registry record def show(self, opts, args): - user_cred = self.get_user_cred().save_to_string(save_parents=True) + if len(args)!= 1: + self.print_help() + sys.exit(1) hrn = args[0] - records = self.registry.resolve(user_cred, hrn) + user_cred = self.get_user_cred().save_to_string(save_parents=True) + records = self.registry.Resolve(hrn, user_cred) records = filter_records(opts.type, records) if not records: print "No record of type", opts.type @@ -609,82 +629,83 @@ class Sfi: return def delegate(self, opts, args): - user_cred = self.get_user_cred() - if opts.delegate_user: - object_cred = user_cred - elif opts.delegate_slice: - object_cred = self.get_slice_cred(opts.delegate_slice) - else: - print "Must specify either --user or --slice " - return - - # the gid and hrn of the object we are delegating - object_gid = object_cred.get_gid_object() - object_hrn = object_gid.get_hrn() - - if not object_cred.get_privileges().get_all_delegate(): - print "Error: Object credential", object_hrn, "does not have delegate bit set" - return - - records = self.registry.resolve(user_cred.save_to_string(save_parents=True), args[0]) - records = filter_records("user", records) - - if not records: - print "Error: Didn't find a user record for", args[0] - return - - # the gid of the user who will be delegated to - delegee_gid = GID(string=records[0]['gid']) - delegee_hrn = delegee_gid.get_hrn() - - # the key and hrn of the user who will be delegating - user_key = Keypair(filename=self.get_key_file()) - user_hrn = user_cred.get_gid_caller().get_hrn() - subject_string = "%s delegated to %s" % (object_hrn, delegee_hrn) - dcred = Credential(subject=subject_string) - dcred.set_gid_caller(delegee_gid) - dcred.set_gid_object(object_gid) - privs = object_cred.get_privileges() - dcred.set_privileges(object_cred.get_privileges()) - dcred.get_privileges().delegate_all_privileges(True) - dcred.set_pubkey(object_gid.get_pubkey()) - dcred.set_issuer(user_key, user_hrn) - dcred.set_parent(object_cred) - dcred.encode() - dcred.sign() - - if opts.delegate_user: - dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_" + + delegee_hrn = args[0] + if opts.delegate_user: + user_cred = self.get_user_cred() + cred = self.delegate_cred(user_cred, delegee_hrn) + elif opts.delegate_slice: + slice_cred = self.get_slice_cred(opts.delegate_slice) + cred = self.delegate_cred(slice_cred, delegee_hrn) + else: + self.logger.warning("Must specify either --user or --slice ") + return + delegated_cred = Credential(string=cred) + object_hrn = delegated_cred.get_gid_object().get_hrn() + if opts.delegate_user: + dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_" + get_leaf(object_hrn) + ".cred") - elif opts.delegate_slice: - dest_fn = os.path_join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_" + elif opts.delegate_slice: + dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_" + get_leaf(object_hrn) + ".cred") + + delegated_cred.save_to_file(dest_fn, save_parents=True) + + self.logger.info("delegated credential for %s to %s and wrote to %s"%(object_hrn, delegee_hrn,dest_fn)) - dcred.save_to_file(dest_fn, save_parents=True) - - print "delegated credential for", object_hrn, "to", delegee_hrn, "and wrote to", dest_fn + def delegate_cred(self, object_cred, hrn): + # the gid and hrn of the object we are delegating + if isinstance(object_cred, str): + object_cred = Credential(string=object_cred) + object_gid = object_cred.get_gid_object() + object_hrn = object_gid.get_hrn() + if not object_cred.get_privileges().get_all_delegate(): + self.logger.error("Object credential %s does not have delegate bit set"%object_hrn) + return + + # the delegating user's gid + caller_gid = self._get_gid(self.user) + caller_gidfile = os.path.join(self.options.sfi_dir, self.user + ".gid") + + # the gid of the user who will be delegated to + delegee_gid = self._get_gid(hrn) + delegee_hrn = delegee_gid.get_hrn() + delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid") + delegee_gid.save_to_file(filename=delegee_gidfile) + dcred = object_cred.delegate(delegee_gidfile, self.get_key_file(), caller_gidfile) + return dcred.save_to_string(save_parents=True) + # removed named registry record # - have to first retrieve the record to be removed def remove(self, opts, args): auth_cred = self.get_auth_cred().save_to_string(save_parents=True) + if len(args)!=1: + self.print_help() + sys.exit(1) hrn = args[0] type = opts.type if type in ['all']: type = '*' - return self.registry.remove(auth_cred, type, hrn) + return self.registry.Remove(hrn, auth_cred, type) # add named registry record def add(self, opts, args): auth_cred = self.get_auth_cred().save_to_string(save_parents=True) + if len(args)!=1: + self.print_help() + sys.exit(1) record_filepath = args[0] rec_file = self.get_record_file(record_filepath) record = load_record_from_file(rec_file).as_dict() - return self.registry.register(auth_cred, record) + return self.registry.Register(record, auth_cred) # update named registry entry def update(self, opts, args): user_cred = self.get_user_cred() + if len(args)!=1: + self.print_help() + sys.exit(1) rec_file = self.get_record_file(args[0]) record = load_record_from_file(rec_file) if record['type'] == "user": @@ -695,7 +716,7 @@ class Sfi: elif record['type'] in ["slice"]: try: cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True) - except ServerException, e: + except xmlrpcprotocol.ServerException, e: # XXX smbaker -- once we have better error return codes, update this # to do something better than a string compare if "Permission error" in e.args[0]: @@ -709,16 +730,16 @@ class Sfi: else: raise "unknown record type" + record.get_type() record = record.as_dict() - return self.registry.update(cred, record) + return self.registry.Update(record, cred) def get_trusted_certs(self, opts, args): """ - return the trusted certs at this interface + return uhe trusted certs at this interface """ trusted_certs = self.registry.get_trusted_certs() for trusted_cert in trusted_certs: cert = Certificate(string=trusted_cert) - print cert.get_subject() + self.logger.debug('Sfi.get_trusted_certs -> %r'%cert.get_subject()) return def aggregates(self, opts, args): @@ -734,20 +755,6 @@ class Sfi: display_list(result) return - def get_geni_aggregates(self, opts, args): - """ - return a list of details about known aggregates - """ - user_cred = self.get_user_cred().save_to_string(save_parents=True) - hrn = None - if args: - hrn = args[0] - - result = self.registry.get_geni_aggregates(user_cred, hrn) - display_list(result) - return - - def registries(self, opts, args): """ return a list of details about known registries @@ -761,20 +768,35 @@ class Sfi: return - # + # ================================================================== # Slice-related commands - # + # ================================================================== - # list available nodes -- use 'resources' w/ no argument instead + + def version(self, opts, args): + if opts.version_local: + version=version_core() + else: + if opts.version_registry: + server=self.registry + else: + server = self.get_server_from_opts(opts) + version=server.GetVersion() + for (k,v) in version.iteritems(): + print "%-20s: %s"%(k,v) # list instantiated slices def slices(self, opts, args): + """ + list instantiated slices + """ user_cred = self.get_user_cred().save_to_string(save_parents=True) - server = self.slicemgr - # direct connection to the nodes component manager interface - if opts.component: - server = self.get_component_server_from_hrn(opts.component) - results = server.get_slices(user_cred) + creds = [user_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(user_cred, get_authority(self.authority)) + creds.append(delegated_cred) + server = self.get_server_from_opts(opts) + results = server.ListSlices(creds, unique_call_id()) display_list(results) return @@ -782,26 +804,26 @@ class Sfi: def resources(self, opts, args): user_cred = self.get_user_cred().save_to_string(save_parents=True) server = self.slicemgr - if opts.aggregate: - agg_hrn = opts.aggregate - aggregates = self.registry.get_aggregates(user_cred, agg_hrn) - if not aggregates: - raise Exception, "No such aggregate %s" % agg_hrn - aggregate = aggregates[0] - url = "http://%s:%s" % (aggregate['addr'], aggregate['port']) - server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug) + call_options = {} + server = self.get_server_from_opts(opts) + if args: cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True) hrn = args[0] + call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')} else: cred = user_cred hrn = None - - result = server.get_resources(cred, hrn) + + creds = [cred] + if opts.delegate: + delegated_cred = self.delegate_cred(cred, get_authority(self.authority)) + creds.append(delegated_cred) + result = server.ListResources(creds, call_options,unique_call_id()) format = opts.format - - display_rspec(result, format) - if (opts.file is not None): + if opts.file is None: + display_rspec(result, format) + else: file = opts.file if not file.startswith(os.sep): file = os.path.join(self.options.sfi_dir, file) @@ -811,38 +833,36 @@ class Sfi: # created named slice with given rspec def create(self, opts, args): slice_hrn = args[0] + slice_urn = hrn_to_urn(slice_hrn, 'slice') user_cred = self.get_user_cred() slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) rspec_file = self.get_rspec_file(args[1]) rspec = open(rspec_file).read() - server = self.slicemgr - if opts.aggregate: - aggregates = self.registry.get_aggregates(user_cred, opts.aggregate) - if not aggregates: - raise Exception, "No such aggregate %s" % opts.aggregate - aggregate = aggregates[0] - url = "http://%s:%s" % (aggregate['addr'], aggregate['port']) - server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug) - return server.create_slice(slice_cred, slice_hrn, rspec) + server = self.get_server_from_opts(opts) + result = server.CreateSliver(slice_urn, creds, rspec, [], unique_call_id()) + print result + return result # get a ticket for the specified slice def get_ticket(self, opts, args): slice_hrn, rspec_path = args[0], args[1] + slice_urn = hrn_to_urn(slice_hrn, 'slice') user_cred = self.get_user_cred() slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) rspec_file = self.get_rspec_file(rspec_path) rspec = open(rspec_file).read() - server = self.slicemgr - if opts.aggregate: - aggregates = self.registry.get_aggregates(user_cred, opts.aggregate) - if not aggregates: - raise Exception, "No such aggregate %s" % opts.aggregate - aggregate = aggregates[0] - url = "http://%s:%s" % (aggregate['addr'], aggregate['port']) - server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug) - ticket_string = server.get_ticket(slice_cred, slice_hrn, rspec) + server = self.get_server_from_opts(opts) + ticket_string = server.GetTicket(slice_urn, creds, rspec, []) file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket") - print "writing ticket to ", file + self.logger.info("writing ticket to %s"%file) ticket = SfaTicket(string=ticket_string) ticket.save_to_file(filename=file, save_parents=True) @@ -853,7 +873,8 @@ class Sfi: # use this to get the right slice credential ticket = SfaTicket(filename=ticket_file) ticket.decode() - slice_hrn = ticket.gidObject.get_hrn() + slice_hrn = ticket.gidObject.get_hrn() + slice_urn = hrn_to_urn(slice_hrn, 'slice') #slice_hrn = ticket.attributes['slivers'][0]['hrn'] user_cred = self.get_user_cred() slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True) @@ -868,158 +889,141 @@ class Sfi: connections = {} for hostname in hostnames: try: - cm_port = "12346" - url = "https://%(hostname)s:%(cm_port)s" % locals() - print "Calling redeem_ticket at %(url)s " % locals(), - cm = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug) - cm.redeem_ticket(slice_cred, ticket.save_to_string(save_parents=True)) - print "Success" + self.logger.info("Calling redeem_ticket at %(hostname)s " % locals()) + server = self.get_server(hostname, CM_PORT, self.key_file, \ + self.cert_file, self.options.debug) + server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred) + self.logger.info("Success") except socket.gaierror: - print "Failed:", - print "Componet Manager not accepting requests" + self.logger.error("redeem_ticket failed: Component Manager not accepting requests") except Exception, e: - print "Failed:", e.message - + self.logger.log_exc(e.message) return # delete named slice def delete(self, opts, args): slice_hrn = args[0] - server = self.slicemgr - # direct connection to the nodes component manager interface - if opts.component: - server = self.get_component_server_from_hrn(opts.component) - + slice_urn = hrn_to_urn(slice_hrn, 'slice') slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True) - return server.delete_slice(slice_cred, slice_hrn) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + server = self.get_server_from_opts(opts) + return server.DeleteSliver(slice_urn, creds, unique_call_id()) # start named slice def start(self, opts, args): slice_hrn = args[0] - server = self.slicemgr - # direct connection to the nodes component manager interface - if opts.component: - server = self.get_component_server_from_hrn(opts.component) - + slice_urn = hrn_to_urn(slice_hrn, 'slice') slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True) - return server.start_slice(slice_cred, slice_hrn) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + server = self.get_server_from_opts(opts) + return server.Start(slice_urn, creds) # stop named slice def stop(self, opts, args): slice_hrn = args[0] - server = self.slicemgr - # direct connection to the nodes component manager interface - if opts.component: - server = self.get_component_server_from_hrn(opts.component) - + slice_urn = hrn_to_urn(slice_hrn, 'slice') slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True) - return server.stop_slice(slice_cred, slice_hrn) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + server = self.get_server_from_opts(opts) + return server.Stop(slice_urn, creds) # reset named slice def reset(self, opts, args): slice_hrn = args[0] - server = self.slicemgr - # direct connection to the nodes component manager interface - if opts.component: - server = self.get_component_server_from_hrn(opts.component) + slice_urn = hrn_to_urn(slice_hrn, 'slice') + server = self.get_server_from_opts(opts) slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True) - return server.reset_slice(slice_cred, slice_hrn) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + return server.reset_slice(creds, slice_urn) + def renew(self, opts, args): + slice_hrn = args[0] + slice_urn = hrn_to_urn(slice_hrn, 'slice') + server = self.get_server_from_opts(opts) + slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + time = args[1] + return server.RenewSliver(slice_urn, creds, time, unique_call_id()) - # GENI AM related calls - def GetVersion(self, opts, args): - server = self.geni_am - print server.GetVersion() + def status(self, opts, args): + slice_hrn = args[0] + slice_urn = hrn_to_urn(slice_hrn, 'slice') + slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + server = self.get_server_from_opts(opts) + print server.SliverStatus(slice_urn, creds) - def ListResources(self, opts, args): - user_cred = self.get_user_cred().save_to_string(save_parents=True) - server = self.geni_am - call_options = {'geni_compressed': True} - xrn = None - cred = user_cred - if args: - xrn = args[0] - cred = self.get_slice_cred(xrn).save_to_string(save_parents=True) - if xrn: - call_options['geni_slice_urn'] = xrn - - rspec = server.ListResources([cred], call_options) - rspec = zlib.decompress(rspec.decode('base64')) - print rspec - - def CreateSliver(self, opts, args): - slice_xrn = args[0] - slice_cred = self.get_slice_cred(slice_xrn).save_to_string(save_parents=True) - rspec_file = self.get_rspec_file(args[1]) - rspec = open(rspec_file).read() - server = self.geni_am - return server.CreateSliver(slice_xrn, [slice_cred], rspec, []) - - def DeleteSliver(self, opts, args): - slice_xrn = args[0] - slice_cred = self.get_slice_cred(slice_xrn).save_to_string(save_parents=True) - server = self.geni_am - return server.DeleteSliver(slice_xrn, [slice_cred]) - - def SliverStatus(self, opts, args): - slice_xrn = args[0] - slice_cred = self.get_slice_cred(slice_xrn).save_to_string(save_parents=True) - server = self.geni_am - print server.SliverStatus(slice_xrn, [slice_cred]) - - def RenewSliver(self, opts, args): - slice_xrn = args[0] - slice_cred = self.get_slice_cred(slice_xrn).save_to_string(save_parents=True) - time = args[1] - server = self.geni_am - return server.RenewSliver(slice_xrn, [slice_cred], time) - - def Shutdown(self, opts, args): - slice_xrn = args[0] - slice_cred = self.get_slice_cred(slice_xrn).save_to_string(save_parents=True) - server = self.geni_am - return server.Shutdown(slice_xrn, [slice_cred]) + def shutdown(self, opts, args): + slice_hrn = args[0] + slice_urn = hrn_to_urn(slice_hrn, 'slice') + slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True) + creds = [slice_cred] + if opts.delegate: + delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority)) + creds.append(delegated_cred) + server = self.get_server_from_opts(opts) + return server.Shutdown(slice_urn, creds) + def print_help (self): + self.sfi_parser.print_help() + self.cmd_parser.print_help() + # # Main: parse arguments and dispatch to command # def main(self): - parser = self.create_parser() - (options, args) = parser.parse_args() + self.sfi_parser = self.create_parser() + (options, args) = self.sfi_parser.parse_args() self.options = options - + + self.logger.setLevelFromOptVerbose(self.options.verbose) if options.hashrequest: self.hashrequest = True if len(args) <= 0: - print "No command given. Use -h for help." - return - 1 + self.logger.critical("No command given. Use -h for help.") + return -1 command = args[0] - (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:]) - if self.options.verbose : - print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm, - options.sfi_dir, options.user, - options.auth) - print "Command %s" % command - if command in ("resources"): - print "resources cmd_opts %s" % cmd_opts.format - elif command in ("list", "show", "remove"): - print "cmd_opts.type %s" % cmd_opts.type - print "cmd_args %s" % cmd_args - + self.cmd_parser = self.create_cmd_parser(command) + (cmd_opts, cmd_args) = self.cmd_parser.parse_args(args[1:]) + self.set_servers() + self.logger.info("Command=%s" % command) + if command in ("resources"): + self.logger.debug("resources cmd_opts %s" % cmd_opts.format) + elif command in ("list", "show", "remove"): + self.logger.debug("cmd_opts.type %s" % cmd_opts.type) + self.logger.debug('cmd_args %s',cmd_args) + try: self.dispatch(command, cmd_opts, cmd_args) except KeyError: - raise - print "Command not found:", command + self.logger.critical ("Unknown command %s"%command) sys.exit(1) return if __name__ == "__main__": - Sfi().main() + Sfi().main()