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
17 from sfa.trust.certificate import Keypair, Certificate
18 from sfa.trust.credential import Credential
19 from sfa.util.sfaticket import SfaTicket
20 from sfa.util.record import *
21 from sfa.util.namespace import *
22 from sfa.util.xmlrpcprotocol import ServerException
23 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
24 from sfa.util.config import Config
30 # utility methods here
32 def display_rspec(rspec, format='rspec'):
34 tree = etree.parse(StringIO(rspec))
36 result = root.xpath("./network/site/node/hostname/text()")
37 elif format in ['ip']:
38 # The IP address is not yet part of the new RSpec
39 # so this doesn't do anything yet.
40 tree = etree.parse(StringIO(rspec))
42 result = root.xpath("./network/site/node/ipv4/text()")
49 def display_list(results):
50 for result in results:
53 def display_records(recordList, dump=False):
54 ''' Print all fields in the record'''
55 for record in recordList:
56 display_record(record, dump)
58 def display_record(record, dump=False):
62 info = record.getdict()
63 print "%s (%s)" % (info['hrn'], info['type'])
67 def filter_records(type, records):
69 for record in records:
70 if (record['type'] == type) or (type == "all"):
71 filtered_records.append(record)
72 return filtered_records
76 def save_rspec_to_file(rspec, filename):
77 if not filename.endswith(".rspec"):
78 filename = filename + ".rspec"
80 f = open(filename, 'w')
85 def save_records_to_file(filename, recordList):
87 for record in recordList:
89 save_record_to_file(filename + "." + str(index), record)
91 save_record_to_file(filename, record)
94 def save_record_to_file(filename, record):
95 if record['type'] in ['user']:
96 record = UserRecord(dict=record)
97 elif record['type'] in ['slice']:
98 record = SliceRecord(dict=record)
99 elif record['type'] in ['node']:
100 record = NodeRecord(dict=record)
101 elif record['type'] in ['authority', 'ma', 'sa']:
102 record = AuthorityRecord(dict=record)
104 record = SfaRecord(dict=record)
105 str = record.save_to_string()
106 file(filename, "w").write(str)
111 def load_record_from_file(filename):
112 str = file(filename, "r").read()
113 record = SfaRecord(string=str)
127 def create_cmd_parser(self, command, additional_cmdargs=None):
128 cmdargs = {"list": "name",
133 "aggregates": "[name]",
134 "registries": "[name]",
136 "get_trusted_certs": "cred",
138 "resources": "[name]",
139 "create": "name rspec",
140 "get_ticket": "name rspec",
141 "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 # user specifies remote aggregate/sm/component
168 if command in ("resources", "slices", "create", "delete", "start", "stop", "restart", "get_ticket", "redeem_ticket"):
169 parser.add_option("-a", "--aggregate", dest="aggregate",
170 default=None, help="aggregate host")
171 parser.add_option("-p", "--port", dest="port",
172 default=AGGREGATE_PORT, help="aggregate port")
173 parser.add_option("-c", "--component", dest="component", default=None,
174 help="component hrn")
176 # registy filter option
177 if command in ("list", "show", "remove"):
178 parser.add_option("-t", "--type", dest="type", type="choice",
179 help="type filter ([all]|user|slice|authority|node|aggregate)",
180 choices=("all", "user", "slice", "authority", "node", "aggregate"),
183 if command in ("resources"):
184 parser.add_option("-f", "--format", dest="format", type="choice",
185 help="display format ([xml]|dns|ip)", default="xml",
186 choices=("xml", "dns", "ip"))
188 if command in ("resources", "show", "list"):
189 parser.add_option("-o", "--output", dest="file",
190 help="output XML to file", metavar="FILE", default=None)
192 if command in ("show", "list"):
193 parser.add_option("-f", "--format", dest="format", type="choice",
194 help="display format ([text]|xml)", default="text",
195 choices=("text", "xml"))
197 if command in ("delegate"):
198 parser.add_option("-u", "--user",
199 action="store_true", dest="delegate_user", default=False,
200 help="delegate user credential")
201 parser.add_option("-s", "--slice", dest="delegate_slice",
202 help="delegate slice credential", metavar="HRN", default=None)
207 def create_parser(self):
209 # Generate command line parser
210 parser = OptionParser(usage="sfi [options] command [command_options] [command_args]",
211 description="Commands: gid,list,show,remove,add,update,nodes,slices,resources,create,delete,start,stop,reset")
212 parser.add_option("-r", "--registry", dest="registry",
213 help="root registry", metavar="URL", default=None)
214 parser.add_option("-s", "--slicemgr", dest="sm",
215 help="slice manager", metavar="URL", default=None)
216 default_sfi_dir = os.path.expanduser("~/.sfi/")
217 parser.add_option("-d", "--dir", dest="sfi_dir",
218 help="config & working directory - default is " + default_sfi_dir,
219 metavar="PATH", default=default_sfi_dir)
220 parser.add_option("-u", "--user", dest="user",
221 help="user name", metavar="HRN", default=None)
222 parser.add_option("-a", "--auth", dest="auth",
223 help="authority name", metavar="HRN", default=None)
224 parser.add_option("-v", "--verbose",
225 action="store_true", dest="verbose", default=False,
227 parser.add_option("-D", "--debug",
228 action="store_true", dest="debug", default=False,
229 help="Debug (xml-rpc) protocol messages")
230 parser.add_option("-p", "--protocol",
231 dest="protocol", default="xmlrpc",
232 help="RPC protocol (xmlrpc or soap)")
233 parser.add_option("-k", "--hashrequest",
234 action="store_true", dest="hashrequest", default=False,
235 help="Create a hash of the request that will be authenticated on the server")
236 parser.disable_interspersed_args()
242 # Establish Connection to SliceMgr and Registry Servers
244 def set_servers(self):
245 config_file = self.options.sfi_dir + os.sep + "sfi_config"
247 config = Config (config_file)
249 print "Failed to read configuration file", config_file
250 print "Make sure to remove the export clauses and to add quotes"
251 if not self.options.verbose:
252 print "Re-run with -v for more details"
254 traceback.print_exc()
259 if (self.options.sm is not None):
260 sm_url = self.options.sm
261 elif hasattr(config, "SFI_SM"):
262 sm_url = config.SFI_SM
264 print "You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s" % config_file
268 if (self.options.registry is not None):
269 reg_url = self.options.registry
270 elif hasattr(config, "SFI_REGISTRY"):
271 reg_url = config.SFI_REGISTRY
273 print "You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s" % config_file
278 if (self.options.user is not None):
279 self.user = self.options.user
280 elif hasattr(config, "SFI_USER"):
281 self.user = config.SFI_USER
283 print "You need to set e.g. SFI_USER='plc.princeton.username' in %s" % config_file
287 if (self.options.auth is not None):
288 self.authority = self.options.auth
289 elif hasattr(config, "SFI_AUTH"):
290 self.authority = config.SFI_AUTH
292 print "You need to set e.g. SFI_AUTH='plc.princeton' in %s" % config_file
298 if self.options.verbose :
299 print "Contacting Slice Manager at:", sm_url
300 print "Contacting Registry at:", reg_url
302 # Get key and certificate
303 key_file = self.get_key_file()
304 cert_file = self.get_cert_file(key_file)
305 self.key = Keypair(filename=key_file)
306 self.key_file = key_file
307 self.cert_file = cert_file
308 self.cert = Certificate(filename=cert_file)
309 # Establish connection to server(s)
310 self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file, self.options.debug)
311 self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file, self.options.debug)
316 # Get various credential and spec files
318 # Establishes limiting conventions
319 # - conflates MAs and SAs
320 # - assumes last token in slice name is unique
322 # Bootstraps credentials
323 # - bootstrap user credential from self-signed certificate
324 # - bootstrap authority credential from user credential
325 # - bootstrap slice credential from user credential
329 def get_key_file(self):
330 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey")
331 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
332 if (os.path.isfile(file)):
335 print "Key file", file, "does not exist"
339 def get_cert_file(self, key_file):
341 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
342 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert")
343 if (os.path.isfile(file)):
346 k = Keypair(filename=key_file)
347 cert = Certificate(subject=self.user)
349 cert.set_issuer(k, self.user)
351 if self.options.verbose :
352 print "Writing self-signed certificate to", file
353 cert.save_to_file(file)
356 def get_cached_gid(self, file):
361 if (os.path.isfile(file)):
362 gid = GID(filename=file)
365 def get_gid(self, opts, args):
369 gid = self._get_gid(hrn)
370 print gid.save_to_string(save_parents=True)
373 def _get_gid(self, hrn=None):
377 gidfile = os.path.join(self.options.sfi_dir, hrn + ".gid")
378 gid = self.get_cached_gid(gidfile)
380 user_cred = self.get_user_cred()
381 records = self.registry.Resolve(hrn, user_cred.save_to_string(save_parents=True))
383 raise RecordNotFound(args[0])
384 gid = GID(string=records[0]['gid'])
385 if self.options.verbose:
386 print "Writing gid to ", gidfile
387 gid.save_to_file(filename=gidfile)
391 def get_cached_credential(self, file):
393 Return a cached credential only if it hasn't expired.
395 if (os.path.isfile(file)):
396 credential = Credential(filename=file)
397 # make sure it isnt expired
398 if not credential.get_lifetime or \
399 datetime.datetime.today() < credential.get_lifetime():
403 def get_user_cred(self):
404 #file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
405 file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred")
406 return self.get_cred(file, 'user', self.user)
408 def get_auth_cred(self):
409 if not self.authority:
410 print "no authority specified. Use -a or set SF_AUTH"
412 file = os.path.join(self.options.sfi_dir, get_leaf("authority") + ".cred")
413 return self.get_cred(file, 'authority', self.authority)
415 def get_slice_cred(self, name):
416 file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
417 return self.get_cred(file, 'slice', name)
419 def get_cred(self, file, type, hrn):
420 # attempt to load a cached credential
421 cred = self.get_cached_credential(file)
424 cert_string = self.cert.save_to_string(save_parents=True)
425 user_name = self.user.replace(self.authority + ".", '')
426 if user_name.count(".") > 0:
427 user_name = user_name.replace(".", '_')
428 self.user = self.authority + "." + user_name
429 cred_str = self.registry.get_self_credential(cert_string, "user", hrn)
431 # bootstrap slice credential from user credential
432 user_cred = self.get_user_cred().save_to_string(save_parents=True)
433 cred_str = self.registry.get_credential(user_cred, type, hrn)
436 print "Failed to get %s credential" % (type)
439 cred = Credential(string=cred_str)
440 cred.save_to_file(file, save_parents=True)
441 if self.options.verbose:
442 print "Writing %s credential to %s" %(type, file)
447 def get_rspec_file(self, rspec):
448 if (os.path.isabs(rspec)):
451 file = os.path.join(self.options.sfi_dir, rspec)
452 if (os.path.isfile(file)):
455 print "No such rspec file", rspec
458 def get_record_file(self, record):
459 if (os.path.isabs(record)):
462 file = os.path.join(self.options.sfi_dir, record)
463 if (os.path.isfile(file)):
466 print "No such registry record file", record
469 def load_publickey_string(self, fn):
471 key_string = f.read()
473 # if the filename is a private key file, then extract the public key
474 if "PRIVATE KEY" in key_string:
475 outfn = tempfile.mktemp()
476 cmd = "openssl rsa -in " + fn + " -pubout -outform PEM -out " + outfn
479 key_string = f.read()
484 def get_component_server_from_hrn(self, hrn):
485 # direct connection to the nodes component manager interface
486 user_cred = self.get_user_cred().save_to_string(save_parents=True)
487 records = self.registry.Resolve(hrn, user_cred)
488 records = filter_records('node', records)
490 print "No such component:", opts.component
493 return self.get_server(record['hostname'], CM_PORT, self.key_file, \
494 self.cert_file, self.options.debug)
496 def get_server(self, host, port, keyfile, certfile, debug):
498 Return an instnace of an xmlrpc server connection
500 url = "http://%s:%s" % (host, port)
501 return xmlrpcprotocol.get_server(url, keyfile, certfile, debug)
503 def get_server_from_opts(self, opts):
505 Return instance of an xmlrpc connection to a slice manager, aggregate
506 or component server depending on the specified opts
508 server = self.slicemgr
509 # direct connection to an aggregate
510 if hasattr(opts, 'aggregate') and opts.aggregate:
511 server = self.get_server(opts.aggregate, opts.port, self.key_file, \
512 self.cert_file, self.options.debug)
513 # direct connection to the nodes component manager interface
514 if hasattr(opts, 'component') and opts.component:
515 server = self.get_component_server_from_hrn(opts.component)
518 #==========================================================================
519 # Following functions implement the commands
521 # Registry-related commands
522 #==========================================================================
524 def dispatch(self, command, cmd_opts, cmd_args):
525 getattr(self, command)(cmd_opts, cmd_args)
527 # list entires in named authority registry
528 def list(self, opts, args):
529 user_cred = self.get_user_cred().save_to_string(save_parents=True)
532 list = self.registry.List(hrn, user_cred)
534 raise Exception, "Not enough parameters for the 'list' command"
536 # filter on person, slice, site, node, etc.
537 # THis really should be in the self.filter_records funct def comment...
538 list = filter_records(opts.type, list)
540 print "%s (%s)" % (record['hrn'], record['type'])
543 if not file.startswith(os.sep):
544 file = os.path.join(self.options.sfi_dir, file)
545 save_records_to_file(file, list)
548 # show named registry record
549 def show(self, opts, args):
550 user_cred = self.get_user_cred().save_to_string(save_parents=True)
552 records = self.registry.Resolve(hrn, user_cred)
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 = SfaRecord(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):
581 delegee_hrn = args[0]
582 if opts.delegate_user:
583 user_cred = self.get_user_cred()
584 cred = self.delegate_cred(user_cred, delegee_hrn)
585 elif opts.delegate_slice:
586 slice_cred = self.get_slice_cred(opts.delegate_slice)
587 cred = self.delegate_cred(slice_cred, delegee_hrn)
589 print "Must specify either --user or --slice <hrn>"
591 delegated_cred = Credential(string=cred)
592 object_hrn = delegated_cred.get_gid_object().get_hrn()
593 if opts.delegate_user:
594 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
595 + get_leaf(object_hrn) + ".cred")
596 elif opts.delegate_slice:
597 dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
598 + get_leaf(object_hrn) + ".cred")
600 delegated_cred.save_to_file(dest_fn, save_parents=True)
602 print "delegated credential for", object_hrn, "to", delegee_hrn, "and wrote to", dest_fn
604 def delegate_cred(self, object_cred, hrn):
605 # the gid and hrn of the object we are delegating
606 if isinstance(object_cred, str):
607 object_cred = Credential(string=object_cred)
608 object_gid = object_cred.get_gid_object()
609 object_hrn = object_gid.get_hrn()
611 if not object_cred.get_privileges().get_all_delegate():
612 print "Error: Object credential", object_hrn, "does not have delegate bit set"
615 # the delegating user's gid
616 caller_gid = self._get_gid(self.user)
617 caller_gidfile = os.path.join(self.options.sfi_dir, self.user + ".gid")
619 # the gid of the user who will be delegated to
620 delegee_gid = self._get_gid(hrn)
621 delegee_hrn = delegee_gid.get_hrn()
622 delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid")
623 delegee_gid.save_to_file(filename=delegee_gidfile)
624 dcred = object_cred.delegate(delegee_gidfile, self.get_key_file(), caller_gidfile)
625 return dcred.save_to_string(save_parents=True)
627 # removed named registry record
628 # - have to first retrieve the record to be removed
629 def remove(self, opts, args):
630 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
635 return self.registry.Remove(hrn, auth_cred, type)
637 # add named registry record
638 def add(self, opts, args):
639 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
640 record_filepath = args[0]
641 rec_file = self.get_record_file(record_filepath)
642 record = load_record_from_file(rec_file).as_dict()
643 return self.registry.Register(record, auth_cred)
645 # update named registry entry
646 def update(self, opts, args):
647 user_cred = self.get_user_cred()
648 rec_file = self.get_record_file(args[0])
649 record = load_record_from_file(rec_file)
650 if record['type'] == "user":
651 if record.get_name() == user_cred.get_gid_object().get_hrn():
652 cred = user_cred.save_to_string(save_parents=True)
654 cred = self.get_auth_cred().save_to_string(save_parents=True)
655 elif record['type'] in ["slice"]:
657 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
658 except ServerException, e:
659 # XXX smbaker -- once we have better error return codes, update this
660 # to do something better than a string compare
661 if "Permission error" in e.args[0]:
662 cred = self.get_auth_cred().save_to_string(save_parents=True)
665 elif record.get_type() in ["authority"]:
666 cred = self.get_auth_cred().save_to_string(save_parents=True)
667 elif record.get_type() == 'node':
668 cred = self.get_auth_cred().save_to_string(save_parents=True)
670 raise "unknown record type" + record.get_type()
671 record = record.as_dict()
672 return self.registry.Update(record, cred)
674 def get_trusted_certs(self, opts, args):
676 return uhe trusted certs at this interface
678 trusted_certs = self.registry.get_trusted_certs()
679 for trusted_cert in trusted_certs:
680 cert = Certificate(string=trusted_cert)
681 print cert.get_subject()
684 def aggregates(self, opts, args):
686 return a list of details about known aggregates
688 user_cred = self.get_user_cred().save_to_string(save_parents=True)
693 result = self.registry.get_aggregates(user_cred, hrn)
697 def registries(self, opts, args):
699 return a list of details about known registries
701 user_cred = self.get_user_cred().save_to_string(save_parents=True)
705 result = self.registry.get_registries(user_cred, hrn)
710 # ==================================================================
711 # Slice-related commands
712 # ==================================================================
715 def version(self, opts, args):
716 server = self.get_server_from_opts(opts)
718 print server.GetVersion()
720 # list instantiated slices
721 def slices(self, opts, args):
723 list instantiated slices
725 user_cred = self.get_user_cred().save_to_string(save_parents=True)
726 server = self.get_server_from_opts(opts)
727 results = server.ListSlices([user_cred])
728 display_list(results)
731 # show rspec for named slice
732 def resources(self, opts, args):
733 user_cred = self.get_user_cred().save_to_string(save_parents=True)
734 server = self.slicemgr
736 server = self.get_server_from_opts(opts)
739 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
741 call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')}
746 delegated_cred = self.delegate_cred(cred, get_authority(self.authority))
747 creds = [cred, delegated_cred]
748 #creds = [delegated_cred]
749 result = server.ListResources(creds, call_options)
751 display_rspec(result, format)
752 if (opts.file is not None):
754 if not file.startswith(os.sep):
755 file = os.path.join(self.options.sfi_dir, file)
756 save_rspec_to_file(result, file)
759 # created named slice with given rspec
760 def create(self, opts, args):
762 slice_urn = hrn_to_urn(slice_hrn, 'slice')
763 user_cred = self.get_user_cred()
764 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
765 rspec_file = self.get_rspec_file(args[1])
766 rspec = open(rspec_file).read()
767 server = self.get_server_from_opts(opts)
768 result = server.CreateSliver(slice_urn, [slice_cred], rspec, [])
772 # get a ticket for the specified slice
773 def get_ticket(self, opts, args):
774 slice_hrn, rspec_path = args[0], args[1]
775 slice_urn = hrn_to_urn(slice_hrn, 'slice')
776 user_cred = self.get_user_cred()
777 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
778 rspec_file = self.get_rspec_file(rspec_path)
779 rspec = open(rspec_file).read()
780 server = self.get_server_from_opts(opts)
781 ticket_string = server.GetTicket(slice_urn, [slice_cred], rspec, [])
782 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
783 print "writing ticket to ", file
784 ticket = SfaTicket(string=ticket_string)
785 ticket.save_to_file(filename=file, save_parents=True)
787 def redeem_ticket(self, opts, args):
788 ticket_file = args[0]
790 # get slice hrn from the ticket
791 # use this to get the right slice credential
792 ticket = SfaTicket(filename=ticket_file)
794 slice_hrn = ticket.gidObject.get_hrn()
795 slice_urn = hrn_to_urn(slice_hrn, 'slice')
796 #slice_hrn = ticket.attributes['slivers'][0]['hrn']
797 user_cred = self.get_user_cred()
798 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
800 # get a list of node hostnames from the RSpec
801 tree = etree.parse(StringIO(ticket.rspec))
802 root = tree.getroot()
803 hostnames = root.xpath("./network/site/node/hostname/text()")
805 # create an xmlrpc connection to the component manager at each of these
806 # components and gall redeem_ticket
808 for hostname in hostnames:
810 print "Calling redeem_ticket at %(hostname)s " % locals(),
811 server = self.get_server(hostname, CM_PORT, self.key_file, \
812 self.cert_file, self.options.debug)
813 server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred)
815 except socket.gaierror:
817 print "Componet Manager not accepting requests"
819 print "Failed:", e.message
823 def delete(self, opts, args):
825 slice_urn = hrn_to_urn(slice_hrn, 'slice')
826 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
827 server = self.get_server_from_opts(opts)
828 return server.DeleteSliver(slice_urn, [slice_cred])
831 def start(self, opts, args):
833 slice_urn = hrn_to_urn(slice_hrn, 'slice')
834 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
835 server = self.get_server_from_opts(opts)
836 return server.Start(slice_urn, [slice_cred])
839 def stop(self, opts, args):
841 slice_urn = hrn_to_urn(slice_hrn, 'slice')
842 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
843 server = self.get_server_from_opts(opts)
844 return server.Stop(slice_urn, [slice_cred])
847 def reset(self, opts, args):
849 slice_urn = hrn_to_urn(slice_hrn, 'slice')
850 server = self.get_server_from_opts(opts)
851 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
852 return server.reset_slice(slice_cred, slice_urn)
854 def renew(self, opts, args):
856 slice_urn = hrn_to_urn(slice_hrn, 'slice')
857 server = self.get_server_from_opts(opts)
858 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
860 return server.RenewSliver(slice_urn, [slice_cred], time)
863 def status(self, opts, args):
865 slice_urn = hrn_to_urn(slice_hrn, 'slice')
866 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
867 server = self.get_server_from_opts(opts)
868 print server.SliverStatus(slice_urn, [slice_cred])
871 def shutdown(self, opts, args):
873 slice_urn = hrn_to_urn(slice_hrn, 'slice')
874 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
875 server = self.get_server_from_opts(opts)
876 return server.Shutdown(slice_urn, [slice_cred])
879 # Main: parse arguments and dispatch to command
882 parser = self.create_parser()
883 (options, args) = parser.parse_args()
884 self.options = options
886 if options.hashrequest:
887 self.hashrequest = True
890 print "No command given. Use -h for help."
894 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
895 if self.options.verbose :
896 print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm,
897 options.sfi_dir, options.user,
899 print "Command %s" % command
900 if command in ("resources"):
901 print "resources cmd_opts %s" % cmd_opts.format
902 elif command in ("list", "show", "remove"):
903 print "cmd_opts.type %s" % cmd_opts.type
904 print "cmd_args %s" % cmd_args
909 self.dispatch(command, cmd_opts, cmd_args)
912 print "Command not found:", command
917 if __name__ == "__main__":