3 # sfi -- slice-based facility interface
11 from types import StringTypes, ListType
12 from optparse import OptionParser
13 from sfa.trust.certificate import Keypair, Certificate
14 from sfa.trust.credential import Credential
15 from sfa.util.sfaticket import SfaTicket
16 from sfa.util.record import *
17 from sfa.util.namespace 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
24 # utility methods here
26 def display_rspec(rspec, format = 'rspec'):
29 spec.parseString(rspec)
31 nodespecs = spec.getDictsByTagName('NodeSpec')
32 for nodespec in nodespecs:
33 if nodespec.has_key('name') and nodespec['name']:
34 if isinstance(nodespec['name'], ListType):
35 hostnames.extend(nodespec['name'])
36 elif isinstance(nodespec['name'], StringTypes):
37 hostnames.append(nodespec['name'])
39 elif format in ['ip']:
41 spec.parseString(rspec)
43 ifspecs = spec.getDictsByTagName('IfSpec')
44 for ifspec in ifspecs:
45 if ifspec.has_key('addr') and ifspec['addr']:
46 ips.append(ifspec['addr'])
54 def display_list(results):
55 for result in results:
59 def display_records(recordList, dump = False):
60 ''' Print all fields in the record'''
61 for record in recordList:
62 display_record(record, dump)
64 def display_record(record, dump = False):
68 info = record.getdict()
69 print "%s (%s)" % (info['hrn'], info['type'])
73 def filter_records(type, records):
75 for record in records:
76 if (record['type'] == type) or (type == "all"):
77 filtered_records.append(record)
78 return filtered_records
82 def save_rspec_to_file(rspec, filename):
83 if not filename.endswith(".rspec"):
84 filename = filename + ".rspec"
86 f = open(filename, 'w')
91 def save_records_to_file(filename, recordList):
93 for record in recordList:
95 save_record_to_file(filename + "." + str(index), record)
97 save_record_to_file(filename, record)
100 def save_record_to_file(filename, record):
101 if record['type'] in ['user']:
102 record = UserRecord(dict = record)
103 elif record['type'] in ['slice']:
104 record = SliceRecord(dict = record)
105 elif record['type'] in ['node']:
106 record = NodeRecord(dict = record)
107 elif record['type'] in ['authority', 'ma', 'sa']:
108 record = AuthorityRecord(dict = record)
110 record = SfaRecord(dict = record)
111 str = record.save_to_string()
112 file(filename, "w").write(str)
117 def load_record_from_file(filename):
118 str = file(filename, "r").read()
119 record = SfaRecord(string=str)
134 def create_cmd_parser(self,command, additional_cmdargs = None):
135 cmdargs = {"gid": "",
141 "aggregates": "[name]",
142 "registries": "[name]",
144 "resources": "[name]",
145 "create": "name rspec",
146 "get_trusted_certs": "cred",
147 "get_ticket": "name rspec",
148 "redeem_ticket": "ticket",
154 "GetVersion": "name",
155 "ListResources": "name",
156 "CreateSliver": "name"
159 if additional_cmdargs:
160 cmdargs.update(additional_cmdargs)
162 if command not in cmdargs:
163 print "Invalid command\n"
165 for key in cmdargs.keys():
170 parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
171 % (command, cmdargs[command]))
173 if command in ("resources"):
174 parser.add_option("-f", "--format", dest="format",type="choice",
175 help="display format ([xml]|dns|ip)",default="xml",
176 choices=("xml","dns","ip"))
177 parser.add_option("-a", "--aggregate", dest="aggregate",
178 default=None, help="aggregate hrn")
180 if command in ("create", "get_ticket"):
181 parser.add_option("-a", "--aggregate", dest="aggregate",default=None,
182 help="aggregate hrn")
184 if command in ("start", "stop", "reset", "delete", "slices"):
185 parser.add_option("-c", "--component", dest="component",default=None,
186 help="component hrn")
188 if command in ("list", "show", "remove"):
189 parser.add_option("-t", "--type", dest="type",type="choice",
190 help="type filter ([all]|user|slice|sa|ma|node|aggregate)",
191 choices=("all","user","slice","sa","ma","node","aggregate"),
194 if command in ("resources", "show", "list"):
195 parser.add_option("-o", "--output", dest="file",
196 help="output XML to file", metavar="FILE", default=None)
198 if command in ("show", "list"):
199 parser.add_option("-f", "--format", dest="format", type="choice",
200 help="display format ([text]|xml)",default="text",
201 choices=("text","xml"))
203 if command in ("delegate"):
204 parser.add_option("-u", "--user",
205 action="store_true", dest="delegate_user", default=False,
206 help="delegate user credential")
207 parser.add_option("-s", "--slice", dest="delegate_slice",
208 help="delegate slice credential", metavar="HRN", default=None)
213 def create_parser(self):
215 # Generate command line parser
216 parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
217 description="Commands: gid,list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
218 parser.add_option("-g", "--geni_am", dest="geni_am",
219 help="geni am", metavar="URL", default=None)
220 parser.add_option("-r", "--registry", dest="registry",
221 help="root registry", metavar="URL", default=None)
222 parser.add_option("-s", "--slicemgr", dest="sm",
223 help="slice manager", metavar="URL", default=None)
224 default_sfi_dir=os.path.expanduser("~/.sfi/")
225 parser.add_option("-d", "--dir", dest="sfi_dir",
226 help="config & working directory - default is " + default_sfi_dir,
227 metavar="PATH", default = default_sfi_dir)
228 parser.add_option("-u", "--user", dest="user",
229 help="user name", metavar="HRN", default=None)
230 parser.add_option("-a", "--auth", dest="auth",
231 help="authority name", metavar="HRN", default=None)
232 parser.add_option("-v", "--verbose",
233 action="store_true", dest="verbose", default=False,
235 parser.add_option("-p", "--protocol",
236 dest="protocol", default="xmlrpc",
237 help="RPC protocol (xmlrpc or soap)")
238 parser.add_option("-k", "--hashrequest",
239 action="store_true", dest="hashrequest", default=False,
240 help="Create a hash of the request that will be authenticated on the server")
241 parser.disable_interspersed_args()
247 # Establish Connection to SliceMgr and Registry Servers
249 def set_servers(self):
250 config_file = self.options.sfi_dir + os.sep + "sfi_config"
252 config = Config (config_file)
254 print "Failed to read configuration file",config_file
255 print "Make sure to remove the export clauses and to add quotes"
256 if not self.options.verbose:
257 print "Re-run with -v for more details"
259 traceback.print_exc()
264 if (self.options.sm is not None):
265 sm_url = self.options.sm
266 elif hasattr(config,"SFI_SM"):
267 sm_url = config.SFI_SM
269 print "You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s"%config_file
273 if (self.options.registry is not None):
274 reg_url = self.options.registry
275 elif hasattr(config,"SFI_REGISTRY"):
276 reg_url = config.SFI_REGISTRY
278 print "You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s"%config_file
282 if (self.options.geni_am is not None):
283 geni_am_url = self.options.geni_am
284 elif hasattr(config,"SFI_GENI_AM"):
285 geni_am_url = config.SFI_GENI_AM
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 print "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 print "You need to set e.g. SFI_AUTH='plc.princeton' in %s"%config_file
308 if self.options.verbose :
309 print "Contacting Slice Manager at:", sm_url
310 print "Contacting Registry at:", reg_url
312 # Get key and certificate
313 key_file = self.get_key_file()
314 cert_file = self.get_cert_file(key_file)
315 self.key = Keypair(filename=key_file)
316 self.key_file = key_file
317 self.cert_file = cert_file
318 self.cert = Certificate(filename=cert_file)
319 # Establish connection to server(s)
320 self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file)
321 self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file)
322 self.geni_am = xmlrpcprotocol.get_server(geni_am_url, key_file, cert_file)
326 # Get various credential and spec files
328 # Establishes limiting conventions
329 # - conflates MAs and SAs
330 # - assumes last token in slice name is unique
332 # Bootstraps credentials
333 # - bootstrap user credential from self-signed certificate
334 # - bootstrap authority credential from user credential
335 # - bootstrap slice credential from user credential
339 def get_key_file(self):
340 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey")
341 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
342 if (os.path.isfile(file)):
345 print "Key file", file, "does not exist"
349 def get_cert_file(self,key_file):
351 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
352 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert")
353 if (os.path.isfile(file)):
356 k = Keypair(filename = key_file)
357 cert = Certificate(subject=self.user)
359 cert.set_issuer(k, self.user)
361 if self.options.verbose :
362 print "Writing self-signed certificate to", file
363 cert.save_to_file(file)
367 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid")
368 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".gid")
369 if (os.path.isfile(file)):
370 gid = GID(filename=file)
373 cert_str = self.cert.save_to_string(save_parents=True)
374 gid_str = self.registry.get_gid(cert_str, self.user, "user")
375 gid = GID(string=gid_str)
376 if self.options.verbose:
377 print "Writing user gid to", file
378 gid.save_to_file(file, save_parents=True)
381 def get_user_cred(self):
382 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
383 file=os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred")
384 if (os.path.isfile(file)):
385 user_cred = Credential(filename=file)
388 # bootstrap user credential
389 cert_string = self.cert.save_to_string(save_parents=True)
390 user_name=self.user.replace(self.authority+".", '')
391 if user_name.count(".") > 0:
392 user_name = user_name.replace(".", '_')
393 self.user=self.authority + "." + user_name
395 user_cred = self.registry.get_self_credential(cert_string, "user", self.user)
397 cred = Credential(string=user_cred)
398 cred.save_to_file(file, save_parents=True)
399 if self.options.verbose:
400 print "Writing user credential to", file
403 print "Failed to get user credential"
406 def get_auth_cred(self):
407 if not self.authority:
408 print "no authority specified. Use -a or set SF_AUTH"
411 file = os.path.join(self.options.sfi_dir, get_leaf("authority") +".cred")
412 if (os.path.isfile(file)):
413 auth_cred = Credential(filename=file)
416 # bootstrap authority credential from user credential
417 user_cred = self.get_user_cred().save_to_string(save_parents=True)
418 auth_cred = self.registry.get_credential(user_cred, "authority", self.authority)
420 cred = Credential(string=auth_cred)
421 cred.save_to_file(file, save_parents=True)
422 if self.options.verbose:
423 print "Writing authority credential to", file
426 print "Failed to get authority credential"
429 def get_slice_cred(self,name):
430 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
431 if (os.path.isfile(file)):
432 slice_cred = Credential(filename=file)
435 # bootstrap slice credential from user credential
436 user_cred = self.get_user_cred().save_to_string(save_parents=True)
437 arg_list = [user_cred, "slice", name]
438 slice_cred_str = self.registry.get_credential(user_cred, "slice", name)
440 slice_cred = Credential(string=slice_cred_str)
441 slice_cred.save_to_file(file, save_parents=True)
442 if self.options.verbose:
443 print "Writing slice credential to", file
446 print "Failed to get slice credential"
449 def delegate_cred(self,cred, hrn, type = 'authority'):
450 # the gid and hrn of the object we are delegating
451 user_cred = Credential(string=cred)
452 object_gid = user_cred.get_gid_object()
453 object_hrn = object_gid.get_hrn()
454 #cred.set_delegate(True)
455 #if not cred.get_delegate():
456 # raise Exception, "Error: Object credential %(object_hrn)s does not have delegate bit set" % locals()
459 records = self.registry.resolve(cred, hrn)
460 records = filter_records(type, records)
463 raise Exception, "Error: Didn't find a %(type)s record for %(hrn)s" % locals()
465 # the gid of the user who will be delegated too
466 record = SfaRecord(dict=records[0])
467 delegee_gid = record.get_gid_object()
468 delegee_hrn = delegee_gid.get_hrn()
470 # the key and hrn of the user who will be delegating
471 user_key = Keypair(filename = self.get_key_file())
472 user_hrn = user_cred.get_gid_caller().get_hrn()
474 dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
475 dcred.set_gid_caller(delegee_gid)
476 dcred.set_gid_object(object_gid)
477 dcred.set_privileges(user_cred.get_privileges())
478 dcred.set_delegate(True)
479 dcred.set_pubkey(object_gid.get_pubkey())
480 dcred.set_issuer(user_key, user_hrn)
481 dcred.set_parent(user_cred)
485 return dcred.save_to_string(save_parents=True)
487 def get_rspec_file(self,rspec):
488 if (os.path.isabs(rspec)):
491 file = os.path.join(self.options.sfi_dir, rspec)
492 if (os.path.isfile(file)):
495 print "No such rspec file", rspec
498 def get_record_file(self,record):
499 if (os.path.isabs(record)):
502 file = os.path.join(self.options.sfi_dir, record)
503 if (os.path.isfile(file)):
506 print "No such registry record file", record
509 def load_publickey_string(self,fn):
511 key_string = f.read()
513 # if the filename is a private key file, then extract the public key
514 if "PRIVATE KEY" in key_string:
515 outfn = tempfile.mktemp()
516 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
519 key_string = f.read()
524 def get_component_server_from_hrn(self, hrn):
525 # direct connection to the nodes component manager interface
526 user_cred = self.get_user_cred().save_to_string(save_parents=True)
527 records = self.registry.resolve(user_cred, hrn)
528 records = filter_records('node', records)
530 print "No such component:", opts.component
533 url = "https://%s:%s" % (record['hostname'], cm_port)
534 return xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
537 # Following functions implement the commands
539 # Registry-related commands
542 def dispatch(self,command, cmd_opts, cmd_args):
543 getattr(self,command)(cmd_opts, cmd_args)
545 def gid(self, opts, args):
547 print "GID: %s" % (gid.save_to_string(save_parents=True))
550 # list entires in named authority registry
551 def list(self,opts, args):
552 user_cred = self.get_user_cred().save_to_string(save_parents=True)
555 list = self.registry.list(user_cred, hrn)
557 raise Exception, "Not enough parameters for the 'list' command"
559 # filter on person, slice, site, node, etc.
560 # THis really should be in the self.filter_records funct def comment...
561 list = filter_records(opts.type, list)
563 print "%s (%s)" % (record['hrn'], record['type'])
566 if not file.startswith(os.sep):
567 file = os.path.join(self.options.sfi_dir, file)
568 save_records_to_file(file, list)
571 # show named registry record
572 def show(self,opts, args):
573 user_cred = self.get_user_cred().save_to_string(save_parents=True)
575 records = self.registry.resolve(user_cred, hrn)
576 records = filter_records(opts.type, records)
578 print "No record of type", opts.type
579 for record in records:
580 if record['type'] in ['user']:
581 record = UserRecord(dict = record)
582 elif record['type'] in ['slice']:
583 record = SliceRecord(dict = record)
584 elif record['type'] in ['node']:
585 record = NodeRecord(dict = record)
586 elif record['type'] in ['authority', 'ma', 'sa']:
587 record = AuthorityRecord(dict = record)
589 record = SfaRecord(dict = record)
590 if (opts.format=="text"):
593 print record.save_to_string()
597 if not file.startswith(os.sep):
598 file = os.path.join(self.options.sfi_dir, file)
599 save_records_to_file(file, records)
602 def delegate(self,opts, args):
603 user_cred = self.get_user_cred()
604 if opts.delegate_user:
605 object_cred = user_cred
606 elif opts.delegate_slice:
607 object_cred = self.get_slice_cred(opts.delegate_slice)
609 print "Must specify either --user or --slice <hrn>"
612 # the gid and hrn of the object we are delegating
613 object_gid = object_cred.get_gid_object()
614 object_hrn = object_gid.get_hrn()
616 if not object_cred.get_delegate():
617 print "Error: Object credential", object_hrn, "does not have delegate bit set"
620 records = self.registry.resolve(user_cred, args[0])
621 records = filter_records("user", records)
624 print "Error: Didn't find a user record for", args[0]
627 # the gid of the user who will be delegated to
628 delegee_gid = records[0].get_gid_object()
629 delegee_hrn = delegee_gid.get_hrn()
631 # the key and hrn of the user who will be delegating
632 user_key = Keypair(filename = self.get_key_file())
633 user_hrn = user_cred.get_gid_caller().get_hrn()
635 dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
636 dcred.set_gid_caller(delegee_gid)
637 dcred.set_gid_object(object_gid)
638 dcred.set_privileges(object_cred.get_privileges())
639 dcred.set_delegate(True)
640 dcred.set_pubkey(object_gid.get_pubkey())
641 dcred.set_issuer(user_key, user_hrn)
642 dcred.set_parent(object_cred)
646 if opts.delegate_user:
647 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
648 + get_leaf(object_hrn) + ".cred")
649 elif opts.delegate_slice:
650 dest_fn = os.path_join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
651 + get_leaf(object_hrn) + ".cred")
653 dcred.save_to_file(dest_fn, save_parents = True)
655 print "delegated credential for", object_hrn, "to", delegee_hrn, "and wrote to", dest_fn
657 # removed named registry record
658 # - have to first retrieve the record to be removed
659 def remove(self,opts, args):
660 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
665 return self.registry.remove(auth_cred, type, hrn)
667 # add named registry record
668 def add(self,opts, args):
669 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
670 record_filepath = args[0]
671 rec_file = self.get_record_file(record_filepath)
672 record = load_record_from_file(rec_file).as_dict()
673 return self.registry.register(auth_cred, record)
675 # update named registry entry
676 def update(self,opts, args):
677 user_cred = self.get_user_cred()
678 rec_file = self.get_record_file(args[0])
679 record = load_record_from_file(rec_file)
680 if record['type'] == "user":
681 if record.get_name() == user_cred.get_gid_object().get_hrn():
682 cred = user_cred.save_to_string(save_parents=True)
684 cred = self.get_auth_cred().save_to_string(save_parents=True)
685 elif record['type'] in ["slice"]:
687 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
688 except ServerException, e:
689 # XXX smbaker -- once we have better error return codes, update this
690 # to do something better than a string compare
691 if "Permission error" in e.args[0]:
692 cred = self.get_auth_cred().save_to_string(save_parents=True)
695 elif record.get_type() in ["authority"]:
696 cred = self.get_auth_cred().save_to_string(save_parents=True)
697 elif record.get_type() == 'node':
698 cred = self.get_auth_cred().save_to_string(save_parents=True)
700 raise "unknown record type" + record.get_type()
701 record = record.as_dict()
702 return self.registry.update(cred, record)
704 def get_trusted_certs(self, opts, args):
706 return the trusted certs at this interface
708 trusted_certs = self.registry.get_trusted_certs()
709 for trusted_cert in trusted_certs:
710 cert = Certificate(string=trusted_cert)
711 print cert.get_subject()
714 def aggregates(self, opts, args):
716 return a list of details about known aggregates
718 user_cred = self.get_user_cred().save_to_string(save_parents=True)
722 result = self.registry.get_aggregates(user_cred, hrn)
726 def registries(self, opts, args):
728 return a list of details about known registries
730 user_cred = self.get_user_cred().save_to_string(save_parents=True)
734 result = self.registry.get_registries(user_cred, hrn)
740 # Slice-related commands
743 # list available nodes -- use 'resources' w/ no argument instead
745 # list instantiated slices
746 def slices(self,opts, args):
747 user_cred = self.get_user_cred().save_to_string(save_parents=True)
748 server = self.slicemgr
749 # direct connection to the nodes component manager interface
751 server = self.get_component_server_from_hrn(opts.component)
752 results = server.get_slices(user_cred)
753 display_list(results)
756 # show rspec for named slice
757 def resources(self,opts, args):
758 user_cred = self.get_user_cred().save_to_string(save_parents=True)
759 server = self.slicemgr
761 agg_hrn = opts.aggregate
762 aggregates = self.registry.get_aggregates(user_cred, agg_hrn)
764 raise Exception, "No such aggregate %s" % agg_hrn
765 aggregate = aggregates[0]
766 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
767 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
769 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
775 result = server.get_resources(cred, hrn)
778 display_rspec(result, format)
779 if (opts.file is not None):
781 if not file.startswith(os.sep):
782 file = os.path.join(self.options.sfi_dir, file)
783 save_rspec_to_file(result, file)
786 # created named slice with given rspec
787 def create(self,opts, args):
789 user_cred = self.get_user_cred()
790 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
791 rspec_file = self.get_rspec_file(args[1])
792 rspec=open(rspec_file).read()
793 server = self.slicemgr
795 aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
797 raise Exception, "No such aggregate %s" % opts.aggregate
798 aggregate = aggregates[0]
799 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
800 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.protocol)
801 return server.create_slice(slice_cred, slice_hrn, rspec)
803 # get a ticket for the specified slice
804 def get_ticket(self, opts, args):
805 slice_hrn, rspec_path = args[0], args[1]
806 user_cred = self.get_user_cred()
807 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
808 rspec_file = self.get_rspec_file(rspec_path)
809 rspec=open(rspec_file).read()
810 server = self.slicemgr
812 aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
814 raise Exception, "No such aggregate %s" % opts.aggregate
815 aggregate = aggregates[0]
816 url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
817 server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file, self.options.protocol)
818 ticket_string = server.get_ticket(slice_cred, slice_hrn, rspec)
819 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
820 print "writing ticket to ", file
821 ticket = SfaTicket(string=ticket_string)
822 ticket.save_to_file(filename=file, save_parents=True)
824 def redeem_ticket(self, opts, args):
825 ticket_file = args[0]
827 # get slice hrn from the ticket
828 # use this to get the right slice credential
829 ticket = SfaTicket(filename=ticket_file)
831 slice_hrn=ticket.gidObject.get_hrn()
832 #slice_hrn = ticket.attributes['slivers'][0]['hrn']
833 user_cred = self.get_user_cred()
834 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
836 # get a list node hostnames from the nodespecs in the rspec
838 rspec.parseString(ticket.rspec)
839 nodespecs = rspec.getDictsByTagName('NodeSpec')
840 hostnames = [nodespec['name'] for nodespec in nodespecs]
842 # create an xmlrpc connection to the component manager at each of these
843 # components and gall redeem_ticket
845 for hostname in hostnames:
848 url = "https://%(hostname)s:%(cm_port)s" % locals()
849 print "Calling redeem_ticket at %(url)s " % locals(),
850 cm = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
851 cm.redeem_ticket(slice_cred, ticket.save_to_string(save_parents=True))
853 except socket.gaierror:
855 print "Componet Manager not accepting requests"
857 print "Failed:", e.message
862 def delete(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(slice_hrn).save_to_string(save_parents=True)
870 return server.delete_slice(slice_cred, slice_hrn)
873 def start(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)
880 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
881 return server.start_slice(slice_cred, slice_hrn)
884 def stop(self,opts, args):
886 server = self.slicemgr
887 # direct connection to the nodes component manager interface
889 server = self.get_component_server_from_hrn(opts.component)
891 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
892 return server.stop_slice(slice_cred, slice_hrn)
895 def reset(self,opts, args):
897 server = self.slicemgr
898 # direct connection to the nodes component manager interface
900 server = self.get_component_server_from_hrn(opts.component)
901 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
902 return server.reset_slice(slice_cred, slice_hrn)
905 # GENI AM related calls
907 def GetVersion(self,opts,args):
908 server = self.geni_am
909 print server.GetVersion()
911 def ListResources(self,opts,args):
912 user_cred = self.get_user_cred().save_to_string(save_parents=True)
913 server = self.geni_am
914 call_options = {'geni_compressed': True}
919 cred = self.get_slice_cred(xrn).save_to_string(save_parents=True)
922 call_options['geni_slice_urn'] = xrn
924 rspec = server.ListResources([user_cred], call_options)
925 rspec = zlib.decompress(rspec.decode('base64'))
928 def CreateSliver(self,opts,args):
930 user_cred = self.get_user_cred()
931 slice_cred = self.get_slice_cred(slice_xrn).save_to_string(save_parents=True)
932 rspec_file = self.get_rspec_file(args[1])
933 rspec = open(rspec_file).read()
934 server = self.geni_am
935 return server.CreateSliver(slice_xrn, [slice_cred], rspec)
937 # Main: parse arguments and dispatch to command
940 parser = self.create_parser()
941 (options, args) = parser.parse_args()
942 self.options = options
944 if options.hashrequest:
945 self.hashrequest=True
948 print "No command given. Use -h for help."
952 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
953 if self.options.verbose :
954 print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm,
955 options.sfi_dir, options.user,
957 print "Command %s" %command
958 if command in ("resources"):
959 print "resources cmd_opts %s" %cmd_opts.format
960 elif command in ("list","show","remove"):
961 print "cmd_opts.type %s" %cmd_opts.type
962 print "cmd_args %s" %cmd_args
967 self.dispatch(command, cmd_opts, cmd_args)
970 print "Command not found:", command
975 if __name__=="__main__":