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 = 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 gid of the user who will be delegated to
616 delegee_gid = self._get_gid(hrn)
617 delegee_hrn = delegee_gid.get_hrn()
618 delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid")
619 delegee_gid.save_to_file(filename=delegee_gidfile)
620 dcred = object_cred.delegate(delegee_gidfile, self.get_key_file())
621 return dcred.save_to_string(save_parents=True)
623 # removed named registry record
624 # - have to first retrieve the record to be removed
625 def remove(self, opts, args):
626 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
631 return self.registry.Remove(hrn, auth_cred, type)
633 # add named registry record
634 def add(self, opts, args):
635 auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
636 record_filepath = args[0]
637 rec_file = self.get_record_file(record_filepath)
638 record = load_record_from_file(rec_file).as_dict()
639 return self.registry.Register(record, auth_cred)
641 # update named registry entry
642 def update(self, opts, args):
643 user_cred = self.get_user_cred()
644 rec_file = self.get_record_file(args[0])
645 record = load_record_from_file(rec_file)
646 if record['type'] == "user":
647 if record.get_name() == user_cred.get_gid_object().get_hrn():
648 cred = user_cred.save_to_string(save_parents=True)
650 cred = self.get_auth_cred().save_to_string(save_parents=True)
651 elif record['type'] in ["slice"]:
653 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
654 except ServerException, e:
655 # XXX smbaker -- once we have better error return codes, update this
656 # to do something better than a string compare
657 if "Permission error" in e.args[0]:
658 cred = self.get_auth_cred().save_to_string(save_parents=True)
661 elif record.get_type() in ["authority"]:
662 cred = self.get_auth_cred().save_to_string(save_parents=True)
663 elif record.get_type() == 'node':
664 cred = self.get_auth_cred().save_to_string(save_parents=True)
666 raise "unknown record type" + record.get_type()
667 record = record.as_dict()
668 return self.registry.Update(record, cred)
670 def get_trusted_certs(self, opts, args):
672 return uhe trusted certs at this interface
674 trusted_certs = self.registry.get_trusted_certs()
675 for trusted_cert in trusted_certs:
676 cert = Certificate(string=trusted_cert)
677 print cert.get_subject()
680 def aggregates(self, opts, args):
682 return a list of details about known aggregates
684 user_cred = self.get_user_cred().save_to_string(save_parents=True)
689 result = self.registry.get_aggregates(user_cred, hrn)
693 def registries(self, opts, args):
695 return a list of details about known registries
697 user_cred = self.get_user_cred().save_to_string(save_parents=True)
701 result = self.registry.get_registries(user_cred, hrn)
706 # ==================================================================
707 # Slice-related commands
708 # ==================================================================
711 def version(self, opts, args):
712 server = self.get_server_from_opts(opts)
714 print server.GetVersion()
716 # list instantiated slices
717 def slices(self, opts, args):
719 list instantiated slices
721 user_cred = self.get_user_cred().save_to_string(save_parents=True)
722 server = self.get_server_from_opts(opts)
723 results = server.ListSlices([user_cred])
724 display_list(results)
727 # show rspec for named slice
728 def resources(self, opts, args):
729 user_cred = self.get_user_cred().save_to_string(save_parents=True)
730 server = self.slicemgr
732 server = self.get_server_from_opts(opts)
735 cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
737 call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')}
742 delegated_cred = self.delegate_cred(cred, self.authority)
743 creds = [cred, delegated_cred]
744 result = server.ListResources(creds, call_options)
746 display_rspec(result, format)
747 if (opts.file is not None):
749 if not file.startswith(os.sep):
750 file = os.path.join(self.options.sfi_dir, file)
751 save_rspec_to_file(result, file)
754 # created named slice with given rspec
755 def create(self, opts, args):
757 slice_urn = hrn_to_urn(slice_hrn, 'slice')
758 user_cred = self.get_user_cred()
759 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
760 rspec_file = self.get_rspec_file(args[1])
761 rspec = open(rspec_file).read()
762 server = self.get_server_from_opts(opts)
763 result = server.CreateSliver(slice_urn, [slice_cred], rspec, [])
767 # get a ticket for the specified slice
768 def get_ticket(self, opts, args):
769 slice_hrn, rspec_path = args[0], args[1]
770 slice_urn = hrn_to_urn(slice_hrn, 'slice')
771 user_cred = self.get_user_cred()
772 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
773 rspec_file = self.get_rspec_file(rspec_path)
774 rspec = open(rspec_file).read()
775 server = self.get_server_from_opts(opts)
776 ticket_string = server.GetTicket(slice_urn, [slice_cred], rspec, [])
777 file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
778 print "writing ticket to ", file
779 ticket = SfaTicket(string=ticket_string)
780 ticket.save_to_file(filename=file, save_parents=True)
782 def redeem_ticket(self, opts, args):
783 ticket_file = args[0]
785 # get slice hrn from the ticket
786 # use this to get the right slice credential
787 ticket = SfaTicket(filename=ticket_file)
789 slice_hrn = ticket.gidObject.get_hrn()
790 slice_urn = hrn_to_urn(slice_hrn, 'slice')
791 #slice_hrn = ticket.attributes['slivers'][0]['hrn']
792 user_cred = self.get_user_cred()
793 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
795 # get a list of node hostnames from the RSpec
796 tree = etree.parse(StringIO(ticket.rspec))
797 root = tree.getroot()
798 hostnames = root.xpath("./network/site/node/hostname/text()")
800 # create an xmlrpc connection to the component manager at each of these
801 # components and gall redeem_ticket
803 for hostname in hostnames:
805 print "Calling redeem_ticket at %(hostname)s " % locals(),
806 server = self.get_server(hostname, CM_PORT, self.key_file, \
807 self.cert_file, self.options.debug)
808 server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred)
810 except socket.gaierror:
812 print "Componet Manager not accepting requests"
814 print "Failed:", e.message
818 def delete(self, opts, args):
820 slice_urn = hrn_to_urn(slice_hrn, 'slice')
821 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
822 server = self.get_server_from_opts(opts)
823 return server.DeleteSliver(slice_urn, [slice_cred])
826 def start(self, opts, args):
828 slice_urn = hrn_to_urn(slice_hrn, 'slice')
829 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
830 server = self.get_server_from_opts(opts)
831 return server.Start(slice_urn, [slice_cred])
834 def stop(self, opts, args):
836 slice_urn = hrn_to_urn(slice_hrn, 'slice')
837 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
838 server = self.get_server_from_opts(opts)
839 return server.Stop(slice_urn, [slice_cred])
842 def reset(self, opts, args):
844 slice_urn = hrn_to_urn(slice_hrn, 'slice')
845 server = self.get_server_from_opts(opts)
846 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
847 return server.reset_slice(slice_cred, slice_urn)
849 def renew(self, opts, args):
851 slice_urn = hrn_to_urn(slice_hrn, 'slice')
852 server = self.get_server_from_opts(opts)
853 slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
855 return server.RenewSliver(slice_urn, [slice_cred], time)
858 def status(self, opts, args):
860 slice_urn = hrn_to_urn(slice_hrn, 'slice')
861 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
862 server = self.get_server_from_opts(opts)
863 print server.SliverStatus(slice_urn, [slice_cred])
866 def shutdown(self, opts, args):
868 slice_urn = hrn_to_urn(slice_hrn, 'slice')
869 slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
870 server = self.get_server_from_opts(opts)
871 return server.Shutdown(slice_urn, [slice_cred])
874 # Main: parse arguments and dispatch to command
877 parser = self.create_parser()
878 (options, args) = parser.parse_args()
879 self.options = options
881 if options.hashrequest:
882 self.hashrequest = True
885 print "No command given. Use -h for help."
889 (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
890 if self.options.verbose :
891 print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm,
892 options.sfi_dir, options.user,
894 print "Command %s" % command
895 if command in ("resources"):
896 print "resources cmd_opts %s" % cmd_opts.format
897 elif command in ("list", "show", "remove"):
898 print "cmd_opts.type %s" % cmd_opts.type
899 print "cmd_args %s" % cmd_args
904 self.dispatch(command, cmd_opts, cmd_args)
907 print "Command not found:", command
912 if __name__ == "__main__":