3 # sfi -- slice-based facility interface
11 from lxml import etree
12 from StringIO import StringIO
13 from types import StringTypes, ListType
14 from optparse import OptionParser
15 from sfa.trust.certificate import Keypair, Certificate
16 from sfa.trust.credential import Credential
17 from sfa.util.sfaticket import SfaTicket
18 from sfa.util.record import *
19 from sfa.util.namespace import *
20 from sfa.util.xmlrpcprotocol import ServerException
21 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
22 from sfa.util.config import Config
25 # utility methods here
27 def display_rspec(rspec, format = 'rspec'):
29 tree = etree.parse(StringIO(rspec))
31 result = root.xpath("./network/site/node/hostname/text()")
32 elif format in ['ip']:
33 # The IP address is not yet part of the new RSpec
34 # so this doesn't do anything yet.
35 tree = etree.parse(StringIO(rspec))
37 result = root.xpath("./network/site/node/ipv4/text()")
44 def display_list(results):
45 for result in results:
49 def display_records(recordList, dump = False):
50 ''' Print all fields in the record'''
51 for record in recordList:
52 display_record(record, dump)
54 def display_record(record, dump = False):
58 info = record.getdict()
59 print "%s (%s)" % (info['hrn'], info['type'])
63 def filter_records(type, records):
65 for record in records:
66 if (record['type'] == type) or (type == "all"):
67 filtered_records.append(record)
68 return filtered_records
72 def save_rspec_to_file(rspec, filename):
73 if not filename.endswith(".rspec"):
74 filename = filename + ".rspec"
76 f = open(filename, 'w')
81 def save_records_to_file(filename, recordList):
83 for record in recordList:
85 save_record_to_file(filename + "." + str(index), record)
87 save_record_to_file(filename, record)
90 def save_record_to_file(filename, record):
91 if record['type'] in ['user']:
92 record = UserRecord(dict = record)
93 elif record['type'] in ['slice']:
94 record = SliceRecord(dict = record)
95 elif record['type'] in ['node']:
96 record = NodeRecord(dict = record)
97 elif record['type'] in ['authority', 'ma', 'sa']:
98 record = AuthorityRecord(dict = record)
100 record = SfaRecord(dict = record)
101 str = record.save_to_string()
102 file(filename, "w").write(str)
107 def load_record_from_file(filename):
108 str = file(filename, "r").read()
109 record = SfaRecord(string=str)
123 def create_cmd_parser(self,command, additional_cmdargs = None):
124 cmdargs = {"gid": "",
130 "aggregates": "[name]",
131 "registries": "[name]",
133 "resources": "[name]",
134 "create": "name rspec",
135 "get_trusted_certs": "cred",
136 "get_ticket": "name rspec",
137 "redeem_ticket": "ticket",
145 if additional_cmdargs:
146 cmdargs.update(additional_cmdargs)
148 if command not in cmdargs:
149 print "Invalid command\n"
151 for key in cmdargs.keys():
156 parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
157 % (command, cmdargs[command]))
159 if command in ("resources"):
160 parser.add_option("-f", "--format", dest="format",type="choice",
161 help="display format ([xml]|dns|ip)",default="xml",
162 choices=("xml","dns","ip"))
163 parser.add_option("-a", "--aggregate", dest="aggregate",
164 default=None, help="aggregate hrn")
166 if command in ("create", "get_ticket"):
167 parser.add_option("-a", "--aggregate", dest="aggregate",default=None,
168 help="aggregate hrn")
170 if command in ("start", "stop", "reset", "delete", "slices"):
171 parser.add_option("-c", "--component", dest="component",default=None,
172 help="component hrn")
174 if command in ("list", "show", "remove"):
175 parser.add_option("-t", "--type", dest="type",type="choice",
176 help="type filter ([all]|user|slice|sa|ma|node|aggregate)",
177 choices=("all","user","slice","sa","ma","node","aggregate"),
180 if command in ("resources", "show", "list"):
181 parser.add_option("-o", "--output", dest="file",
182 help="output XML to file", metavar="FILE", default=None)
184 if command in ("show", "list"):
185 parser.add_option("-f", "--format", dest="format", type="choice",
186 help="display format ([text]|xml)",default="text",
187 choices=("text","xml"))
189 if command in ("delegate"):
190 parser.add_option("-u", "--user",
191 action="store_true", dest="delegate_user", default=False,
192 help="delegate user credential")
193 parser.add_option("-s", "--slice", dest="delegate_slice",
194 help="delegate slice credential", metavar="HRN", default=None)
198 def create_parser(self):
200 # Generate command line parser
201 parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
202 description="Commands: gid,list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
203 parser.add_option("-r", "--registry", dest="registry",
204 help="root registry", metavar="URL", default=None)
205 parser.add_option("-s", "--slicemgr", dest="sm",
206 help="slice manager", metavar="URL", default=None)
207 default_sfi_dir=os.path.expanduser("~/.sfi/")
208 parser.add_option("-d", "--dir", dest="sfi_dir",
209 help="config & working directory - default is " + default_sfi_dir,
210 metavar="PATH", default = default_sfi_dir)
211 parser.add_option("-u", "--user", dest="user",
212 help="user name", metavar="HRN", default=None)
213 parser.add_option("-a", "--auth", dest="auth",
214 help="authority name", metavar="HRN", default=None)
215 parser.add_option("-v", "--verbose",
216 action="store_true", dest="verbose", default=False,
218 parser.add_option("-D", "--debug",
219 action="store_true", dest="debug", default=False,
220 help="Debug (xml-rpc) protocol messages")
221 parser.add_option("-p", "--protocol",
222 dest="protocol", default="xmlrpc",
223 help="RPC protocol (xmlrpc or soap)")
224 parser.add_option("-k", "--hashrequest",
225 action="store_true", dest="hashrequest", default=False,
226 help="Create a hash of the request that will be authenticated on the server")
227 parser.disable_interspersed_args()
233 # Establish Connection to SliceMgr and Registry Servers
235 def set_servers(self):
236 config_file = self.options.sfi_dir + os.sep + "sfi_config"
238 config = Config (config_file)
240 print "Failed to read configuration file",config_file
241 print "Make sure to remove the export clauses and to add quotes"
242 if not self.options.verbose:
243 print "Re-run with -v for more details"
245 traceback.print_exc()
250 if (self.options.sm is not None):
251 sm_url = self.options.sm
252 elif hasattr(config,"SFI_SM"):
253 sm_url = config.SFI_SM
255 print "You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s"%config_file
259 if (self.options.registry is not None):
260 reg_url = self.options.registry
261 elif hasattr(config,"SFI_REGISTRY"):
262 reg_url = config.SFI_REGISTRY
264 print "You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s"%config_file
268 if (self.options.user is not None):
269 self.user = self.options.user
270 elif hasattr(config,"SFI_USER"):
271 self.user = config.SFI_USER
273 print "You need to set e.g. SFI_USER='plc.princeton.username' in %s"%config_file
277 if (self.options.auth is not None):
278 self.authority = self.options.auth
279 elif hasattr(config,"SFI_AUTH"):
280 self.authority = config.SFI_AUTH
282 print "You need to set e.g. SFI_AUTH='plc.princeton' in %s"%config_file
288 if self.options.verbose :
289 print "Contacting Slice Manager at:", sm_url
290 print "Contacting Registry at:", reg_url
292 # Get key and certificate
293 key_file = self.get_key_file()
294 cert_file = self.get_cert_file(key_file)
295 self.key = Keypair(filename=key_file)
296 self.key_file = key_file
297 self.cert_file = cert_file
298 self.cert = Certificate(filename=cert_file)
299 # Establish connection to server(s)
300 self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file, self.options.debug)
301 self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file, self.options.debug)
305 # Get various credential and spec files
307 # Establishes limiting conventions
308 # - conflates MAs and SAs
309 # - assumes last token in slice name is unique
311 # Bootstraps credentials
312 # - bootstrap user credential from self-signed certificate
313 # - bootstrap authority credential from user credential
314 # - bootstrap slice credential from user credential
318 def get_key_file(self):
319 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey")
320 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
321 if (os.path.isfile(file)):
324 print "Key file", file, "does not exist"
328 def get_cert_file(self,key_file):
330 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
331 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert")
332 if (os.path.isfile(file)):
335 k = Keypair(filename = key_file)
336 cert = Certificate(subject=self.user)
338 cert.set_issuer(k, self.user)
340 if self.options.verbose :
341 print "Writing self-signed certificate to", file
342 cert.save_to_file(file)
346 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid")
347 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".gid")
348 if (os.path.isfile(file)):
349 gid = GID(filename=file)
352 cert_str = self.cert.save_to_string(save_parents=True)
353 gid_str = self.registry.get_gid(cert_str, self.user, "user")
354 gid = GID(string=gid_str)
355 if self.options.verbose:
356 print "Writing user gid to", file
357 gid.save_to_file(file, save_parents=True)
360 def get_user_cred(self):
361 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
362 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred")
363 if (os.path.isfile(file)):
364 user_cred = Credential(filename=file)
367 # bootstrap user credential
368 cert_string = self.cert.save_to_string(save_parents=True)
369 user_name=self.user.replace(self.authority+".", '')
370 if user_name.count(".") > 0:
371 user_name = user_name.replace(".", '_')
372 self.user=self.authority + "." + user_name
374 user_cred = self.registry.get_self_credential(cert_string, "user", self.user)
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)
397 auth_cred = self.registry.get_credential(user_cred, "authority", self.authority)
399 cred = Credential(string=auth_cred)
400 cred.save_to_file(file, save_parents=True)
401 if self.options.verbose:
402 print "Writing authority credential to", file
405 print "Failed to get authority credential"
408 def get_slice_cred(self,name):
409 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
410 if (os.path.isfile(file)):
411 slice_cred = Credential(filename=file)
414 # bootstrap slice credential from user credential
415 user_cred = self.get_user_cred().save_to_string(save_parents=True)
416 arg_list = [user_cred, "slice", name]
417 slice_cred_str = self.registry.get_credential(user_cred, "slice", name)
419 slice_cred = Credential(string=slice_cred_str)
420 slice_cred.save_to_file(file, save_parents=True)
421 if self.options.verbose:
422 print "Writing slice credential to", file
425 print "Failed to get slice credential"
428 def delegate_cred(self,cred, hrn, type = 'authority'):
429 # the gid and hrn of the object we are delegating
430 user_cred = Credential(string=cred)
431 object_gid = user_cred.get_gid_object()
432 object_hrn = object_gid.get_hrn()
433 #cred.set_delegate(True)
434 #if not cred.get_delegate():
435 # raise Exception, "Error: Object credential %(object_hrn)s does not have delegate bit set" % locals()
438 records = self.registry.resolve(cred, hrn)
439 records = filter_records(type, records)
442 raise Exception, "Error: Didn't find a %(type)s record for %(hrn)s" % locals()
444 # the gid of the user who will be delegated too
445 record = SfaRecord(dict=records[0])
446 delegee_gid = record.get_gid_object()
447 delegee_hrn = delegee_gid.get_hrn()
449 # the key and hrn of the user who will be delegating
450 user_key = Keypair(filename = self.get_key_file())
451 user_hrn = user_cred.get_gid_caller().get_hrn()
453 dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
454 dcred.set_gid_caller(delegee_gid)
455 dcred.set_gid_object(object_gid)
456 dcred.set_privileges(user_cred.get_privileges())
457 dcred.set_delegate(True)
458 dcred.set_pubkey(object_gid.get_pubkey())
459 dcred.set_issuer(user_key, user_hrn)
460 dcred.set_parent(user_cred)
464 return dcred.save_to_string(save_parents=True)
466 def get_rspec_file(self,rspec):
467 if (os.path.isabs(rspec)):
470 file = os.path.join(self.options.sfi_dir, rspec)
471 if (os.path.isfile(file)):
474 print "No such rspec file", rspec
477 def get_record_file(self,record):
478 if (os.path.isabs(record)):
481 file = os.path.join(self.options.sfi_dir, record)
482 if (os.path.isfile(file)):
485 print "No such registry record file", record
488 def load_publickey_string(self,fn):
490 key_string = f.read()
492 # if the filename is a private key file, then extract the public key
493 if "PRIVATE KEY" in key_string:
494 outfn = tempfile.mktemp()
495 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
498 key_string = f.read()
503 def get_component_server_from_hrn(self, hrn):
504 # direct connection to the nodes component manager interface
505 user_cred = self.get_user_cred().save_to_string(save_parents=True)
506 records = self.registry.resolve(user_cred, hrn)
507 records = filter_records('node', records)
509 print "No such component:", opts.component
512 url = "https://%s:%s" % (record['hostname'], cm_port)
513 return xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug)
516 # Following functions implement the commands
518 # Registry-related commands
521 def dispatch(self,command, cmd_opts, cmd_args):
522 getattr(self,command)(cmd_opts, cmd_args)
524 def gid(self, opts, args):
526 print "GID: %s" % (gid.save_to_string(save_parents=True))
529 # list entires in named authority registry
530 def list(self,opts, args):
531 user_cred = self.get_user_cred().save_to_string(save_parents=True)
534 list = self.registry.list(user_cred, hrn)
536 raise Exception, "Not enough parameters for the 'list' command"
538 # filter on person, slice, site, node, etc.
539 # THis really should be in the self.filter_records funct def comment...
540 list = filter_records(opts.type, list)
542 print "%s (%s)" % (record['hrn'], record['type'])
545 if not file.startswith(os.sep):
546 file = os.path.join(self.options.sfi_dir, file)
547 save_records_to_file(file, list)
550 # show named registry record
551 def show(self,opts, args):
552 user_cred = self.get_user_cred().save_to_string(save_parents=True)
554 records = self.registry.resolve(user_cred, hrn)
555 records = filter_records(opts.type, records)
557 print "No record of type", opts.type
558 for record in records:
559 if record['type'] in ['user']:
560 record = UserRecord(dict = record)
561 elif record['type'] in ['slice']:
562 record = SliceRecord(dict = record)
563 elif record['type'] in ['node']:
564 record = NodeRecord(dict = record)
565 elif record['type'] in ['authority', 'ma', 'sa']:
566 record = AuthorityRecord(dict = record)
568 record = SfaRecord(dict = record)
569 if (opts.format=="text"):
572 print record.save_to_string()
576 if not file.startswith(os.sep):
577 file = os.path.join(self.options.sfi_dir, file)
578 save_records_to_file(file, records)
581 def delegate(self,opts, args):
582 user_cred = self.get_user_cred()
583 if opts.delegate_user:
584 object_cred = user_cred
585 elif opts.delegate_slice:
586 object_cred = self.get_slice_cred(opts.delegate_slice)
588 print "Must specify either --user or --slice <hrn>"
591 # the gid and hrn of the object we are delegating
592 object_gid = object_cred.get_gid_object()
593 object_hrn = object_gid.get_hrn()
595 if not object_cred.get_delegate():
596 print "Error: Object credential", object_hrn, "does not have delegate bit set"
599 records = self.registry.resolve(user_cred.save_to_string(save_parents=True), args[0])
600 records = filter_records("user", records)
603 print "Error: Didn't find a user record for", args[0]
606 # the gid of the user who will be delegated too
607 delegee_gid = GID(string=records[0]['gid'])
608 delegee_hrn = delegee_gid.get_hrn()
610 # the key and hrn of the user who will be delegating
611 user_key = Keypair(filename = self.get_key_file())
612 user_hrn = user_cred.get_gid_caller().get_hrn()
613 subject_string = "%s delegated to %s" % (object_hrn, delegee_hrn)
614 dcred = Credential(subject=subject_string)
615 dcred.set_gid_caller(delegee_gid)
616 dcred.set_gid_object(object_gid)
617 dcred.set_privileges(object_cred.get_privileges())
618 dcred.set_delegate(True)
619 dcred.set_pubkey(object_gid.get_pubkey())
620 dcred.set_issuer(user_key, user_hrn)
621 dcred.set_parent(object_cred)
625 if opts.delegate_user:
626 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
627 + get_leaf(object_hrn) + ".cred")
628 elif opts.delegate_slice:
629 dest_fn = os.path_join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
630 + get_leaf(object_hrn) + ".cred")
632 dcred.save_to_file(dest_fn, save_parents = True)
634 print "delegated credential for", object_hrn, "to", delegee_hrn, "and wrote to", dest_fn
636 # removed named registry record
637 # - have to first retrieve the record to be removed
638 def remove(self,opts, args):
639 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
644 return self.registry.remove(auth_cred, type, hrn)
646 # add named registry record
647 def add(self,opts, args):
648 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
649 record_filepath = args[0]
650 rec_file = self.get_record_file(record_filepath)
651 record = load_record_from_file(rec_file).as_dict()
652 return self.registry.register(auth_cred, record)
654 # update named registry entry
655 def update(self,opts, args):
656 user_cred = self.get_user_cred()
657 rec_file = self.get_record_file(args[0])
658 record = load_record_from_file(rec_file)
659 if record['type'] == "user":
660 if record.get_name() == user_cred.get_gid_object().get_hrn():
661 cred = user_cred.save_to_string(save_parents=True)
663 cred = self.get_auth_cred().save_to_string(save_parents=True)
664 elif record['type'] in ["slice"]:
666 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
667 except ServerException, e:
668 # XXX smbaker -- once we have better error return codes, update this
669 # to do something better than a string compare
670 if "Permission error" in e.args[0]:
671 cred = self.get_auth_cred().save_to_string(save_parents=True)
674 elif record.get_type() in ["authority"]:
675 cred = self.get_auth_cred().save_to_string(save_parents=True)
676 elif record.get_type() == 'node':
677 cred = self.get_auth_cred().save_to_string(save_parents=True)
679 raise "unknown record type" + record.get_type()
680 record = record.as_dict()
681 return self.registry.update(cred, record)
683 def get_trusted_certs(self, opts, args):
685 return the trusted certs at this interface
687 trusted_certs = self.registry.get_trusted_certs()
688 for trusted_cert in trusted_certs:
689 cert = Certificate(string=trusted_cert)
690 print cert.get_subject()
693 def aggregates(self, opts, args):
695 return a list of details about known aggregates
697 user_cred = self.get_user_cred().save_to_string(save_parents=True)
701 result = self.registry.get_aggregates(user_cred, hrn)
705 def registries(self, opts, args):
707 return a list of details about known registries
709 user_cred = self.get_user_cred().save_to_string(save_parents=True)
713 result = self.registry.get_registries(user_cred, hrn)
719 # Slice-related commands
722 # list available nodes -- use 'resources' w/ no argument instead
724 # list instantiated slices
725 def slices(self,opts, args):
726 user_cred = self.get_user_cred().save_to_string(save_parents=True)
727 server = self.slicemgr
728 # direct connection to the nodes component manager interface
730 server = self.get_component_server_from_hrn(opts.component)
731 results = server.get_slices(user_cred)
732 display_list(results)
735 # show rspec for named slice
736 def resources(self,opts, args):
737 user_cred = self.get_user_cred().save_to_string(save_parents=True)
738 server = self.slicemgr
740 agg_hrn = opts.aggregate
741 aggregates = self.registry.get_aggregates(user_cred, agg_hrn)
743 raise Exception, "No such aggregate %s" % agg_hrn
744 aggregate = aggregates[0]
745 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
746 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug)
748 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
754 result = server.get_resources(cred, hrn)
757 display_rspec(result, format)
758 if (opts.file is not None):
760 if not file.startswith(os.sep):
761 file = os.path.join(self.options.sfi_dir, file)
762 save_rspec_to_file(result, file)
765 # created named slice with given rspec
766 def create(self,opts, args):
768 user_cred = self.get_user_cred()
769 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
770 rspec_file = self.get_rspec_file(args[1])
771 rspec=open(rspec_file).read()
772 server = self.slicemgr
774 aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
776 raise Exception, "No such aggregate %s" % opts.aggregate
777 aggregate = aggregates[0]
778 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
779 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug)
780 return server.create_slice(slice_cred, slice_hrn, rspec)
782 # get a ticket for the specified slice
783 def get_ticket(self, opts, args):
784 slice_hrn, rspec_path = args[0], args[1]
785 user_cred = self.get_user_cred()
786 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
787 rspec_file = self.get_rspec_file(rspec_path)
788 rspec=open(rspec_file).read()
789 server = self.slicemgr
791 aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
793 raise Exception, "No such aggregate %s" % opts.aggregate
794 aggregate = aggregates[0]
795 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
796 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug)
797 ticket_string = server.get_ticket(slice_cred, slice_hrn, rspec)
798 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
799 print "writing ticket to ", 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_hrn = ticket.attributes['slivers'][0]['hrn']
812 user_cred = self.get_user_cred()
813 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
815 # get a list of node hostnames from the RSpec
816 tree = etree.parse(StringIO(ticket.rspec))
817 root = tree.getroot()
818 hostnames = root.xpath("./network/site/node/hostname/text()")
820 # create an xmlrpc connection to the component manager at each of these
821 # components and gall redeem_ticket
823 for hostname in hostnames:
826 url = "https://%(hostname)s:%(cm_port)s" % locals()
827 print "Calling redeem_ticket at %(url)s " % locals(),
828 cm = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.debug)
829 cm.redeem_ticket(slice_cred, ticket.save_to_string(save_parents=True))
831 except socket.gaierror:
833 print "Componet Manager not accepting requests"
835 print "Failed:", e.message
840 def delete(self,opts, args):
842 server = self.slicemgr
843 # direct connection to the nodes component manager interface
845 server = self.get_component_server_from_hrn(opts.component)
847 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
848 return server.delete_slice(slice_cred, slice_hrn)
851 def start(self,opts, args):
853 server = self.slicemgr
854 # direct connection to the nodes component manager interface
856 server = self.get_component_server_from_hrn(opts.component)
858 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
859 return server.start_slice(slice_cred, slice_hrn)
862 def stop(self,opts, args):
864 server = self.slicemgr
865 # direct connection to the nodes component manager interface
867 server = self.get_component_server_from_hrn(opts.component)
869 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
870 return server.stop_slice(slice_cred, slice_hrn)
873 def reset(self,opts, args):
875 server = self.slicemgr
876 # direct connection to the nodes component manager interface
878 server = self.get_component_server_from_hrn(opts.component)
879 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
880 return server.reset_slice(slice_cred, slice_hrn)
883 # Main: parse arguments and dispatch to command
886 parser = self.create_parser()
887 (options, args) = parser.parse_args()
888 self.options = options
890 if options.hashrequest:
891 self.hashrequest=True
894 print "No command given. Use -h for help."
898 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
899 if self.options.verbose :
900 print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm,
901 options.sfi_dir, options.user,
903 print "Command %s" %command
904 if command in ("resources"):
905 print "resources cmd_opts %s" %cmd_opts.format
906 elif command in ("list","show","remove"):
907 print "cmd_opts.type %s" %cmd_opts.type
908 print "cmd_args %s" %cmd_args
913 self.dispatch(command, cmd_opts, cmd_args)
916 print "Command not found:", command
921 if __name__=="__main__":