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
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
28 from sfa.util.sfalogging import console_logger
34 # utility methods here
36 def display_rspec(rspec, format='rspec'):
38 tree = etree.parse(StringIO(rspec))
40 result = root.xpath("./network/site/node/hostname/text()")
41 elif format in ['ip']:
42 # The IP address is not yet part of the new RSpec
43 # so this doesn't do anything yet.
44 tree = etree.parse(StringIO(rspec))
46 result = root.xpath("./network/site/node/ipv4/text()")
53 def display_list(results):
54 for result in results:
57 def display_records(recordList, dump=False):
58 ''' Print all fields in the record'''
59 for record in recordList:
60 display_record(record, dump)
62 def display_record(record, dump=False):
66 info = record.getdict()
67 print "%s (%s)" % (info['hrn'], info['type'])
71 def filter_records(type, records):
73 for record in records:
74 if (record['type'] == type) or (type == "all"):
75 filtered_records.append(record)
76 return filtered_records
80 def save_rspec_to_file(rspec, filename):
81 if not filename.endswith(".rspec"):
82 filename = filename + ".rspec"
84 f = open(filename, 'w')
89 def save_records_to_file(filename, recordList):
91 for record in recordList:
93 save_record_to_file(filename + "." + str(index), record)
95 save_record_to_file(filename, record)
98 def save_record_to_file(filename, record):
99 if record['type'] in ['user']:
100 record = UserRecord(dict=record)
101 elif record['type'] in ['slice']:
102 record = SliceRecord(dict=record)
103 elif record['type'] in ['node']:
104 record = NodeRecord(dict=record)
105 elif record['type'] in ['authority', 'ma', 'sa']:
106 record = AuthorityRecord(dict=record)
108 record = SfaRecord(dict=record)
109 str = record.save_to_string()
110 file(filename, "w").write(str)
115 def load_record_from_file(filename):
116 str = file(filename, "r").read()
117 record = SfaRecord(string=str)
128 self.authority = None
130 self.hashrequest = False
131 self.logger=console_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",
235 action="store_true", dest="verbose", default=False,
237 parser.add_option("-D", "--debug",
238 action="store_true", dest="debug", default=False,
239 help="Debug (xml-rpc) protocol messages")
240 parser.add_option("-p", "--protocol",
241 dest="protocol", default="xmlrpc",
242 help="RPC protocol (xmlrpc or soap)")
243 parser.add_option("-k", "--hashrequest",
244 action="store_true", dest="hashrequest", default=False,
245 help="Create a hash of the request that will be authenticated on the server")
246 parser.disable_interspersed_args()
252 # Establish Connection to SliceMgr and Registry Servers
254 def set_servers(self):
255 config_file = self.options.sfi_dir + os.sep + "sfi_config"
257 config = Config (config_file)
259 self.logger.critical("Failed to read configuration file %s"%config_file)
260 self.logger.info("Make sure to remove the export clauses and to add quotes")
261 if not self.options.verbose:
262 self.logger.info("Re-run with -v for more details")
264 self.logger.log_exc("Could not read config file %s"%config_file)
269 if (self.options.sm is not None):
270 sm_url = self.options.sm
271 elif hasattr(config, "SFI_SM"):
272 sm_url = config.SFI_SM
274 self.logger.error("You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s" % config_file)
278 if (self.options.registry is not None):
279 reg_url = self.options.registry
280 elif hasattr(config, "SFI_REGISTRY"):
281 reg_url = config.SFI_REGISTRY
283 self.logger.errors("You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s" % config_file)
288 if (self.options.user is not None):
289 self.user = self.options.user
290 elif hasattr(config, "SFI_USER"):
291 self.user = config.SFI_USER
293 self.logger.errors("You need to set e.g. SFI_USER='plc.princeton.username' in %s" % config_file)
297 if (self.options.auth is not None):
298 self.authority = self.options.auth
299 elif hasattr(config, "SFI_AUTH"):
300 self.authority = config.SFI_AUTH
302 self.logger.error("You need to set e.g. SFI_AUTH='plc.princeton' in %s" % config_file)
309 # Get key and certificate
310 key_file = self.get_key_file()
311 cert_file = self.get_cert_file(key_file)
312 self.key = Keypair(filename=key_file)
313 self.key_file = key_file
314 self.cert_file = cert_file
315 self.cert = Certificate(filename=cert_file)
316 # instruct xmlrpcprotocol to redirect logs to console_logger
317 self.options.client=True
318 # Establish connection to server(s)
319 self.logger.info("Contacting Registry at: %s"%reg_url)
320 self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file, self.options)
321 self.logger.info("Contacting Slice Manager at: %s"%sm_url)
322 self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file, self.options)
327 # Get various credential and spec files
329 # Establishes limiting conventions
330 # - conflates MAs and SAs
331 # - assumes last token in slice name is unique
333 # Bootstraps credentials
334 # - bootstrap user credential from self-signed certificate
335 # - bootstrap authority credential from user credential
336 # - bootstrap slice credential from user credential
340 def get_key_file(self):
341 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey")
342 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
343 if (os.path.isfile(file)):
346 self.logger.error("Key file %s does not exist"%file)
350 def get_cert_file(self, key_file):
352 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
353 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert")
354 if (os.path.isfile(file)):
357 k = Keypair(filename=key_file)
358 cert = Certificate(subject=self.user)
360 cert.set_issuer(k, self.user)
362 self.logger.info("Writing self-signed certificate to %s"%file)
363 cert.save_to_file(file)
366 def get_cached_gid(self, file):
371 if (os.path.isfile(file)):
372 gid = GID(filename=file)
375 def get_gid(self, opts, args):
379 gid = self._get_gid(hrn)
380 self.logger.debug("Sfi.get_gid-> %s",gid.save_to_string(save_parents=True))
383 def _get_gid(self, hrn=None):
387 gidfile = os.path.join(self.options.sfi_dir, hrn + ".gid")
388 gid = self.get_cached_gid(gidfile)
390 user_cred = self.get_user_cred()
391 records = self.registry.Resolve(hrn, user_cred.save_to_string(save_parents=True))
393 raise RecordNotFound(args[0])
394 gid = GID(string=records[0]['gid'])
395 self.logger.info("Writing gid to %s"%gidfile)
396 gid.save_to_file(filename=gidfile)
400 def get_cached_credential(self, file):
402 Return a cached credential only if it hasn't expired.
404 if (os.path.isfile(file)):
405 credential = Credential(filename=file)
406 # make sure it isnt expired
407 if not credential.get_expiration or \
408 datetime.datetime.today() < credential.get_expiration():
412 def get_user_cred(self):
413 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
414 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred")
415 return self.get_cred(file, 'user', self.user)
417 def get_auth_cred(self):
418 if not self.authority:
419 self.logger.critical("no authority specified. Use -a or set SF_AUTH")
421 file = os.path.join(self.options.sfi_dir, get_leaf("authority") + ".cred")
422 return self.get_cred(file, 'authority', self.authority)
424 def get_slice_cred(self, name):
425 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
426 return self.get_cred(file, 'slice', name)
428 def get_cred(self, file, type, hrn):
429 # attempt to load a cached credential
430 cred = self.get_cached_credential(file)
433 cert_string = self.cert.save_to_string(save_parents=True)
434 user_name = self.user.replace(self.authority + ".", '')
435 if user_name.count(".") > 0:
436 user_name = user_name.replace(".", '_')
437 self.user = self.authority + "." + user_name
438 cred_str = self.registry.GetSelfCredential(cert_string, hrn, "user")
440 # bootstrap slice credential from user credential
441 user_cred = self.get_user_cred().save_to_string(save_parents=True)
442 cred_str = self.registry.GetCredential(user_cred, hrn, type)
445 self.logger.critical("Failed to get %s credential" % type)
448 cred = Credential(string=cred_str)
449 cred.save_to_file(file, save_parents=True)
450 self.logger.info("Writing %s credential to %s" %(type, file))
455 def get_rspec_file(self, rspec):
456 if (os.path.isabs(rspec)):
459 file = os.path.join(self.options.sfi_dir, rspec)
460 if (os.path.isfile(file)):
463 self.logger.critical("No such rspec file"%rspec)
466 def get_record_file(self, record):
467 if (os.path.isabs(record)):
470 file = os.path.join(self.options.sfi_dir, record)
471 if (os.path.isfile(file)):
474 self.logger.critical("No such registry record file %s"%record)
477 def load_publickey_string(self, fn):
479 key_string = f.read()
481 # if the filename is a private key file, then extract the public key
482 if "PRIVATE KEY" in key_string:
483 outfn = tempfile.mktemp()
484 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
487 key_string = f.read()
492 def get_component_server_from_hrn(self, hrn):
493 # direct connection to the nodes component manager interface
494 user_cred = self.get_user_cred().save_to_string(save_parents=True)
495 records = self.registry.Resolve(hrn, user_cred)
496 records = filter_records('node', records)
498 self.logger.warning("No such component:%r"% opts.component)
501 return self.get_server(record['hostname'], CM_PORT, self.key_file, \
502 self.cert_file, self.options)
504 def get_server(self, host, port, keyfile, certfile):
506 Return an instnace of an xmlrpc server connection
508 url = "http://%s:%s" % (host, port)
509 return xmlrpcprotocol.get_server(url, keyfile, certfile, self.options)
511 def get_server_from_opts(self, opts):
513 Return instance of an xmlrpc connection to a slice manager, aggregate
514 or component server depending on the specified opts
516 server = self.slicemgr
517 # direct connection to an aggregate
518 if hasattr(opts, 'aggregate') and opts.aggregate:
519 server = self.get_server(opts.aggregate, opts.port, self.key_file, self.cert_file)
520 # direct connection to the nodes component manager interface
521 if hasattr(opts, 'component') and opts.component:
522 server = self.get_component_server_from_hrn(opts.component)
525 #==========================================================================
526 # Following functions implement the commands
528 # Registry-related commands
529 #==========================================================================
531 def dispatch(self, command, cmd_opts, cmd_args):
532 return getattr(self, command)(cmd_opts, cmd_args)
534 # list entires in named authority registry
535 def list(self, opts, args):
536 user_cred = self.get_user_cred().save_to_string(save_parents=True)
539 list = self.registry.List(hrn, user_cred)
541 raise Exception, "Not enough parameters for the 'list' command"
543 # filter on person, slice, site, node, etc.
544 # THis really should be in the self.filter_records funct def comment...
545 list = filter_records(opts.type, list)
547 print "%s (%s)" % (record['hrn'], record['type'])
550 if not file.startswith(os.sep):
551 file = os.path.join(self.options.sfi_dir, file)
552 save_records_to_file(file, list)
555 # show named registry record
556 def show(self, opts, args):
557 user_cred = self.get_user_cred().save_to_string(save_parents=True)
559 records = self.registry.Resolve(hrn, user_cred)
560 records = filter_records(opts.type, records)
562 print "No record of type", opts.type
563 for record in records:
564 if record['type'] in ['user']:
565 record = UserRecord(dict=record)
566 elif record['type'] in ['slice']:
567 record = SliceRecord(dict=record)
568 elif record['type'] in ['node']:
569 record = NodeRecord(dict=record)
570 elif record['type'] in ['authority', 'ma', 'sa']:
571 record = AuthorityRecord(dict=record)
573 record = SfaRecord(dict=record)
574 if (opts.format == "text"):
577 print record.save_to_string()
581 if not file.startswith(os.sep):
582 file = os.path.join(self.options.sfi_dir, file)
583 save_records_to_file(file, records)
586 def delegate(self, opts, args):
588 delegee_hrn = args[0]
589 if opts.delegate_user:
590 user_cred = self.get_user_cred()
591 cred = self.delegate_cred(user_cred, delegee_hrn)
592 elif opts.delegate_slice:
593 slice_cred = self.get_slice_cred(opts.delegate_slice)
594 cred = self.delegate_cred(slice_cred, delegee_hrn)
596 self.logger.warning("Must specify either --user or --slice <hrn>")
598 delegated_cred = Credential(string=cred)
599 object_hrn = delegated_cred.get_gid_object().get_hrn()
600 if opts.delegate_user:
601 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
602 + get_leaf(object_hrn) + ".cred")
603 elif opts.delegate_slice:
604 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
605 + get_leaf(object_hrn) + ".cred")
607 delegated_cred.save_to_file(dest_fn, save_parents=True)
609 self.logger.info("delegated credential for %s to %s and wrote to %s"%(object_hrn, delegee_hrn,dest_fn))
611 def delegate_cred(self, object_cred, hrn):
612 # the gid and hrn of the object we are delegating
613 if isinstance(object_cred, str):
614 object_cred = Credential(string=object_cred)
615 object_gid = object_cred.get_gid_object()
616 object_hrn = object_gid.get_hrn()
618 if not object_cred.get_privileges().get_all_delegate():
619 self.logger.error("Object credential %s does not have delegate bit set"%object_hrn)
622 # the delegating user's gid
623 caller_gid = self._get_gid(self.user)
624 caller_gidfile = os.path.join(self.options.sfi_dir, self.user + ".gid")
626 # the gid of the user who will be delegated to
627 delegee_gid = self._get_gid(hrn)
628 delegee_hrn = delegee_gid.get_hrn()
629 delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid")
630 delegee_gid.save_to_file(filename=delegee_gidfile)
631 dcred = object_cred.delegate(delegee_gidfile, self.get_key_file(), caller_gidfile)
632 return dcred.save_to_string(save_parents=True)
634 # removed named registry record
635 # - have to first retrieve the record to be removed
636 def remove(self, opts, args):
637 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
642 return self.registry.Remove(hrn, auth_cred, type)
644 # add named registry record
645 def add(self, opts, args):
646 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
647 record_filepath = args[0]
648 rec_file = self.get_record_file(record_filepath)
649 record = load_record_from_file(rec_file).as_dict()
650 return self.registry.Register(record, auth_cred)
652 # update named registry entry
653 def update(self, opts, args):
654 user_cred = self.get_user_cred()
655 rec_file = self.get_record_file(args[0])
656 record = load_record_from_file(rec_file)
657 if record['type'] == "user":
658 if record.get_name() == user_cred.get_gid_object().get_hrn():
659 cred = user_cred.save_to_string(save_parents=True)
661 cred = self.get_auth_cred().save_to_string(save_parents=True)
662 elif record['type'] in ["slice"]:
664 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
665 except ServerException, e:
666 # XXX smbaker -- once we have better error return codes, update this
667 # to do something better than a string compare
668 if "Permission error" in e.args[0]:
669 cred = self.get_auth_cred().save_to_string(save_parents=True)
672 elif record.get_type() in ["authority"]:
673 cred = self.get_auth_cred().save_to_string(save_parents=True)
674 elif record.get_type() == 'node':
675 cred = self.get_auth_cred().save_to_string(save_parents=True)
677 raise "unknown record type" + record.get_type()
678 record = record.as_dict()
679 return self.registry.Update(record, cred)
681 def get_trusted_certs(self, opts, args):
683 return uhe trusted certs at this interface
685 trusted_certs = self.registry.get_trusted_certs()
686 for trusted_cert in trusted_certs:
687 cert = Certificate(string=trusted_cert)
688 self.logger.debug('Sfi.get_trusted_certs -> %r'%cert.get_subject())
691 def aggregates(self, opts, args):
693 return a list of details about known aggregates
695 user_cred = self.get_user_cred().save_to_string(save_parents=True)
700 result = self.registry.get_aggregates(user_cred, hrn)
704 def registries(self, opts, args):
706 return a list of details about known registries
708 user_cred = self.get_user_cred().save_to_string(save_parents=True)
712 result = self.registry.get_registries(user_cred, hrn)
717 # ==================================================================
718 # Slice-related commands
719 # ==================================================================
722 def version(self, opts, args):
723 server = self.get_server_from_opts(opts)
725 print server.GetVersion()
727 # list instantiated slices
728 def slices(self, opts, args):
730 list instantiated slices
732 user_cred = self.get_user_cred().save_to_string(save_parents=True)
735 delegated_cred = self.delegate_cred(user_cred, get_authority(self.authority))
736 creds.append(delegated_cred)
737 server = self.get_server_from_opts(opts)
738 results = server.ListSlices(creds)
739 display_list(results)
742 # show rspec for named slice
743 def resources(self, opts, args):
744 user_cred = self.get_user_cred().save_to_string(save_parents=True)
745 server = self.slicemgr
747 server = self.get_server_from_opts(opts)
750 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
752 call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')}
759 delegated_cred = self.delegate_cred(cred, get_authority(self.authority))
760 creds.append(delegated_cred)
761 result = server.ListResources(creds, call_options)
763 display_rspec(result, format)
764 if (opts.file is not None):
766 if not file.startswith(os.sep):
767 file = os.path.join(self.options.sfi_dir, file)
768 save_rspec_to_file(result, file)
771 # created named slice with given rspec
772 def create(self, opts, args):
774 slice_urn = hrn_to_urn(slice_hrn, 'slice')
775 user_cred = self.get_user_cred()
776 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
779 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
780 creds.append(delegated_cred)
781 rspec_file = self.get_rspec_file(args[1])
782 rspec = open(rspec_file).read()
783 server = self.get_server_from_opts(opts)
784 result = server.CreateSliver(slice_urn, creds, rspec, [])
788 # get a ticket for the specified slice
789 def get_ticket(self, opts, args):
790 slice_hrn, rspec_path = args[0], args[1]
791 slice_urn = hrn_to_urn(slice_hrn, 'slice')
792 user_cred = self.get_user_cred()
793 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
796 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
797 creds.append(delegated_cred)
798 rspec_file = self.get_rspec_file(rspec_path)
799 rspec = open(rspec_file).read()
800 server = self.get_server_from_opts(opts)
801 ticket_string = server.GetTicket(slice_urn, creds, rspec, [])
802 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
803 self.logger.info("writing ticket to %s"%file)
804 ticket = SfaTicket(string=ticket_string)
805 ticket.save_to_file(filename=file, save_parents=True)
807 def redeem_ticket(self, opts, args):
808 ticket_file = args[0]
810 # get slice hrn from the ticket
811 # use this to get the right slice credential
812 ticket = SfaTicket(filename=ticket_file)
814 slice_hrn = ticket.gidObject.get_hrn()
815 slice_urn = hrn_to_urn(slice_hrn, 'slice')
816 #slice_hrn = ticket.attributes['slivers'][0]['hrn']
817 user_cred = self.get_user_cred()
818 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
820 # get a list of node hostnames from the RSpec
821 tree = etree.parse(StringIO(ticket.rspec))
822 root = tree.getroot()
823 hostnames = root.xpath("./network/site/node/hostname/text()")
825 # create an xmlrpc connection to the component manager at each of these
826 # components and gall redeem_ticket
828 for hostname in hostnames:
830 self.logger.info("Calling redeem_ticket at %(hostname)s " % locals())
831 server = self.get_server(hostname, CM_PORT, self.key_file, \
832 self.cert_file, self.options.debug)
833 server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred)
834 self.logger.info("Success")
835 except socket.gaierror:
836 self.logger.error("redeem_ticket failed: Component Manager not accepting requests")
838 self.logger.log_exc(e.message)
842 def delete(self, opts, args):
844 slice_urn = hrn_to_urn(slice_hrn, 'slice')
845 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
848 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
849 creds.append(delegated_cred)
850 server = self.get_server_from_opts(opts)
851 return server.DeleteSliver(slice_urn, creds)
854 def start(self, opts, args):
856 slice_urn = hrn_to_urn(slice_hrn, 'slice')
857 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
860 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
861 creds.append(delegated_cred)
862 server = self.get_server_from_opts(opts)
863 return server.Start(slice_urn, creds)
866 def stop(self, opts, args):
868 slice_urn = hrn_to_urn(slice_hrn, 'slice')
869 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
872 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
873 creds.append(delegated_cred)
874 server = self.get_server_from_opts(opts)
875 return server.Stop(slice_urn, creds)
878 def reset(self, opts, args):
880 slice_urn = hrn_to_urn(slice_hrn, 'slice')
881 server = self.get_server_from_opts(opts)
882 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
885 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
886 creds.append(delegated_cred)
887 return server.reset_slice(creds, slice_urn)
889 def renew(self, opts, args):
891 slice_urn = hrn_to_urn(slice_hrn, 'slice')
892 server = self.get_server_from_opts(opts)
893 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
896 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
897 creds.append(delegated_cred)
899 return server.RenewSliver(slice_urn, creds, time)
902 def status(self, opts, args):
904 slice_urn = hrn_to_urn(slice_hrn, 'slice')
905 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
908 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
909 creds.append(delegated_cred)
910 server = self.get_server_from_opts(opts)
911 print server.SliverStatus(slice_urn, creds)
914 def shutdown(self, opts, args):
916 slice_urn = hrn_to_urn(slice_hrn, 'slice')
917 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
920 delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
921 creds.append(delegated_cred)
922 server = self.get_server_from_opts(opts)
923 return server.Shutdown(slice_urn, creds)
927 # Main: parse arguments and dispatch to command
930 parser = self.create_parser()
931 (options, args) = parser.parse_args()
932 self.options = options
934 if self.options.verbose: self.logger.setLevel(logging.DEBUG)
935 if options.hashrequest:
936 self.hashrequest = True
939 self.logger.critical("No command given. Use -h for help.")
943 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
947 self.logger.info("Command %s" % command)
948 self.logger.info("dir %s, user %s, auth %s, reg %s, sm %s" % (
949 self. options.sfi_dir, self.options.user,self.options.auth,
950 self.options.registry, self.options.sm))
951 if command in ("resources"):
952 self.logger.debug("resources cmd_opts %s" % cmd_opts.format)
953 elif command in ("list", "show", "remove"):
954 self.logger.debug("cmd_opts.type %s" % cmd_opts.type)
955 self.logger.debug('cmd_args %s',cmd_args)
958 self.dispatch(command, cmd_opts, cmd_args)
960 self.logger.critical ("Unknown command %s"%command)
965 if __name__ == "__main__":