3 # sfi -- slice-based facility interface
10 from types import StringTypes, ListType
11 from optparse import OptionParser
12 from sfa.trust.certificate import Keypair, Certificate
13 from sfa.trust.credential import Credential
14 from sfa.util.geniclient import GeniClient
15 from sfa.util.sfaticket import SfaTicket
16 from sfa.util.record import *
17 from sfa.util.misc import *
18 from sfa.util.rspec import RSpec
19 from sfa.util.xmlrpcprotocol import ServerException
20 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
21 from sfa.util.config import Config
23 # utility methods here
25 def display_rspec(rspec, format = 'rspec'):
28 spec.parseString(rspec)
30 nodespecs = spec.getDictsByTagName('NodeSpec')
31 for nodespec in nodespecs:
32 if nodespec.has_key('name') and nodespec['name']:
33 if isinstance(nodespec['name'], ListType):
34 hostnames.extend(nodespec['name'])
35 elif isinstance(nodespec['name'], StringTypes):
36 hostnames.append(nodespec['name'])
38 elif format in ['ip']:
40 spec.parseString(rspec)
42 ifspecs = spec.getDictsByTagName('IfSpec')
43 for ifspec in ifspecs:
44 if ifspec.has_key('addr') and ifspec['addr']:
45 ips.append(ifspec['addr'])
53 def display_list(results):
54 for result in results:
58 def display_records(recordList, dump = False):
59 ''' Print all fields in the record'''
60 for record in recordList:
61 display_record(record, dump)
63 def display_record(record, dump = False):
67 info = record.getdict()
68 print "%s (%s)" % (info['hrn'], info['type'])
72 def filter_records(type, records):
74 for record in records:
75 if (record['type'] == type) or (type == "all"):
76 filtered_records.append(record)
77 return filtered_records
81 def save_rspec_to_file(rspec, filename):
82 if not filename.endswith(".rspec"):
83 filename = filename + ".rspec"
85 f = open(filename, 'w')
90 def save_records_to_file(filename, recordList):
92 for record in recordList:
94 save_record_to_file(filename + "." + str(index), record)
96 save_record_to_file(filename, record)
99 def save_record_to_file(filename, record):
100 if record['type'] in ['user']:
101 record = UserRecord(dict = record)
102 elif record['type'] in ['slice']:
103 record = SliceRecord(dict = record)
104 elif record['type'] in ['node']:
105 record = NodeRecord(dict = record)
106 elif record['type'] in ['authority', 'ma', 'sa']:
107 record = AuthorityRecord(dict = record)
109 record = GeniRecord(dict = record)
110 str = record.save_to_string()
111 file(filename, "w").write(str)
116 def load_record_from_file(filename):
117 str = file(filename, "r").read()
118 record = GeniRecord(string=str)
132 def create_cmd_parser(self,command, additional_cmdargs = None):
133 cmdargs = {"gid": "",
139 "aggregates": "[name]",
140 "registries": "[name]",
142 "resources": "[name]",
143 "create": "name rspec",
144 "get_ticket": "name rspec",
145 "redeem_ticket": "ticket",
153 if additional_cmdargs:
154 cmdargs.update(additional_cmdargs)
156 if command not in cmdargs:
157 print "Invalid command\n"
159 for key in cmdargs.keys():
164 parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
165 % (command, cmdargs[command]))
167 if command in ("resources"):
168 parser.add_option("-f", "--format", dest="format",type="choice",
169 help="display format ([xml]|dns|ip)",default="xml",
170 choices=("xml","dns","ip"))
171 parser.add_option("-a", "--aggregate", dest="aggregate",
172 default=None, help="aggregate hrn")
174 if command in ("create", "get_ticket"):
175 parser.add_option("-a", "--aggregate", dest="aggregate",default=None,
176 help="aggregate hrn")
178 if command in ("list", "show", "remove"):
179 parser.add_option("-t", "--type", dest="type",type="choice",
180 help="type filter ([all]|user|slice|sa|ma|node|aggregate)",
181 choices=("all","user","slice","sa","ma","node","aggregate"),
184 if command in ("resources", "show", "list"):
185 parser.add_option("-o", "--output", dest="file",
186 help="output XML to file", metavar="FILE", default=None)
188 if command in ("show", "list"):
189 parser.add_option("-f", "--format", dest="format", type="choice",
190 help="display format ([text]|xml)",default="text",
191 choices=("text","xml"))
193 if command in ("delegate"):
194 parser.add_option("-u", "--user",
195 action="store_true", dest="delegate_user", default=False,
196 help="delegate user credential")
197 parser.add_option("-s", "--slice", dest="delegate_slice",
198 help="delegate slice credential", metavar="HRN", default=None)
202 def create_parser(self):
204 # Generate command line parser
205 parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
206 description="Commands: gid,list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
207 parser.add_option("-r", "--registry", dest="registry",
208 help="root registry", metavar="URL", default=None)
209 parser.add_option("-s", "--slicemgr", dest="sm",
210 help="slice manager", metavar="URL", default=None)
211 default_sfi_dir=os.path.expanduser("~/.sfi/")
212 parser.add_option("-d", "--dir", dest="sfi_dir",
213 help="config & working directory - default is " + default_sfi_dir,
214 metavar="PATH", default = default_sfi_dir)
215 parser.add_option("-u", "--user", dest="user",
216 help="user name", metavar="HRN", default=None)
217 parser.add_option("-a", "--auth", dest="auth",
218 help="authority name", metavar="HRN", default=None)
219 parser.add_option("-v", "--verbose",
220 action="store_true", dest="verbose", default=False,
222 parser.add_option("-p", "--protocol",
223 dest="protocol", default="xmlrpc",
224 help="RPC protocol (xmlrpc or soap)")
225 parser.add_option("-k", "--hashrequest",
226 action="store_true", dest="hashrequest", default=False,
227 help="Create a hash of the request that will be authenticated on the server")
228 parser.disable_interspersed_args()
234 # Establish Connection to SliceMgr and Registry Servers
236 def set_servers(self):
237 config_file = self.options.sfi_dir + os.sep + "sfi_config"
239 config = Config (config_file)
241 print "Failed to read configuration file",config_file
242 print "Make sure to remove the export clauses and to add quotes"
243 if not self.options.verbose:
244 print "Re-run with -v for more details"
246 traceback.print_exc()
251 if (self.options.sm is not None):
252 sm_url = self.options.sm
253 elif hasattr(config,"SFI_SM"):
254 sm_url = config.SFI_SM
256 print "You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s"%config_file
260 if (self.options.registry is not None):
261 reg_url = self.options.registry
262 elif hasattr(config,"SFI_REGISTRY"):
263 reg_url = config.SFI_REGISTRY
265 print "You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s"%config_file
269 if (self.options.user is not None):
270 self.user = self.options.user
271 elif hasattr(config,"SFI_USER"):
272 self.user = config.SFI_USER
274 print "You need to set e.g. SFI_USER='plc.princeton.username' in %s"%config_file
278 if (self.options.auth is not None):
279 self.authority = self.options.auth
280 elif hasattr(config,"SFI_AUTH"):
281 self.authority = config.SFI_AUTH
283 print "You need to set e.g. SFI_AUTH='plc.princeton' in %s"%config_file
289 if self.options.verbose :
290 print "Contacting Slice Manager at:", sm_url
291 print "Contacting Registry at:", reg_url
293 # Get key and certificate
294 key_file = self.get_key_file()
295 cert_file = self.get_cert_file(key_file)
296 self.key = Keypair(filename=key_file)
297 self.key_file = key_file
298 self.cert_file = cert_file
299 self.cert = Certificate(filename=cert_file)
300 # Establish connection to server(s)
301 #self.slicemgr = GeniClient(sm_url, key_file, cert_file, self.options.protocol)
302 #self.registry = GeniClient(reg_url, key_file, cert_file, self.options.protocol)
303 self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file)
304 self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file)
308 # Get various credential and spec files
310 # Establishes limiting conventions
311 # - conflates MAs and SAs
312 # - assumes last token in slice name is unique
314 # Bootstraps credentials
315 # - bootstrap user credential from self-signed certificate
316 # - bootstrap authority credential from user credential
317 # - bootstrap slice credential from user credential
321 def get_key_file(self):
322 file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
323 if (os.path.isfile(file)):
326 print "Key file", file, "does not exist"
330 def get_cert_file(self,key_file):
332 file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
333 if (os.path.isfile(file)):
336 k = Keypair(filename = key_file)
337 cert = Certificate(subject=self.user)
339 cert.set_issuer(k, self.user)
341 if self.options.verbose :
342 print "Writing self-signed certificate to", file
343 cert.save_to_file(file)
347 file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid")
348 if (os.path.isfile(file)):
349 gid = GID(filename=file)
352 cert_str = self.cert.save_to_string(save_parents=True)
355 request_hash = self.key.compute_hash([cert_str, self.user, "user"])
356 gid_str = self.registry.get_gid(cert_str, self.user, "user", request_hash)
357 gid = GID(string=gid_str)
358 if self.options.verbose:
359 print "Writing user gid to", file
360 gid.save_to_file(file, save_parents=True)
363 def get_user_cred(self):
364 file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
365 if (os.path.isfile(file)):
366 user_cred = Credential(filename=file)
369 # bootstrap user credential
370 cert_string = self.cert.save_to_string(save_parents=True)
373 request_hash = self.key.compute_hash([cert_string, "user", self.user])
374 user_cred = self.registry.get_self_credential(cert_string, "user", self.user, request_hash)
376 cred = Credential(string=user_cred)
377 cred.save_to_file(file, save_parents=True)
378 if self.options.verbose:
379 print "Writing user credential to", file
382 print "Failed to get user credential"
385 def get_auth_cred(self):
386 if not self.authority:
387 print "no authority specified. Use -a or set SF_AUTH"
390 file = os.path.join(self.options.sfi_dir, get_leaf("authority") +".cred")
391 if (os.path.isfile(file)):
392 auth_cred = Credential(filename=file)
395 # bootstrap authority credential from user credential
396 user_cred = self.get_user_cred().save_to_string(save_parents=True)
399 request_hash = self.key.compute_hash([user_cred, "authority", self.authority])
400 auth_cred = self.registry.get_credential(user_cred, "authority", self.authority, request_hash)
402 cred = Credential(string=auth_cred)
403 cred.save_to_file(file, save_parents=True)
404 if self.options.verbose:
405 print "Writing authority credential to", file
408 print "Failed to get authority credential"
411 def get_slice_cred(self,name):
412 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
413 if (os.path.isfile(file)):
414 slice_cred = Credential(filename=file)
417 # bootstrap slice credential from user credential
418 user_cred = self.get_user_cred().save_to_string(save_parents=True)
419 arg_list = [user_cred, "slice", name]
422 request_hash = self.key.compute_hash(arg_list)
423 slice_cred_str = self.registry.get_credential(user_cred, "slice", name, request_hash)
425 slice_cred = Credential(string=slice_cred_str)
426 slice_cred.save_to_file(file, save_parents=True)
427 if self.options.verbose:
428 print "Writing slice credential to", file
431 print "Failed to get slice credential"
434 def delegate_cred(self,cred, hrn, type = 'authority'):
435 # the gid and hrn of the object we are delegating
436 object_gid = cred.get_gid_object()
437 object_hrn = object_gid.get_hrn()
438 cred.set_delegate(True)
439 if not cred.get_delegate():
440 raise Exception, "Error: Object credential %(object_hrn)s does not have delegate bit set" % locals()
443 records = self.registry.resolve(cred, hrn)
444 records = filter_records(type, records)
447 raise Exception, "Error: Didn't find a %(type)s record for %(hrn)s" % locals()
449 # the gid of the user who will be delegated too
450 delegee_gid = records[0].get_gid_object()
451 delegee_hrn = delegee_gid.get_hrn()
453 # the key and hrn of the user who will be delegating
454 user_key = Keypair(filename = self.get_key_file())
455 user_hrn = cred.get_gid_caller().get_hrn()
457 dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
458 dcred.set_gid_caller(delegee_gid)
459 dcred.set_gid_object(object_gid)
460 dcred.set_privileges(cred.get_privileges())
461 dcred.set_delegate(True)
462 dcred.set_pubkey(object_gid.get_pubkey())
463 dcred.set_issuer(user_key, user_hrn)
464 dcred.set_parent(cred)
470 def get_rspec_file(self,rspec):
471 if (os.path.isabs(rspec)):
474 file = os.path.join(self.options.sfi_dir, rspec)
475 if (os.path.isfile(file)):
478 print "No such rspec file", rspec
481 def get_record_file(self,record):
482 if (os.path.isabs(record)):
485 file = os.path.join(self.options.sfi_dir, record)
486 if (os.path.isfile(file)):
489 print "No such registry record file", record
492 def load_publickey_string(self,fn):
494 key_string = f.read()
496 # if the filename is a private key file, then extract the public key
497 if "PRIVATE KEY" in key_string:
498 outfn = tempfile.mktemp()
499 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
502 key_string = f.read()
508 # Following functions implement the commands
510 # Registry-related commands
513 def dispatch(self,command, cmd_opts, cmd_args):
514 getattr(self,command)(cmd_opts, cmd_args)
516 def gid(self, opts, args):
518 print "GID: %s" % (gid.save_to_string(save_parents=True))
521 # list entires in named authority registry
522 def list(self,opts, args):
523 user_cred = self.get_user_cred().save_to_string(save_parents=True)
527 request_hash = self.key.compute_hash([user_cred, hrn])
529 list = self.registry.list(user_cred, hrn, request_hash)
531 raise Exception, "Not enough parameters for the 'list' command"
533 # filter on person, slice, site, node, etc.
534 # THis really should be in the self.filter_records funct def comment...
535 list = filter_records(opts.type, list)
537 print "%s (%s)" % (record['hrn'], record['type'])
540 if not file.startswith(os.sep):
541 file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid")
542 save_records_to_file(file, list)
545 # show named registry record
546 def show(self,opts, args):
547 user_cred = self.get_user_cred().save_to_string(save_parents=True)
551 request_hash = self.key.compute_hash([user_cred, hrn])
552 records = self.registry.resolve(user_cred, hrn, request_hash)
553 records = filter_records(opts.type, records)
555 print "No record of type", opts.type
556 for record in records:
557 if record['type'] in ['user']:
558 record = UserRecord(dict = record)
559 elif record['type'] in ['slice']:
560 record = SliceRecord(dict = record)
561 elif record['type'] in ['node']:
562 record = NodeRecord(dict = record)
563 elif record['type'] in ['authority', 'ma', 'sa']:
564 record = AuthorityRecord(dict = record)
566 record = GeniRecord(dict = record)
567 if (opts.format=="text"):
570 print record.save_to_string()
574 if not file.startswith(os.sep):
575 file = os.path.join(self.options.sfi_dir, file)
576 save_records_to_file(file, records)
579 def delegate(self,opts, args):
580 user_cred = self.get_user_cred()
581 if opts.delegate_user:
582 object_cred = user_cred
583 elif opts.delegate_slice:
584 object_cred = self.get_slice_cred(opts.delegate_slice)
586 print "Must specify either --user or --slice <hrn>"
589 # the gid and hrn of the object we are delegating
590 object_gid = object_cred.get_gid_object()
591 object_hrn = object_gid.get_hrn()
593 if not object_cred.get_delegate():
594 print "Error: Object credential", object_hrn, "does not have delegate bit set"
597 records = self.registry.resolve(user_cred, args[0])
598 records = filter_records("user", records)
601 print "Error: Didn't find a user record for", args[0]
604 # the gid of the user who will be delegated too
605 delegee_gid = records[0].get_gid_object()
606 delegee_hrn = delegee_gid.get_hrn()
608 # the key and hrn of the user who will be delegating
609 user_key = Keypair(filename = self.get_key_file())
610 user_hrn = user_cred.get_gid_caller().get_hrn()
612 dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
613 dcred.set_gid_caller(delegee_gid)
614 dcred.set_gid_object(object_gid)
615 dcred.set_privileges(object_cred.get_privileges())
616 dcred.set_delegate(True)
617 dcred.set_pubkey(object_gid.get_pubkey())
618 dcred.set_issuer(user_key, user_hrn)
619 dcred.set_parent(object_cred)
623 if opts.delegate_user:
624 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
625 + get_leaf(object_hrn) + ".cred")
626 elif opts.delegate_slice:
627 dest_fn = os.path_join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
628 + get_leaf(object_hrn) + ".cred")
630 dcred.save_to_file(dest_fn, save_parents = True)
632 print "delegated credential for", object_hrn, "to", delegee_hrn, "and wrote to", dest_fn
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)
644 arg_list = [auth_cred, type, hrn]
645 request_hash = self.key.compute_hash(arg_list)
646 return self.registry.remove(auth_cred, type, hrn, request_hash)
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()
656 arg_list = [auth_cred]
657 request_hash = self.key.compute_hash(arg_list)
658 return self.registry.register(auth_cred, record, request_hash)
660 # update named registry entry
661 def update(self,opts, args):
662 user_cred = self.get_user_cred()
663 rec_file = self.get_record_file(args[0])
664 record = load_record_from_file(rec_file)
665 if record['type'] == "user":
666 if record.get_name() == user_cred.get_gid_object().get_hrn():
667 cred = user_cred.save_to_string(save_parents=True)
669 cred = self.get_auth_cred().save_to_string(save_parents=True)
670 elif record['type'] in ["slice"]:
672 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
673 except ServerException, e:
674 # XXX smbaker -- once we have better error return codes, update this
675 # to do something better than a string compare
676 if "Permission error" in e.args[0]:
677 cred = self.get_auth_cred().save_to_string(save_parents=True)
680 elif record.get_type() in ["authority"]:
681 cred = self.get_auth_cred().save_to_string(save_parents=True)
682 elif record.get_type() == 'node':
683 cred = self.get_auth_cred().save_to_string(save_parents=True)
685 raise "unknown record type" + record.get_type()
686 record = record.as_dict()
690 request_hash = self.key.compute_hash(arg_list)
691 return self.registry.update(cred, record, request_hash)
694 def aggregates(self, opts, args):
696 return a list of details about known aggregates
698 user_cred = self.get_user_cred().save_to_string(save_parents=True)
704 arg_list = [user_cred, hrn]
705 request_hash = self.key.compute_hash(arg_list)
706 result = self.registry.get_aggregates(user_cred, hrn, request_hash)
710 def registries(self, opts, args):
712 return a list of details about known registries
714 user_cred = self.get_user_cred().save_to_string(save_parents=True)
720 arg_list = [user_cred, hrn]
721 request_hash = self.key.compute_hash(arg_list)
722 result = self.registry.get_registries(user_cred, hrn, request_hash)
728 # Slice-related commands
731 # list available nodes -- use 'resources' w/ no argument instead
733 # list instantiated slices
734 def slices(self,opts, args):
735 user_cred = self.get_user_cred().save_to_string(save_parents=True)
738 arg_list = [user_cred]
739 request_hash = self.key.compute_hash(arg_list)
740 results = self.slicemgr.get_slices(user_cred, request_hash)
741 display_list(results)
744 # show rspec for named slice
745 def resources(self,opts, args):
746 user_cred = self.get_user_cred().save_to_string(save_parents=True)
747 server = self.slicemgr
749 agg_hrn = opts.aggregate
750 arg_list = [user_cred, arg_hrn]
751 request_hash = self.key.compute_hash(arg_list)
752 aggregates = self.registry.get_aggregates(user_cred, agg_hrn, request_hash)
754 raise Exception, "No such aggregate %s" % agg_hrn
755 aggregate = aggregates[0]
756 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
757 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
759 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
767 arg_list = [cred, hrn]
768 request_hash = self.key.compute_hash(arg_list)
769 result = server.get_resources(cred, hrn, request_hash)
772 display_rspec(result, format)
773 if (opts.file is not None):
775 if not file.startswith(os.sep):
776 file = os.path.join(self.options.sfi_dir, file)
777 save_rspec_to_file(result, file)
780 # created named slice with given rspec
781 def create(self,opts, args):
783 user_cred = self.get_user_cred()
784 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
785 rspec_file = self.get_rspec_file(args[1])
786 rspec=open(rspec_file).read()
787 server = self.slicemgr
789 aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
791 raise Exception, "No such aggregate %s" % opts.aggregate
792 aggregate = aggregates[0]
793 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
794 server = GeniClient(url, self.key_file, self.cert_file, self.options.protocol)
797 arg_list = [slice_cred, slice_hrn, rspec]
798 request_hash = self.key.compute_hash(arg_list)
799 return server.create_slice(slice_cred, slice_hrn, rspec, request_hash)
801 # get a ticket for the specified slice
802 def get_ticket(self, opts, args):
803 slice_hrn, rspec_path = args[0], args[1]
804 user_cred = self.get_user_cred()
805 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
806 rspec_file = self.get_rspec_file(rspec_path)
807 rspec=open(rspec_file).read()
808 server = self.slicemgr
810 aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
812 raise Exception, "No such aggregate %s" % opts.aggregate
813 aggregate = aggregates[0]
814 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
815 server = GeniClient(url, self.key_file, self.cert_file, self.options.protocol)
818 arg_list = [slice_cred, slice_hrn, rspec]
819 request_hash = self.key.compute_hash(arg_list)
820 ticket_string = server.get_ticket(slice_cred, slice_hrn, rspec, request_hash)
821 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
822 print "writing ticket to ", file
823 ticket = SfaTicket(string=ticket_string)
824 ticket.save_to_file(filename=file, save_parents=True)
826 def redeem_ticket(self, opts, args):
827 ticket_file = args[0]
829 # get slice hrn from the ticket
830 # use this to get the right slice credential
831 ticket = SfaTicket(filename=ticket_file)
833 slice_hrn = ticket.attributes['slivers'][0]['hrn']
834 user_cred = self.get_user_cred()
835 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
837 # get a list node hostnames from the nodespecs in the rspec
839 rspec.parseString(ticket.rspec)
840 nodespecs = rspec.getDictsByTagName('NodeSpec')
841 hostnames = [nodespec['name'] for nodespec in nodespecs]
843 # create an xmlrpc connection to the component manager at each of these
844 # components and gall redeem_ticket
846 for hostname in hostnames:
849 url = "https://%(hostname)s:%(cm_port)s" % locals()
850 print "Calling get_ticket at %(url)s " % locals(),
851 cm = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
852 cm.redeem_ticket(slice_cred, ticket.save_to_string(save_parents=True))
854 except socket.gaierror:
856 print "Componet Manager not accepting requests"
858 print "Failed:", e.message
863 def delete(self,opts, args):
865 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
868 arg_list = [slice_cred, slice_hrn]
869 request_hash = self.key.compute_hash(arg_list)
870 return self.slicemgr.delete_slice(slice_cred, slice_hrn, request_hash)
873 def start(self,opts, args):
875 slice_cred = self.get_slice_cred(args[0])
878 arg_list = [slice_cred, slice_hrn]
879 request_hash = self.key.compute_hash(arg_list)
880 return self.slicemgr.start_slice(slice_cred, slice_hrn, request_hash)
883 def stop(self,opts, args):
885 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
888 arg_list = [slice_cred, slice_hrn]
889 request_hash = self.key.compute_hash(arg_list)
890 return self.slicemgr.stop_slice(slice_cred, slice_hrn, request_hash)
893 def reset(self,opts, args):
895 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
898 arg_list = [slice_cred, slice_hrn]
899 request_hash = self.key.compute_hash(arg_list)
900 return self.slicemgr.reset_slice(slice_cred, slice_hrn, request_hash)
903 # Main: parse arguments and dispatch to command
906 parser = self.create_parser()
907 (options, args) = parser.parse_args()
908 self.options = options
910 if options.hashrequest:
911 self.hashrequest=True
914 print "No command given. Use -h for help."
918 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
919 if self.options.verbose :
920 print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm,
921 options.sfi_dir, options.user,
923 print "Command %s" %command
924 if command in ("resources"):
925 print "resources cmd_opts %s" %cmd_opts.format
926 elif command in ("list","show","remove"):
927 print "cmd_opts.type %s" %cmd_opts.type
928 print "cmd_args %s" %cmd_args
933 self.dispatch(command, cmd_opts, cmd_args)
936 print "Command not found:", command
941 if __name__=="__main__":