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