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.gid import GID
22 from sfa.trust.credential import Credential
23 from sfa.util.sfaticket import SfaTicket
24 from sfa.util.record import SfaRecord, UserRecord, SliceRecord, NodeRecord, AuthorityRecord
25 from sfa.util.namespace import get_leaf, get_authority, hrn_to_urn
26 from sfa.util.xmlrpcprotocol import ServerException
27 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
28 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": "authority",
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_expiration or \
404 datetime.datetime.today() < credential.get_expiration():
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 ### xxx get_leaf('authority') always returns 'authority'
418 # are we not meaning get_leaf(self.authority) instead ?
419 file = os.path.join(self.options.sfi_dir, get_leaf("authority") + ".cred")
420 return self.get_cred(file, 'authority', self.authority)
422 def get_slice_cred(self, name):
423 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
424 return self.get_cred(file, 'slice', name)
426 def get_cred(self, file, type, hrn):
427 # attempt to load a cached credential
428 cred = self.get_cached_credential(file)
431 cert_string = self.cert.save_to_string(save_parents=True)
432 user_name = self.user.replace(self.authority + ".", '')
433 if user_name.count(".") > 0:
434 user_name = user_name.replace(".", '_')
435 self.user = self.authority + "." + user_name
436 cred_str = self.registry.GetSelfCredential(cert_string, hrn, "user")
438 # bootstrap slice credential from user credential
439 user_cred = self.get_user_cred().save_to_string(save_parents=True)
440 cred_str = self.registry.GetCredential(user_cred, hrn, type)
443 self.logger.critical("Failed to get %s credential" % type)
446 cred = Credential(string=cred_str)
447 cred.save_to_file(file, save_parents=True)
448 self.logger.info("Writing %s credential to %s" %(type, file))
453 def get_rspec_file(self, rspec):
454 if (os.path.isabs(rspec)):
457 file = os.path.join(self.options.sfi_dir, rspec)
458 if (os.path.isfile(file)):
461 self.logger.critical("No such rspec file"%rspec)
464 def get_record_file(self, record):
465 if (os.path.isabs(record)):
468 file = os.path.join(self.options.sfi_dir, record)
469 if (os.path.isfile(file)):
472 self.logger.critical("No such registry record file %s"%record)
475 def load_publickey_string(self, fn):
477 key_string = f.read()
479 # if the filename is a private key file, then extract the public key
480 if "PRIVATE KEY" in key_string:
481 outfn = tempfile.mktemp()
482 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
485 key_string = f.read()
490 def get_component_server_from_hrn(self, hrn):
491 # direct connection to the nodes component manager interface
492 user_cred = self.get_user_cred().save_to_string(save_parents=True)
493 records = self.registry.Resolve(hrn, user_cred)
494 records = filter_records('node', records)
496 self.logger.warning("No such component:%r"% opts.component)
499 return self.get_server(record['hostname'], CM_PORT, self.key_file, \
500 self.cert_file, self.options)
502 def get_server(self, host, port, keyfile, certfile):
504 Return an instnace of an xmlrpc server connection
506 url = "http://%s:%s" % (host, port)
507 return xmlrpcprotocol.get_server(url, keyfile, certfile, self.options)
509 def get_server_from_opts(self, opts):
511 Return instance of an xmlrpc connection to a slice manager, aggregate
512 or component server depending on the specified opts
514 server = self.slicemgr
515 # direct connection to an aggregate
516 if hasattr(opts, 'aggregate') and opts.aggregate:
517 server = self.get_server(opts.aggregate, opts.port, self.key_file, self.cert_file)
518 # direct connection to the nodes component manager interface
519 if hasattr(opts, 'component') and opts.component:
520 server = self.get_component_server_from_hrn(opts.component)
523 #==========================================================================
524 # Following functions implement the commands
526 # Registry-related commands
527 #==========================================================================
529 def dispatch(self, command, cmd_opts, cmd_args):
530 return getattr(self, command)(cmd_opts, cmd_args)
532 # list entires in named authority registry
533 def list(self, opts, args):
535 self.parser.print_help()
538 user_cred = self.get_user_cred().save_to_string(save_parents=True)
540 list = self.registry.List(hrn, user_cred)
542 raise Exception, "Not enough parameters for the 'list' command"
544 # filter on person, slice, site, node, etc.
545 # THis really should be in the self.filter_records funct def comment...
546 list = filter_records(opts.type, list)
548 print "%s (%s)" % (record['hrn'], record['type'])
551 if not file.startswith(os.sep):
552 file = os.path.join(self.options.sfi_dir, file)
553 save_records_to_file(file, list)
556 # show named registry record
557 def show(self, opts, args):
559 self.parser.print_help()
562 user_cred = self.get_user_cred().save_to_string(save_parents=True)
563 records = self.registry.Resolve(hrn, user_cred)
564 records = filter_records(opts.type, records)
566 print "No record of type", opts.type
567 for record in records:
568 if record['type'] in ['user']:
569 record = UserRecord(dict=record)
570 elif record['type'] in ['slice']:
571 record = SliceRecord(dict=record)
572 elif record['type'] in ['node']:
573 record = NodeRecord(dict=record)
574 elif record['type'] in ['authority', 'ma', 'sa']:
575 record = AuthorityRecord(dict=record)
577 record = SfaRecord(dict=record)
578 if (opts.format == "text"):
581 print record.save_to_string()
585 if not file.startswith(os.sep):
586 file = os.path.join(self.options.sfi_dir, file)
587 save_records_to_file(file, records)
590 def delegate(self, opts, args):
592 delegee_hrn = args[0]
593 if opts.delegate_user:
594 user_cred = self.get_user_cred()
595 cred = self.delegate_cred(user_cred, delegee_hrn)
596 elif opts.delegate_slice:
597 slice_cred = self.get_slice_cred(opts.delegate_slice)
598 cred = self.delegate_cred(slice_cred, delegee_hrn)
600 self.logger.warning("Must specify either --user or --slice <hrn>")
602 delegated_cred = Credential(string=cred)
603 object_hrn = delegated_cred.get_gid_object().get_hrn()
604 if opts.delegate_user:
605 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
606 + get_leaf(object_hrn) + ".cred")
607 elif opts.delegate_slice:
608 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
609 + get_leaf(object_hrn) + ".cred")
611 delegated_cred.save_to_file(dest_fn, save_parents=True)
613 self.logger.info("delegated credential for %s to %s and wrote to %s"%(object_hrn, delegee_hrn,dest_fn))
615 def delegate_cred(self, object_cred, hrn):
616 # the gid and hrn of the object we are delegating
617 if isinstance(object_cred, str):
618 object_cred = Credential(string=object_cred)
619 object_gid = object_cred.get_gid_object()
620 object_hrn = object_gid.get_hrn()
622 if not object_cred.get_privileges().get_all_delegate():
623 self.logger.error("Object credential %s does not have delegate bit set"%object_hrn)
626 # the delegating user's gid
627 caller_gid = self._get_gid(self.user)
628 caller_gidfile = os.path.join(self.options.sfi_dir, self.user + ".gid")
630 # the gid of the user who will be delegated to
631 delegee_gid = self._get_gid(hrn)
632 delegee_hrn = delegee_gid.get_hrn()
633 delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid")
634 delegee_gid.save_to_file(filename=delegee_gidfile)
635 dcred = object_cred.delegate(delegee_gidfile, self.get_key_file(), caller_gidfile)
636 return dcred.save_to_string(save_parents=True)
638 # removed named registry record
639 # - have to first retrieve the record to be removed
640 def remove(self, opts, args):
641 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
646 return self.registry.Remove(hrn, auth_cred, type)
648 # add named registry record
649 def add(self, opts, args):
650 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
651 record_filepath = args[0]
652 rec_file = self.get_record_file(record_filepath)
653 record = load_record_from_file(rec_file).as_dict()
654 return self.registry.Register(record, auth_cred)
656 # update named registry entry
657 def update(self, opts, args):
658 user_cred = self.get_user_cred()
659 rec_file = self.get_record_file(args[0])
660 record = load_record_from_file(rec_file)
661 if record['type'] == "user":
662 if record.get_name() == user_cred.get_gid_object().get_hrn():
663 cred = user_cred.save_to_string(save_parents=True)
665 cred = self.get_auth_cred().save_to_string(save_parents=True)
666 elif record['type'] in ["slice"]:
668 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
669 except ServerException, e:
670 # XXX smbaker -- once we have better error return codes, update this
671 # to do something better than a string compare
672 if "Permission error" in e.args[0]:
673 cred = self.get_auth_cred().save_to_string(save_parents=True)
676 elif record.get_type() in ["authority"]:
677 cred = self.get_auth_cred().save_to_string(save_parents=True)
678 elif record.get_type() == 'node':
679 cred = self.get_auth_cred().save_to_string(save_parents=True)
681 raise "unknown record type" + record.get_type()
682 record = record.as_dict()
683 return self.registry.Update(record, cred)
685 def get_trusted_certs(self, opts, args):
687 return uhe trusted certs at this interface
689 trusted_certs = self.registry.get_trusted_certs()
690 for trusted_cert in trusted_certs:
691 cert = Certificate(string=trusted_cert)
692 self.logger.debug('Sfi.get_trusted_certs -> %r'%cert.get_subject())
695 def aggregates(self, opts, args):
697 return a list of details about known aggregates
699 user_cred = self.get_user_cred().save_to_string(save_parents=True)
704 result = self.registry.get_aggregates(user_cred, hrn)
708 def registries(self, opts, args):
710 return a list of details about known registries
712 user_cred = self.get_user_cred().save_to_string(save_parents=True)
716 result = self.registry.get_registries(user_cred, hrn)
721 # ==================================================================
722 # Slice-related commands
723 # ==================================================================
726 def version(self, opts, args):
727 server = self.get_server_from_opts(opts)
729 print server.GetVersion()
731 # list instantiated slices
732 def slices(self, opts, args):
734 list instantiated slices
736 user_cred = self.get_user_cred().save_to_string(save_parents=True)
739 delegated_cred = self.delegate_cred(user_cred, get_authority(self.authority))
740 creds.append(delegated_cred)
741 server = self.get_server_from_opts(opts)
742 results = server.ListSlices(creds)
743 display_list(results)
746 # show rspec for named slice
747 def resources(self, opts, args):
748 user_cred = self.get_user_cred().save_to_string(save_parents=True)
749 server = self.slicemgr
751 server = self.get_server_from_opts(opts)
754 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
756 call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')}
763 delegated_cred = self.delegate_cred(cred, get_authority(self.authority))
764 creds.append(delegated_cred)
765 result = server.ListResources(creds, call_options)
767 display_rspec(result, format)
768 if (opts.file is not None):
770 if not file.startswith(os.sep):
771 file = os.path.join(self.options.sfi_dir, file)
772 save_rspec_to_file(result, file)
775 # created named slice with given rspec
776 def create(self, opts, args):
778 slice_urn = hrn_to_urn(slice_hrn, 'slice')
779 user_cred = self.get_user_cred()
780 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
783 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
784 creds.append(delegated_cred)
785 rspec_file = self.get_rspec_file(args[1])
786 rspec = open(rspec_file).read()
787 server = self.get_server_from_opts(opts)
788 result = server.CreateSliver(slice_urn, creds, rspec, [])
792 # get a ticket for the specified slice
793 def get_ticket(self, opts, args):
794 slice_hrn, rspec_path = args[0], args[1]
795 slice_urn = hrn_to_urn(slice_hrn, 'slice')
796 user_cred = self.get_user_cred()
797 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
800 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
801 creds.append(delegated_cred)
802 rspec_file = self.get_rspec_file(rspec_path)
803 rspec = open(rspec_file).read()
804 server = self.get_server_from_opts(opts)
805 ticket_string = server.GetTicket(slice_urn, creds, rspec, [])
806 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
807 self.logger.info("writing ticket to %s"%file)
808 ticket = SfaTicket(string=ticket_string)
809 ticket.save_to_file(filename=file, save_parents=True)
811 def redeem_ticket(self, opts, args):
812 ticket_file = args[0]
814 # get slice hrn from the ticket
815 # use this to get the right slice credential
816 ticket = SfaTicket(filename=ticket_file)
818 slice_hrn = ticket.gidObject.get_hrn()
819 slice_urn = hrn_to_urn(slice_hrn, 'slice')
820 #slice_hrn = ticket.attributes['slivers'][0]['hrn']
821 user_cred = self.get_user_cred()
822 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
824 # get a list of node hostnames from the RSpec
825 tree = etree.parse(StringIO(ticket.rspec))
826 root = tree.getroot()
827 hostnames = root.xpath("./network/site/node/hostname/text()")
829 # create an xmlrpc connection to the component manager at each of these
830 # components and gall redeem_ticket
832 for hostname in hostnames:
834 self.logger.info("Calling redeem_ticket at %(hostname)s " % locals())
835 server = self.get_server(hostname, CM_PORT, self.key_file, \
836 self.cert_file, self.options.debug)
837 server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred)
838 self.logger.info("Success")
839 except socket.gaierror:
840 self.logger.error("redeem_ticket failed: Component Manager not accepting requests")
842 self.logger.log_exc(e.message)
846 def delete(self, opts, args):
848 slice_urn = hrn_to_urn(slice_hrn, 'slice')
849 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
852 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
853 creds.append(delegated_cred)
854 server = self.get_server_from_opts(opts)
855 return server.DeleteSliver(slice_urn, creds)
858 def start(self, opts, args):
860 slice_urn = hrn_to_urn(slice_hrn, 'slice')
861 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
864 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
865 creds.append(delegated_cred)
866 server = self.get_server_from_opts(opts)
867 return server.Start(slice_urn, creds)
870 def stop(self, opts, args):
872 slice_urn = hrn_to_urn(slice_hrn, 'slice')
873 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
876 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
877 creds.append(delegated_cred)
878 server = self.get_server_from_opts(opts)
879 return server.Stop(slice_urn, creds)
882 def reset(self, opts, args):
884 slice_urn = hrn_to_urn(slice_hrn, 'slice')
885 server = self.get_server_from_opts(opts)
886 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
889 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
890 creds.append(delegated_cred)
891 return server.reset_slice(creds, slice_urn)
893 def renew(self, opts, args):
895 slice_urn = hrn_to_urn(slice_hrn, 'slice')
896 server = self.get_server_from_opts(opts)
897 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
900 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
901 creds.append(delegated_cred)
903 return server.RenewSliver(slice_urn, creds, time)
906 def status(self, opts, args):
908 slice_urn = hrn_to_urn(slice_hrn, 'slice')
909 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
912 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
913 creds.append(delegated_cred)
914 server = self.get_server_from_opts(opts)
915 print server.SliverStatus(slice_urn, creds)
918 def shutdown(self, opts, args):
920 slice_urn = hrn_to_urn(slice_hrn, 'slice')
921 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
924 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
925 creds.append(delegated_cred)
926 server = self.get_server_from_opts(opts)
927 return server.Shutdown(slice_urn, creds)
931 # Main: parse arguments and dispatch to command
934 parser = self.create_parser()
935 (options, args) = parser.parse_args()
936 self.options = options
938 self.logger.setLevelFromOptVerbose(self.options.verbose)
939 if options.hashrequest:
940 self.hashrequest = True
943 self.logger.critical("No command given. Use -h for help.")
947 self.parser = self.create_cmd_parser(command)
948 (cmd_opts, cmd_args) = self.parser.parse_args(args[1:])
952 self.logger.info("Command=%s" % command)
953 if command in ("resources"):
954 self.logger.debug("resources cmd_opts %s" % cmd_opts.format)
955 elif command in ("list", "show", "remove"):
956 self.logger.debug("cmd_opts.type %s" % cmd_opts.type)
957 self.logger.debug('cmd_args %s',cmd_args)
960 self.dispatch(command, cmd_opts, cmd_args)
962 self.logger.critical ("Unknown command %s"%command)
967 if __name__ == "__main__":