3 # sfi -- slice-based facility interface
13 from lxml import etree
14 from StringIO import StringIO
15 from types import StringTypes, ListType
16 from optparse import OptionParser
19 from sfa.util.sfalogging import sfa_logger,sfa_logger_goes_to_console
20 from sfa.trust.certificate import Keypair, Certificate
21 from sfa.trust.credential import Credential
22 from sfa.util.sfaticket import SfaTicket
23 from sfa.util.record import SfaRecord, UserRecord, SliceRecord, NodeRecord, AuthorityRecord
24 from sfa.util.namespace import get_leaf, get_authority, hrn_to_urn
25 from sfa.util.xmlrpcprotocol import ServerException
26 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
27 from sfa.util.config import Config
33 # utility methods here
35 def display_rspec(rspec, format='rspec'):
37 tree = etree.parse(StringIO(rspec))
39 result = root.xpath("./network/site/node/hostname/text()")
40 elif format in ['ip']:
41 # The IP address is not yet part of the new RSpec
42 # so this doesn't do anything yet.
43 tree = etree.parse(StringIO(rspec))
45 result = root.xpath("./network/site/node/ipv4/text()")
52 def display_list(results):
53 for result in results:
56 def display_records(recordList, dump=False):
57 ''' Print all fields in the record'''
58 for record in recordList:
59 display_record(record, dump)
61 def display_record(record, dump=False):
65 info = record.getdict()
66 print "%s (%s)" % (info['hrn'], info['type'])
70 def filter_records(type, records):
72 for record in records:
73 if (record['type'] == type) or (type == "all"):
74 filtered_records.append(record)
75 return filtered_records
79 def save_rspec_to_file(rspec, filename):
80 if not filename.endswith(".rspec"):
81 filename = filename + ".rspec"
83 f = open(filename, 'w')
88 def save_records_to_file(filename, recordList):
90 for record in recordList:
92 save_record_to_file(filename + "." + str(index), record)
94 save_record_to_file(filename, record)
97 def save_record_to_file(filename, record):
98 if record['type'] in ['user']:
99 record = UserRecord(dict=record)
100 elif record['type'] in ['slice']:
101 record = SliceRecord(dict=record)
102 elif record['type'] in ['node']:
103 record = NodeRecord(dict=record)
104 elif record['type'] in ['authority', 'ma', 'sa']:
105 record = AuthorityRecord(dict=record)
107 record = SfaRecord(dict=record)
108 str = record.save_to_string()
109 file(filename, "w").write(str)
114 def load_record_from_file(filename):
115 str = file(filename, "r").read()
116 record = SfaRecord(string=str)
127 self.authority = None
129 self.hashrequest = False
130 sfa_logger_goes_to_console()
131 self.logger=sfa_logger()
133 def create_cmd_parser(self, command, additional_cmdargs=None):
134 cmdargs = {"list": "name",
139 "aggregates": "[name]",
140 "registries": "[name]",
142 "get_trusted_certs": "cred",
144 "resources": "[name]",
145 "create": "name rspec",
146 "get_ticket": "name rspec",
147 "redeem_ticket": "ticket",
159 if additional_cmdargs:
160 cmdargs.update(additional_cmdargs)
162 if command not in cmdargs:
163 msg="Invalid command\n"
165 msg += ','.join(cmdargs.keys())
166 self.logger.critical(msg)
169 parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
170 % (command, cmdargs[command]))
172 # user specifies remote aggregate/sm/component
173 if command in ("resources", "slices", "create", "delete", "start", "stop",
174 "restart", "shutdown", "get_ticket", "renew", "status"):
175 parser.add_option("-a", "--aggregate", dest="aggregate",
176 default=None, help="aggregate host")
177 parser.add_option("-p", "--port", dest="port",
178 default=AGGREGATE_PORT, help="aggregate port")
179 parser.add_option("-c", "--component", dest="component", default=None,
180 help="component hrn")
181 parser.add_option("-d", "--delegate", dest="delegate", default=None,
183 help="Include a credential delegated to the user's root"+\
184 "authority in set of credentials for this call")
186 # registy filter option
187 if command in ("list", "show", "remove"):
188 parser.add_option("-t", "--type", dest="type", type="choice",
189 help="type filter ([all]|user|slice|authority|node|aggregate)",
190 choices=("all", "user", "slice", "authority", "node", "aggregate"),
193 if command in ("resources"):
194 parser.add_option("-f", "--format", dest="format", type="choice",
195 help="display format ([xml]|dns|ip)", default="xml",
196 choices=("xml", "dns", "ip"))
198 if command in ("resources", "show", "list"):
199 parser.add_option("-o", "--output", dest="file",
200 help="output XML to file", metavar="FILE", default=None)
202 if command in ("show", "list"):
203 parser.add_option("-f", "--format", dest="format", type="choice",
204 help="display format ([text]|xml)", default="text",
205 choices=("text", "xml"))
207 if command in ("delegate"):
208 parser.add_option("-u", "--user",
209 action="store_true", dest="delegate_user", default=False,
210 help="delegate user credential")
211 parser.add_option("-s", "--slice", dest="delegate_slice",
212 help="delegate slice credential", metavar="HRN", default=None)
217 def create_parser(self):
219 # Generate command line parser
220 parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
221 description="Commands: gid,list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
222 parser.add_option("-r", "--registry", dest="registry",
223 help="root registry", metavar="URL", default=None)
224 parser.add_option("-s", "--slicemgr", dest="sm",
225 help="slice manager", metavar="URL", default=None)
226 default_sfi_dir = os.path.expanduser("~/.sfi/")
227 parser.add_option("-d", "--dir", dest="sfi_dir",
228 help="config & working directory - default is " + default_sfi_dir,
229 metavar="PATH", default=default_sfi_dir)
230 parser.add_option("-u", "--user", dest="user",
231 help="user name", metavar="HRN", default=None)
232 parser.add_option("-a", "--auth", dest="auth",
233 help="authority name", metavar="HRN", default=None)
234 parser.add_option("-v", "--verbose", action="count", dest="verbose", default=0,
235 help="verbose mode - cumulative")
236 parser.add_option("-D", "--debug",
237 action="store_true", dest="debug", default=False,
238 help="Debug (xml-rpc) protocol messages")
239 parser.add_option("-p", "--protocol", dest="protocol", default="xmlrpc",
240 help="RPC protocol (xmlrpc or soap)")
241 parser.add_option("-k", "--hashrequest",
242 action="store_true", dest="hashrequest", default=False,
243 help="Create a hash of the request that will be authenticated on the server")
244 parser.disable_interspersed_args()
250 # Establish Connection to SliceMgr and Registry Servers
252 def set_servers(self):
253 config_file = self.options.sfi_dir + os.sep + "sfi_config"
255 config = Config (config_file)
257 self.logger.critical("Failed to read configuration file %s"%config_file)
258 self.logger.info("Make sure to remove the export clauses and to add quotes")
259 if self.options.verbose==0:
260 self.logger.info("Re-run with -v for more details")
262 self.logger.log_exc("Could not read config file %s"%config_file)
267 if (self.options.sm is not None):
268 sm_url = self.options.sm
269 elif hasattr(config, "SFI_SM"):
270 sm_url = config.SFI_SM
272 self.logger.error("You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s" % config_file)
276 if (self.options.registry is not None):
277 reg_url = self.options.registry
278 elif hasattr(config, "SFI_REGISTRY"):
279 reg_url = config.SFI_REGISTRY
281 self.logger.errors("You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s" % config_file)
286 if (self.options.user is not None):
287 self.user = self.options.user
288 elif hasattr(config, "SFI_USER"):
289 self.user = config.SFI_USER
291 self.logger.errors("You need to set e.g. SFI_USER='plc.princeton.username' in %s" % config_file)
295 if (self.options.auth is not None):
296 self.authority = self.options.auth
297 elif hasattr(config, "SFI_AUTH"):
298 self.authority = config.SFI_AUTH
300 self.logger.error("You need to set e.g. SFI_AUTH='plc.princeton' in %s" % config_file)
307 # Get key and certificate
308 key_file = self.get_key_file()
309 cert_file = self.get_cert_file(key_file)
310 self.key = Keypair(filename=key_file)
311 self.key_file = key_file
312 self.cert_file = cert_file
313 self.cert = Certificate(filename=cert_file)
314 # Establish connection to server(s)
315 self.logger.info("Contacting Registry at: %s"%reg_url)
316 self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file, self.options)
317 self.logger.info("Contacting Slice Manager at: %s"%sm_url)
318 self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file, self.options)
323 # Get various credential and spec files
325 # Establishes limiting conventions
326 # - conflates MAs and SAs
327 # - assumes last token in slice name is unique
329 # Bootstraps credentials
330 # - bootstrap user credential from self-signed certificate
331 # - bootstrap authority credential from user credential
332 # - bootstrap slice credential from user credential
336 def get_key_file(self):
337 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey")
338 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
339 if (os.path.isfile(file)):
342 self.logger.error("Key file %s does not exist"%file)
346 def get_cert_file(self, key_file):
348 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
349 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert")
350 if (os.path.isfile(file)):
353 k = Keypair(filename=key_file)
354 cert = Certificate(subject=self.user)
356 cert.set_issuer(k, self.user)
358 self.logger.info("Writing self-signed certificate to %s"%file)
359 cert.save_to_file(file)
362 def get_cached_gid(self, file):
367 if (os.path.isfile(file)):
368 gid = GID(filename=file)
371 def get_gid(self, opts, args):
375 gid = self._get_gid(hrn)
376 self.logger.debug("Sfi.get_gid-> %s",gid.save_to_string(save_parents=True))
379 def _get_gid(self, hrn=None):
383 gidfile = os.path.join(self.options.sfi_dir, hrn + ".gid")
384 gid = self.get_cached_gid(gidfile)
386 user_cred = self.get_user_cred()
387 records = self.registry.Resolve(hrn, user_cred.save_to_string(save_parents=True))
389 raise RecordNotFound(args[0])
390 gid = GID(string=records[0]['gid'])
391 self.logger.info("Writing gid to %s"%gidfile)
392 gid.save_to_file(filename=gidfile)
396 def get_cached_credential(self, file):
398 Return a cached credential only if it hasn't expired.
400 if (os.path.isfile(file)):
401 credential = Credential(filename=file)
402 # make sure it isnt expired
403 if not credential.get_lifetime or \
404 datetime.datetime.today() < credential.get_lifetime():
408 def get_user_cred(self):
409 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
410 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred")
411 return self.get_cred(file, 'user', self.user)
413 def get_auth_cred(self):
414 if not self.authority:
415 self.logger.critical("no authority specified. Use -a or set SF_AUTH")
417 file = os.path.join(self.options.sfi_dir, get_leaf("authority") + ".cred")
418 return self.get_cred(file, 'authority', self.authority)
420 def get_slice_cred(self, name):
421 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
422 return self.get_cred(file, 'slice', name)
424 def get_cred(self, file, type, hrn):
425 # attempt to load a cached credential
426 cred = self.get_cached_credential(file)
429 cert_string = self.cert.save_to_string(save_parents=True)
430 user_name = self.user.replace(self.authority + ".", '')
431 if user_name.count(".") > 0:
432 user_name = user_name.replace(".", '_')
433 self.user = self.authority + "." + user_name
434 cred_str = self.registry.GetSelfCredential(cert_string, hrn, "user")
436 # bootstrap slice credential from user credential
437 user_cred = self.get_user_cred().save_to_string(save_parents=True)
438 cred_str = self.registry.GetCredential(user_cred, hrn, type)
441 self.logger.critical("Failed to get %s credential" % type)
444 cred = Credential(string=cred_str)
445 cred.save_to_file(file, save_parents=True)
446 self.logger.info("Writing %s credential to %s" %(type, file))
451 def get_rspec_file(self, rspec):
452 if (os.path.isabs(rspec)):
455 file = os.path.join(self.options.sfi_dir, rspec)
456 if (os.path.isfile(file)):
459 self.logger.critical("No such rspec file"%rspec)
462 def get_record_file(self, record):
463 if (os.path.isabs(record)):
466 file = os.path.join(self.options.sfi_dir, record)
467 if (os.path.isfile(file)):
470 self.logger.critical("No such registry record file %s"%record)
473 def load_publickey_string(self, fn):
475 key_string = f.read()
477 # if the filename is a private key file, then extract the public key
478 if "PRIVATE KEY" in key_string:
479 outfn = tempfile.mktemp()
480 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
483 key_string = f.read()
488 def get_component_server_from_hrn(self, hrn):
489 # direct connection to the nodes component manager interface
490 user_cred = self.get_user_cred().save_to_string(save_parents=True)
491 records = self.registry.Resolve(hrn, user_cred)
492 records = filter_records('node', records)
494 self.logger.warning("No such component:%r"% opts.component)
497 return self.get_server(record['hostname'], CM_PORT, self.key_file, \
498 self.cert_file, self.options)
500 def get_server(self, host, port, keyfile, certfile):
502 Return an instnace of an xmlrpc server connection
504 url = "http://%s:%s" % (host, port)
505 return xmlrpcprotocol.get_server(url, keyfile, certfile, self.options)
507 def get_server_from_opts(self, opts):
509 Return instance of an xmlrpc connection to a slice manager, aggregate
510 or component server depending on the specified opts
512 server = self.slicemgr
513 # direct connection to an aggregate
514 if hasattr(opts, 'aggregate') and opts.aggregate:
515 server = self.get_server(opts.aggregate, opts.port, self.key_file, self.cert_file)
516 # direct connection to the nodes component manager interface
517 if hasattr(opts, 'component') and opts.component:
518 server = self.get_component_server_from_hrn(opts.component)
521 #==========================================================================
522 # Following functions implement the commands
524 # Registry-related commands
525 #==========================================================================
527 def dispatch(self, command, cmd_opts, cmd_args):
528 return getattr(self, command)(cmd_opts, cmd_args)
530 # list entires in named authority registry
531 def list(self, opts, args):
532 user_cred = self.get_user_cred().save_to_string(save_parents=True)
535 list = self.registry.List(hrn, user_cred)
537 raise Exception, "Not enough parameters for the 'list' command"
539 # filter on person, slice, site, node, etc.
540 # THis really should be in the self.filter_records funct def comment...
541 list = filter_records(opts.type, list)
543 print "%s (%s)" % (record['hrn'], record['type'])
546 if not file.startswith(os.sep):
547 file = os.path.join(self.options.sfi_dir, file)
548 save_records_to_file(file, list)
551 # show named registry record
552 def show(self, opts, args):
553 user_cred = self.get_user_cred().save_to_string(save_parents=True)
555 records = self.registry.Resolve(hrn, user_cred)
556 records = filter_records(opts.type, records)
558 print "No record of type", opts.type
559 for record in records:
560 if record['type'] in ['user']:
561 record = UserRecord(dict=record)
562 elif record['type'] in ['slice']:
563 record = SliceRecord(dict=record)
564 elif record['type'] in ['node']:
565 record = NodeRecord(dict=record)
566 elif record['type'] in ['authority', 'ma', 'sa']:
567 record = AuthorityRecord(dict=record)
569 record = SfaRecord(dict=record)
570 if (opts.format == "text"):
573 print record.save_to_string()
577 if not file.startswith(os.sep):
578 file = os.path.join(self.options.sfi_dir, file)
579 save_records_to_file(file, records)
582 def delegate(self, opts, args):
584 delegee_hrn = args[0]
585 if opts.delegate_user:
586 user_cred = self.get_user_cred()
587 cred = self.delegate_cred(user_cred, delegee_hrn)
588 elif opts.delegate_slice:
589 slice_cred = self.get_slice_cred(opts.delegate_slice)
590 cred = self.delegate_cred(slice_cred, delegee_hrn)
592 self.logger.warning("Must specify either --user or --slice <hrn>")
594 delegated_cred = Credential(string=cred)
595 object_hrn = delegated_cred.get_gid_object().get_hrn()
596 if opts.delegate_user:
597 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
598 + get_leaf(object_hrn) + ".cred")
599 elif opts.delegate_slice:
600 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
601 + get_leaf(object_hrn) + ".cred")
603 delegated_cred.save_to_file(dest_fn, save_parents=True)
605 self.logger.info("delegated credential for %s to %s and wrote to %s"%(object_hrn, delegee_hrn,dest_fn))
607 def delegate_cred(self, object_cred, hrn):
608 # the gid and hrn of the object we are delegating
609 if isinstance(object_cred, str):
610 object_cred = Credential(string=object_cred)
611 object_gid = object_cred.get_gid_object()
612 object_hrn = object_gid.get_hrn()
614 if not object_cred.get_privileges().get_all_delegate():
615 self.logger.error("Object credential %s does not have delegate bit set"%object_hrn)
618 # the delegating user's gid
619 caller_gid = self._get_gid(self.user)
620 caller_gidfile = os.path.join(self.options.sfi_dir, self.user + ".gid")
622 # the gid of the user who will be delegated to
623 delegee_gid = self._get_gid(hrn)
624 delegee_hrn = delegee_gid.get_hrn()
625 delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid")
626 delegee_gid.save_to_file(filename=delegee_gidfile)
627 dcred = object_cred.delegate(delegee_gidfile, self.get_key_file(), caller_gidfile)
628 return dcred.save_to_string(save_parents=True)
630 # removed named registry record
631 # - have to first retrieve the record to be removed
632 def remove(self, opts, args):
633 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
638 return self.registry.Remove(hrn, auth_cred, type)
640 # add named registry record
641 def add(self, opts, args):
642 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
643 record_filepath = args[0]
644 rec_file = self.get_record_file(record_filepath)
645 record = load_record_from_file(rec_file).as_dict()
646 return self.registry.Register(record, auth_cred)
648 # update named registry entry
649 def update(self, opts, args):
650 user_cred = self.get_user_cred()
651 rec_file = self.get_record_file(args[0])
652 record = load_record_from_file(rec_file)
653 if record['type'] == "user":
654 if record.get_name() == user_cred.get_gid_object().get_hrn():
655 cred = user_cred.save_to_string(save_parents=True)
657 cred = self.get_auth_cred().save_to_string(save_parents=True)
658 elif record['type'] in ["slice"]:
660 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
661 except ServerException, e:
662 # XXX smbaker -- once we have better error return codes, update this
663 # to do something better than a string compare
664 if "Permission error" in e.args[0]:
665 cred = self.get_auth_cred().save_to_string(save_parents=True)
668 elif record.get_type() in ["authority"]:
669 cred = self.get_auth_cred().save_to_string(save_parents=True)
670 elif record.get_type() == 'node':
671 cred = self.get_auth_cred().save_to_string(save_parents=True)
673 raise "unknown record type" + record.get_type()
674 record = record.as_dict()
675 return self.registry.Update(record, cred)
677 def get_trusted_certs(self, opts, args):
679 return uhe trusted certs at this interface
681 trusted_certs = self.registry.get_trusted_certs()
682 for trusted_cert in trusted_certs:
683 cert = Certificate(string=trusted_cert)
684 self.logger.debug('Sfi.get_trusted_certs -> %r'%cert.get_subject())
687 def aggregates(self, opts, args):
689 return a list of details about known aggregates
691 user_cred = self.get_user_cred().save_to_string(save_parents=True)
696 result = self.registry.get_aggregates(user_cred, hrn)
700 def registries(self, opts, args):
702 return a list of details about known registries
704 user_cred = self.get_user_cred().save_to_string(save_parents=True)
708 result = self.registry.get_registries(user_cred, hrn)
713 # ==================================================================
714 # Slice-related commands
715 # ==================================================================
718 def version(self, opts, args):
719 server = self.get_server_from_opts(opts)
721 print server.GetVersion()
723 # list instantiated slices
724 def slices(self, opts, args):
726 list instantiated slices
728 user_cred = self.get_user_cred().save_to_string(save_parents=True)
731 delegated_cred = self.delegate_cred(user_cred, get_authority(self.authority))
732 creds.append(delegated_cred)
733 server = self.get_server_from_opts(opts)
734 results = server.ListSlices(creds)
735 display_list(results)
738 # show rspec for named slice
739 def resources(self, opts, args):
740 user_cred = self.get_user_cred().save_to_string(save_parents=True)
741 server = self.slicemgr
743 server = self.get_server_from_opts(opts)
746 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
748 call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')}
755 delegated_cred = self.delegate_cred(cred, get_authority(self.authority))
756 creds.append(delegated_cred)
757 result = server.ListResources(creds, call_options)
759 display_rspec(result, format)
760 if (opts.file is not None):
762 if not file.startswith(os.sep):
763 file = os.path.join(self.options.sfi_dir, file)
764 save_rspec_to_file(result, file)
767 # created named slice with given rspec
768 def create(self, opts, args):
770 slice_urn = hrn_to_urn(slice_hrn, 'slice')
771 user_cred = self.get_user_cred()
772 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
775 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
776 creds.append(delegated_cred)
777 rspec_file = self.get_rspec_file(args[1])
778 rspec = open(rspec_file).read()
779 server = self.get_server_from_opts(opts)
780 result = server.CreateSliver(slice_urn, creds, rspec, [])
784 # get a ticket for the specified slice
785 def get_ticket(self, opts, args):
786 slice_hrn, rspec_path = args[0], args[1]
787 slice_urn = hrn_to_urn(slice_hrn, 'slice')
788 user_cred = self.get_user_cred()
789 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
792 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
793 creds.append(delegated_cred)
794 rspec_file = self.get_rspec_file(rspec_path)
795 rspec = open(rspec_file).read()
796 server = self.get_server_from_opts(opts)
797 ticket_string = server.GetTicket(slice_urn, creds, rspec, [])
798 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
799 self.logger.info("writing ticket to %s"%file)
800 ticket = SfaTicket(string=ticket_string)
801 ticket.save_to_file(filename=file, save_parents=True)
803 def redeem_ticket(self, opts, args):
804 ticket_file = args[0]
806 # get slice hrn from the ticket
807 # use this to get the right slice credential
808 ticket = SfaTicket(filename=ticket_file)
810 slice_hrn = ticket.gidObject.get_hrn()
811 slice_urn = hrn_to_urn(slice_hrn, 'slice')
812 #slice_hrn = ticket.attributes['slivers'][0]['hrn']
813 user_cred = self.get_user_cred()
814 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
816 # get a list of node hostnames from the RSpec
817 tree = etree.parse(StringIO(ticket.rspec))
818 root = tree.getroot()
819 hostnames = root.xpath("./network/site/node/hostname/text()")
821 # create an xmlrpc connection to the component manager at each of these
822 # components and gall redeem_ticket
824 for hostname in hostnames:
826 self.logger.info("Calling redeem_ticket at %(hostname)s " % locals())
827 server = self.get_server(hostname, CM_PORT, self.key_file, \
828 self.cert_file, self.options.debug)
829 server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred)
830 self.logger.info("Success")
831 except socket.gaierror:
832 self.logger.error("redeem_ticket failed: Component Manager not accepting requests")
834 self.logger.log_exc(e.message)
838 def delete(self, opts, args):
840 slice_urn = hrn_to_urn(slice_hrn, 'slice')
841 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
844 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
845 creds.append(delegated_cred)
846 server = self.get_server_from_opts(opts)
847 return server.DeleteSliver(slice_urn, creds)
850 def start(self, opts, args):
852 slice_urn = hrn_to_urn(slice_hrn, 'slice')
853 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
856 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
857 creds.append(delegated_cred)
858 server = self.get_server_from_opts(opts)
859 return server.Start(slice_urn, creds)
862 def stop(self, opts, args):
864 slice_urn = hrn_to_urn(slice_hrn, 'slice')
865 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
868 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
869 creds.append(delegated_cred)
870 server = self.get_server_from_opts(opts)
871 return server.Stop(slice_urn, creds)
874 def reset(self, opts, args):
876 slice_urn = hrn_to_urn(slice_hrn, 'slice')
877 server = self.get_server_from_opts(opts)
878 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
881 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
882 creds.append(delegated_cred)
883 return server.reset_slice(creds, slice_urn)
885 def renew(self, opts, args):
887 slice_urn = hrn_to_urn(slice_hrn, 'slice')
888 server = self.get_server_from_opts(opts)
889 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
892 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
893 creds.append(delegated_cred)
895 return server.RenewSliver(slice_urn, creds, time)
898 def status(self, opts, args):
900 slice_urn = hrn_to_urn(slice_hrn, 'slice')
901 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
904 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
905 creds.append(delegated_cred)
906 server = self.get_server_from_opts(opts)
907 print server.SliverStatus(slice_urn, creds)
910 def shutdown(self, opts, args):
912 slice_urn = hrn_to_urn(slice_hrn, 'slice')
913 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
916 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
917 creds.append(delegated_cred)
918 server = self.get_server_from_opts(opts)
919 return server.Shutdown(slice_urn, creds)
923 # Main: parse arguments and dispatch to command
926 parser = self.create_parser()
927 (options, args) = parser.parse_args()
928 self.options = options
930 self.logger.setLevelFromOptVerbose(self.options.verbose)
931 if options.hashrequest:
932 self.hashrequest = True
935 self.logger.critical("No command given. Use -h for help.")
939 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
943 self.logger.info("Command=%s" % command)
944 if command in ("resources"):
945 self.logger.debug("resources cmd_opts %s" % cmd_opts.format)
946 elif command in ("list", "show", "remove"):
947 self.logger.debug("cmd_opts.type %s" % cmd_opts.type)
948 self.logger.debug('cmd_args %s',cmd_args)
951 self.dispatch(command, cmd_opts, cmd_args)
953 self.logger.critical ("Unknown command %s"%command)
958 if __name__ == "__main__":