X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Fclient%2Fsfi.py;h=5974a03bbd3584f2a153a021b3969ad8367e43ea;hb=5307e4e09dd0a7982f0c6dfdd13065425c802005;hp=ed884eaef87712147c1af4ea81659ffcbe0773ce;hpb=31a3999226eb16a573f961da4a6f133c77553723;p=sfa.git

diff --git a/sfa/client/sfi.py b/sfa/client/sfi.py
index ed884eae..5974a03b 100755
--- a/sfa/client/sfi.py
+++ b/sfa/client/sfi.py
@@ -3,47 +3,46 @@
 # sfi -- slice-based facility interface
 
 import sys
+sys.path.append('.')
 import os, os.path
 import tempfile
 import traceback
 import socket
+import random
+import datetime
+from lxml import etree
+from StringIO import StringIO
 from types import StringTypes, ListType
 from optparse import OptionParser
+import zlib
+
+from sfa.util.sfalogging import sfa_logger,sfa_logger_goes_to_console
 from sfa.trust.certificate import Keypair, Certificate
+from sfa.trust.gid import GID
 from sfa.trust.credential import Credential
-from sfa.util.geniclient import GeniClient
 from sfa.util.sfaticket import SfaTicket
-from sfa.util.record import *
-from sfa.util.misc import *
-from sfa.util.rspec import RSpec
-from sfa.util.xmlrpcprotocol import ServerException
+from sfa.util.record import SfaRecord, UserRecord, SliceRecord, NodeRecord, AuthorityRecord
+from sfa.util.xrn import Xrn, get_leaf, get_authority, hrn_to_urn
 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
 from sfa.util.config import Config
+from sfa.util.version import version_core
+
+AGGREGATE_PORT=12346
+CM_PORT=12346
 
 # utility methods here
 # display methods
-def display_rspec(rspec, format = 'rspec'):
+def display_rspec(rspec, format='rspec'):
     if format in ['dns']:
-        spec = RSpec()
-        spec.parseString(rspec)
-        hostnames = []
-        nodespecs = spec.getDictsByTagName('NodeSpec')
-        for nodespec in nodespecs:
-            if nodespec.has_key('name') and nodespec['name']:
-                if isinstance(nodespec['name'], ListType):
-                    hostnames.extend(nodespec['name'])
-                elif isinstance(nodespec['name'], StringTypes):
-                     hostnames.append(nodespec['name'])
-        result = hostnames
+        tree = etree.parse(StringIO(rspec))
+        root = tree.getroot()
+        result = root.xpath("./network/site/node/hostname/text()")
     elif format in ['ip']:
-        spec = RSpec()
-        spec.parseString(rspec)
-        ips = []
-        ifspecs = spec.getDictsByTagName('IfSpec')
-        for ifspec in ifspecs:
-            if ifspec.has_key('addr') and ifspec['addr']:
-                ips.append(ifspec['addr'])
-        result = ips
+        # The IP address is not yet part of the new RSpec
+        # so this doesn't do anything yet.
+        tree = etree.parse(StringIO(rspec))
+        root = tree.getroot()
+        result = root.xpath("./network/site/node/ipv4/text()")
     else:
         result = rspec
 
@@ -54,13 +53,12 @@ def display_list(results):
     for result in results:
         print result
 
-
-def display_records(recordList, dump = False):
+def display_records(recordList, dump=False):
     ''' Print all fields in the record'''
     for record in recordList:
         display_record(record, dump)
 
-def display_record(record, dump = False):
+def display_record(record, dump=False):
     if dump:
         record.dump()
     else:
@@ -90,7 +88,7 @@ def save_rspec_to_file(rspec, filename):
 def save_records_to_file(filename, recordList):
     index = 0
     for record in recordList:
-        if index>0:
+        if index > 0:
             save_record_to_file(filename + "." + str(index), record)
         else:
             save_record_to_file(filename, record)
@@ -98,15 +96,15 @@ def save_records_to_file(filename, recordList):
 
 def save_record_to_file(filename, record):
     if record['type'] in ['user']:
-        record = UserRecord(dict = record)
+        record = UserRecord(dict=record)
     elif record['type'] in ['slice']:
-        record = SliceRecord(dict = record)
+        record = SliceRecord(dict=record)
     elif record['type'] in ['node']:
-        record = NodeRecord(dict = record)
+        record = NodeRecord(dict=record)
     elif record['type'] in ['authority', 'ma', 'sa']:
-        record = AuthorityRecord(dict = record)
+        record = AuthorityRecord(dict=record)
     else:
-        record = GeniRecord(dict = record)
+        record = SfaRecord(dict=record)
     str = record.save_to_string()
     file(filename, "w").write(str)
     return
@@ -115,71 +113,100 @@ def save_record_to_file(filename, record):
 # load methods
 def load_record_from_file(filename):
     str = file(filename, "r").read()
-    record = GeniRecord(string=str)
+    record = SfaRecord(string=str)
     return record
 
 
+import uuid
+def unique_call_id(): return uuid.uuid4().urn
 
 class Sfi:
     
-    slicemgr = None
-    registry = None
-    user = None
-    authority = None
-    options = None
-    hashrequest = False
+    required_options=['verbose',  'debug',  'registry',  'sm',  'auth',  'user']
+
+    # dummy to meet Sfi's expectations for its 'options' field
+    # i.e. s/t we can do setattr on
+    class DummyOptions:
+        pass
+
+    def __init__ (self,options=None):
+        if options is None: options=Sfi.DummyOptions()
+        for opt in Sfi.required_options:
+            if not hasattr(options,opt): setattr(options,opt,None)
+        if not hasattr(options,'sfi_dir'): options.sfi_dir=os.path.expanduser("~/.sfi/")
+        self.options = options
+        self.slicemgr = None
+        self.registry = None
+        self.user = None
+        self.authority = None
+        self.hashrequest = False
+        sfa_logger_goes_to_console()
+        self.logger=sfa_logger()
    
-    def create_cmd_parser(self,command, additional_cmdargs = None):
-        cmdargs = {"gid": "",
-                  "list": "name",
+    def create_cmd_parser(self, command, additional_cmdargs=None):
+        cmdargs = {"list": "authority",
                   "show": "name",
                   "remove": "name",
                   "add": "record",
                   "update": "record",
                   "aggregates": "[name]",
                   "registries": "[name]",
+                  "get_gid": [],  
+                  "get_trusted_certs": "cred",
                   "slices": "",
                   "resources": "[name]",
                   "create": "name rspec",
                   "get_ticket": "name rspec",
-                  "redeem_ticket": "ticket rspec",  
+                  "redeem_ticket": "ticket",
                   "delete": "name",
                   "reset": "name",
                   "start": "name",
                   "stop": "name",
-                  "delegate": "name"
+                  "delegate": "name",
+                  "status": "name",
+                  "renew": "name",
+                  "shutdown": "name",
+                  "version": "",  
                  }
 
         if additional_cmdargs:
             cmdargs.update(additional_cmdargs)
 
         if command not in cmdargs:
-            print "Invalid command\n"
-            print "Commands: ",
-            for key in cmdargs.keys():
-                print key+",",
-            print ""
+            msg="Invalid command\n"
+            msg+="Commands: "
+            msg += ','.join(cmdargs.keys())            
+            self.logger.critical(msg)
             sys.exit(2)
 
         parser = OptionParser(usage="sfi [sfi_options] %s [options] %s" \
                                      % (command, cmdargs[command]))
 
-        if command in ("resources"):
-            parser.add_option("-f", "--format", dest="format",type="choice",
-                             help="display format ([xml]|dns|ip)",default="xml",
-                             choices=("xml","dns","ip"))
+        # user specifies remote aggregate/sm/component                          
+        if command in ("resources", "slices", "create", "delete", "start", "stop", 
+                       "restart", "shutdown",  "get_ticket", "renew", "status"):
             parser.add_option("-a", "--aggregate", dest="aggregate",
-                             default=None, help="aggregate hrn")
-
-        if command in ("create", "get_ticket"):
-            parser.add_option("-a", "--aggregate", dest="aggregate",default=None,
-                             help="aggregate hrn")
-
+                             default=None, help="aggregate host")
+            parser.add_option("-p", "--port", dest="port",
+                             default=AGGREGATE_PORT, help="aggregate port")
+            parser.add_option("-c", "--component", dest="component", default=None,
+                             help="component hrn")
+            parser.add_option("-d", "--delegate", dest="delegate", default=None, 
+                             action="store_true",
+                             help="Include a credential delegated to the user's root"+\
+                                  "authority in set of credentials for this call")  
+        
+        # registy filter option    
         if command in ("list", "show", "remove"):
-            parser.add_option("-t", "--type", dest="type",type="choice",
-                            help="type filter ([all]|user|slice|sa|ma|node|aggregate)",
-                            choices=("all","user","slice","sa","ma","node","aggregate"),
+            parser.add_option("-t", "--type", dest="type", type="choice",
+                            help="type filter ([all]|user|slice|authority|node|aggregate)",
+                            choices=("all", "user", "slice", "authority", "node", "aggregate"),
                             default="all")
+        # display formats
+        if command in ("resources"):
+            parser.add_option("-f", "--format", dest="format", type="choice",
+                             help="display format ([xml]|dns|ip)", default="xml",
+                             choices=("xml", "dns", "ip"))
 
         if command in ("resources", "show", "list"):
            parser.add_option("-o", "--output", dest="file",
@@ -187,8 +214,8 @@ class Sfi:
         
         if command in ("show", "list"):
            parser.add_option("-f", "--format", dest="format", type="choice",
-                             help="display format ([text]|xml)",default="text",
-                             choices=("text","xml"))
+                             help="display format ([text]|xml)", default="text",
+                             choices=("text", "xml"))
 
         if command in ("delegate"):
            parser.add_option("-u", "--user",
@@ -196,6 +223,15 @@ class Sfi:
                             help="delegate user credential")
            parser.add_option("-s", "--slice", dest="delegate_slice",
                             help="delegate slice credential", metavar="HRN", default=None)
+        
+        if command in ("version"):
+            parser.add_option("-R","--registry-version",
+                              action="store_true", dest="version_registry", default=False,
+                              help="probe registry version instead of slicemgr")
+            parser.add_option("-l","--local",
+                              action="store_true", dest="version_local", default=False,
+                              help="display version of the local client")
+
         return parser
 
         
@@ -208,19 +244,20 @@ class Sfi:
                          help="root registry", metavar="URL", default=None)
         parser.add_option("-s", "--slicemgr", dest="sm",
                          help="slice manager", metavar="URL", default=None)
-        default_sfi_dir=os.path.expanduser("~/.sfi/")
+        default_sfi_dir = os.path.expanduser("~/.sfi/")
         parser.add_option("-d", "--dir", dest="sfi_dir",
                          help="config & working directory - default is " + default_sfi_dir,
-                         metavar="PATH", default = default_sfi_dir)
+                         metavar="PATH", default=default_sfi_dir)
         parser.add_option("-u", "--user", dest="user",
                          help="user name", metavar="HRN", default=None)
         parser.add_option("-a", "--auth", dest="auth",
                          help="authority name", metavar="HRN", default=None)
-        parser.add_option("-v", "--verbose",
-                         action="store_true", dest="verbose", default=False,
-                         help="verbose mode")
-        parser.add_option("-p", "--protocol",
-                         dest="protocol", default="xmlrpc",
+        parser.add_option("-v", "--verbose", action="count", dest="verbose", default=0,
+                         help="verbose mode - cumulative")
+        parser.add_option("-D", "--debug",
+                          action="store_true", dest="debug", default=False,
+                          help="Debug (xml-rpc) protocol messages")
+        parser.add_option("-p", "--protocol", dest="protocol", default="xmlrpc",
                          help="RPC protocol (xmlrpc or soap)")
         parser.add_option("-k", "--hashrequest",
                          action="store_true", dest="hashrequest", default=False,
@@ -230,66 +267,67 @@ class Sfi:
         return parser
         
  
-    #
-    # Establish Connection to SliceMgr and Registry Servers
-    #
-    def set_servers(self):
+    def read_config(self):
        config_file = self.options.sfi_dir + os.sep + "sfi_config"
        try:
           config = Config (config_file)
        except:
-          print "Failed to read configuration file",config_file
-          print "Make sure to remove the export clauses and to add quotes"
-          if not self.options.verbose:
-             print "Re-run with -v for more details"
+          self.logger.critical("Failed to read configuration file %s"%config_file)
+          self.logger.info("Make sure to remove the export clauses and to add quotes")
+          if self.options.verbose==0:
+              self.logger.info("Re-run with -v for more details")
           else:
-             traceback.print_exc()
+              self.logger.log_exc("Could not read config file %s"%config_file)
           sys.exit(1)
     
-       errors=0
+       errors = 0
        # Set SliceMgr URL
        if (self.options.sm is not None):
-          sm_url = self.options.sm
-       elif hasattr(config,"SFI_SM"):
-          sm_url = config.SFI_SM
+          self.sm_url = self.options.sm
+       elif hasattr(config, "SFI_SM"):
+          self.sm_url = config.SFI_SM
        else:
-          print "You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s"%config_file
-          errors +=1 
+          self.logger.error("You need to set e.g. SFI_SM='http://your.slicemanager.url:12347/' in %s" % config_file)
+          errors += 1 
     
        # Set Registry URL
        if (self.options.registry is not None):
-          reg_url = self.options.registry
-       elif hasattr(config,"SFI_REGISTRY"):
-          reg_url = config.SFI_REGISTRY
+          self.reg_url = self.options.registry
+       elif hasattr(config, "SFI_REGISTRY"):
+          self.reg_url = config.SFI_REGISTRY
        else:
-          print "You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s"%config_file
-          errors +=1 
-    
+          self.logger.errors("You need to set e.g. SFI_REGISTRY='http://your.registry.url:12345/' in %s" % config_file)
+          errors += 1 
+          
+
        # Set user HRN
        if (self.options.user is not None):
           self.user = self.options.user
-       elif hasattr(config,"SFI_USER"):
+       elif hasattr(config, "SFI_USER"):
           self.user = config.SFI_USER
        else:
-          print "You need to set e.g. SFI_USER='plc.princeton.username' in %s"%config_file
-          errors +=1 
+          self.logger.errors("You need to set e.g. SFI_USER='plc.princeton.username' in %s" % config_file)
+          errors += 1 
     
        # Set authority HRN
        if (self.options.auth is not None):
           self.authority = self.options.auth
-       elif hasattr(config,"SFI_AUTH"):
+       elif hasattr(config, "SFI_AUTH"):
           self.authority = config.SFI_AUTH
        else:
-          print "You need to set e.g. SFI_AUTH='plc.princeton' in %s"%config_file
-          errors +=1 
+          self.logger.error("You need to set e.g. SFI_AUTH='plc.princeton' in %s" % config_file)
+          errors += 1 
     
        if errors:
           sys.exit(1)
-    
-       if self.options.verbose :
-          print "Contacting Slice Manager at:", sm_url
-          print "Contacting Registry at:", reg_url
-    
+
+
+    #
+    # Establish Connection to SliceMgr and Registry Servers
+    #
+    def set_servers(self):
+
+       self.read_config() 
        # Get key and certificate
        key_file = self.get_key_file()
        cert_file = self.get_cert_file(key_file)
@@ -298,10 +336,11 @@ class Sfi:
        self.cert_file = cert_file
        self.cert = Certificate(filename=cert_file) 
        # Establish connection to server(s)
-       #self.slicemgr = GeniClient(sm_url, key_file, cert_file, self.options.protocol)
-       #self.registry = GeniClient(reg_url, key_file, cert_file, self.options.protocol)
-       self.registry = xmlrpcprotocol.get_server(reg_url, key_file, cert_file)  
-       self.slicemgr = xmlrpcprotocol.get_server(sm_url, key_file, cert_file)  
+       self.logger.info("Contacting Registry at: %s"%self.reg_url)
+       self.registry = xmlrpcprotocol.get_server(self.reg_url, key_file, cert_file, self.options)  
+       self.logger.info("Contacting Slice Manager at: %s"%self.sm_url)
+       self.slicemgr = xmlrpcprotocol.get_server(self.sm_url, key_file, cert_file, self.options)
+
        return
     
     #
@@ -319,155 +358,135 @@ class Sfi:
     
     
     def get_key_file(self):
-       file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".pkey")
+       file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".pkey")
        if (os.path.isfile(file)):
           return file
        else:
-          print "Key file", file, "does not exist"
+          self.logger.error("Key file %s does not exist"%file)
           sys.exit(-1)
        return
     
-    def get_cert_file(self,key_file):
+    def get_cert_file(self, key_file):
     
-       file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cert")
-       if (os.path.isfile(file)):
-          return file
-       else:
-          k = Keypair(filename = key_file)
-          cert = Certificate(subject=self.user)
-          cert.set_pubkey(k)
-          cert.set_issuer(k, self.user)
-          cert.sign()
-          if self.options.verbose :
-             print "Writing self-signed certificate to", file
-          cert.save_to_file(file)
-          return file
-   
-    def get_gid(self):
-        file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid")
+        file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cert")
         if (os.path.isfile(file)):
-            gid = GID(filename=file)
-            return gid
+            # use existing cert if it exists                     
+            return file
         else:
-            cert_str = self.cert.save_to_string(save_parents=True)
-            request_hash=None
-            if self.hashrequest:
-                request_hash = self.key.compute_hash([cert_str, self.user, "user"])
-            gid_str = self.registry.get_gid(cert_str, self.user, "user", request_hash)
-            gid = GID(string=gid_str)
-            if self.options.verbose:
-                print "Writing user gid to", file
-            gid.save_to_file(file, save_parents=True)
-            return gid       
+            try:
+                # attempt to use gid as the cert.  
+                gid = self._get_gid()
+                self.logger.info("Writing certificate to %s"%file)
+                gid.save_to_file(file) 
+            except:
+                # generate self signed certificate
+                k = Keypair(filename=key_file)
+                cert = Certificate(subject=self.user)
+                cert.set_pubkey(k)
+                cert.set_issuer(k, self.user)
+                cert.sign()
+                self.logger.info("Writing self-signed certificate to %s"%file)
+                cert.save_to_file(file)
+            
+            return file
+
+    def get_cached_gid(self, file):
+        """
+        Return a cached gid    
+        """
+        gid = None 
+        if (os.path.isfile(file)):
+            gid = GID(filename=file)
+        return gid
+
+    # xxx opts unused
+    def get_gid(self, opts, args):
+        """
+        Get the specify gid and save it to file
+        """
+        hrn = None
+        if args:
+            hrn = args[0]
+        gid = self._get_gid(hrn)
+        self.logger.debug("Sfi.get_gid-> %s",gid.save_to_string(save_parents=True))
+        return gid
+
+    def _get_gid(self, hrn=None):
+        """
+        git_gid helper. Retrive the gid from the registry and save it to file.
+        """
+        
+        if not hrn:
+            hrn = self.user
  
-    def get_user_cred(self):
-        file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".cred")
+        gidfile = os.path.join(self.options.sfi_dir, hrn + ".gid")
+        gid = self.get_cached_gid(gidfile)
+        if not gid:
+            user_cred = self.get_user_cred()
+            records = self.registry.Resolve(hrn, user_cred.save_to_string(save_parents=True))
+            if not records:
+                raise RecordNotFound(args[0])
+            gid = GID(string=records[0]['gid'])
+            self.logger.info("Writing gid to %s"%gidfile)
+            gid.save_to_file(filename=gidfile)
+        return gid   
+                
+     
+    def get_cached_credential(self, file):
+        """
+        Return a cached credential only if it hasn't expired.
+        """
         if (os.path.isfile(file)):
-            user_cred = Credential(filename=file)
-            return user_cred
-        else:
-            # bootstrap user credential
-            cert_string = self.cert.save_to_string(save_parents=True)
-            request_hash=None
-            if self.hashrequest:
-                request_hash = self.key.compute_hash([cert_string, "user", self.user])
-            user_cred = self.registry.get_self_credential(cert_string, "user", self.user, request_hash)
-            if user_cred:
-               cred = Credential(string=user_cred)
-               cred.save_to_file(file, save_parents=True)
-               if self.options.verbose:
-                    print "Writing user credential to", file
-               return cred
-            else:
-               print "Failed to get user credential"
-               sys.exit(-1)
-  
+            credential = Credential(filename=file)
+            # make sure it isnt expired 
+            if not credential.get_expiration or \
+               datetime.datetime.today() < credential.get_expiration():
+                return credential
+        return None 
+ 
+    def get_user_cred(self):
+        file = os.path.join(self.options.sfi_dir, self.user.replace(self.authority + '.', '') + ".cred")
+        return self.get_cred(file, 'user', self.user)
+
     def get_auth_cred(self):
         if not self.authority:
-            print "no authority specified. Use -a or set SF_AUTH"
+            self.logger.critical("no authority specified. Use -a or set SF_AUTH")
             sys.exit(-1)
-    
-        file = os.path.join(self.options.sfi_dir, get_leaf("authority") +".cred")
-        if (os.path.isfile(file)):
-            auth_cred = Credential(filename=file)
-            return auth_cred
-        else:
-            # bootstrap authority credential from user credential
-            user_cred = self.get_user_cred().save_to_string(save_parents=True)
-            request_hash = None
-            if self.hashrequest:
-                request_hash = self.key.compute_hash([user_cred, "authority", self.authority])
-            auth_cred = self.registry.get_credential(user_cred, "authority", self.authority, request_hash)
-            if auth_cred:
-                cred = Credential(string=auth_cred)
-                cred.save_to_file(file, save_parents=True)
-                if self.options.verbose:
-                    print "Writing authority credential to", file
-                return cred
-            else:
-                print "Failed to get authority credential"
-                sys.exit(-1)
-    
-    def get_slice_cred(self,name):
+        file = os.path.join(self.options.sfi_dir, self.authority + ".cred")
+        return self.get_cred(file, 'authority', self.authority)
+
+    def get_slice_cred(self, name):
         file = os.path.join(self.options.sfi_dir, "slice_" + get_leaf(name) + ".cred")
-        if (os.path.isfile(file)):
-            slice_cred = Credential(filename=file)
-            return slice_cred
-        else:
-            # bootstrap slice credential from user credential
-            user_cred = self.get_user_cred().save_to_string(save_parents=True)
-            arg_list = [user_cred, "slice", name]
-            request_hash=None
-            if self.hashrequest:
-                request_hash = self.key.compute_hash(arg_list)  
-            slice_cred_str = self.registry.get_credential(user_cred, "slice", name, request_hash)
-            if slice_cred_str:
-                slice_cred = Credential(string=slice_cred_str)
-                slice_cred.save_to_file(file, save_parents=True)
-                if self.options.verbose:
-                    print "Writing slice credential to", file
-                return slice_cred
+        return self.get_cred(file, 'slice', name)
+ 
+    def get_cred(self, file, type, hrn):
+        # attempt to load a cached credential 
+        cred = self.get_cached_credential(file)    
+        if not cred:
+            if type in ['user']:
+                cert_string = self.cert.save_to_string(save_parents=True)
+                user_name = self.user.replace(self.authority + ".", '')
+                if user_name.count(".") > 0:
+                    user_name = user_name.replace(".", '_')
+                    self.user = self.authority + "." + user_name
+                cred_str = self.registry.GetSelfCredential(cert_string, hrn, "user")
             else:
-                print "Failed to get slice credential"
+                # bootstrap slice credential from user credential
+                user_cred = self.get_user_cred().save_to_string(save_parents=True)
+                cred_str = self.registry.GetCredential(user_cred, hrn, type)
+            
+            if not cred_str:
+                self.logger.critical("Failed to get %s credential" % type)
                 sys.exit(-1)
+                
+            cred = Credential(string=cred_str)
+            cred.save_to_file(file, save_parents=True)
+            self.logger.info("Writing %s credential to %s" %(type, file))
+
+        return cred
+ 
     
-    def delegate_cred(self,cred, hrn, type = 'authority'):
-        # the gid and hrn of the object we are delegating
-        object_gid = cred.get_gid_object()
-        object_hrn = object_gid.get_hrn()
-        cred.set_delegate(True)
-        if not cred.get_delegate():
-            raise Exception, "Error: Object credential %(object_hrn)s does not have delegate bit set" % locals()
-           
-    
-        records = self.registry.resolve(cred, hrn)
-        records = filter_records(type, records)
-        
-        if not records:
-            raise Exception, "Error: Didn't find a %(type)s record for %(hrn)s" % locals()
-    
-        # the gid of the user who will be delegated too
-        delegee_gid = records[0].get_gid_object()
-        delegee_hrn = delegee_gid.get_hrn()
-        
-        # the key and hrn of the user who will be delegating
-        user_key = Keypair(filename = self.get_key_file())
-        user_hrn = cred.get_gid_caller().get_hrn()
-    
-        dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
-        dcred.set_gid_caller(delegee_gid)
-        dcred.set_gid_object(object_gid)
-        dcred.set_privileges(cred.get_privileges())
-        dcred.set_delegate(True)
-        dcred.set_pubkey(object_gid.get_pubkey())
-        dcred.set_issuer(user_key, user_hrn)
-        dcred.set_parent(cred)
-        dcred.encode()
-        dcred.sign()
-    
-        return dcred
-    
-    def get_rspec_file(self,rspec):
+    def get_rspec_file(self, rspec):
        if (os.path.isabs(rspec)):
           file = rspec
        else:
@@ -475,10 +494,10 @@ class Sfi:
        if (os.path.isfile(file)):
           return file
        else:
-          print "No such rspec file", rspec
+          self.logger.critical("No such rspec file"%rspec)
           sys.exit(1)
     
-    def get_record_file(self,record):
+    def get_record_file(self, record):
        if (os.path.isabs(record)):
           file = record
        else:
@@ -486,11 +505,11 @@ class Sfi:
        if (os.path.isfile(file)):
           return file
        else:
-          print "No such registry record file", record
+          self.logger.critical("No such registry record file %s"%record)
           sys.exit(1)
     
-    def load_publickey_string(self,fn):
-       f = file(fn,"r")
+    def load_publickey_string(self, fn):
+       f = file(fn, "r")
        key_string = f.read()
     
        # if the filename is a private key file, then extract the public key
@@ -503,30 +522,63 @@ class Sfi:
            os.remove(outfn)
     
        return key_string
-    
-    #
+
+    # xxx opts undefined
+    def get_component_server_from_hrn(self, hrn):
+        # direct connection to the nodes component manager interface
+        user_cred = self.get_user_cred().save_to_string(save_parents=True)
+        records = self.registry.Resolve(hrn, user_cred)
+        records = filter_records('node', records)
+        if not records:
+            self.logger.warning("No such component:%r"% opts.component)
+        record = records[0]
+  
+        return self.get_server(record['hostname'], CM_PORT, self.key_file, self.cert_file)
+ 
+    def get_server(self, host, port, keyfile, certfile):
+        """
+        Return an instance of an xmlrpc server connection    
+        """
+        # port is appended onto the domain, before the path. Should look like:
+        # http://domain:port/path
+        host_parts = host.split('/')
+        host_parts[0] = host_parts[0] + ":" + str(port)
+        url =  "http://%s" %  "/".join(host_parts)    
+        return xmlrpcprotocol.get_server(url, keyfile, certfile, self.options)
+
+    # xxx opts could be retrieved in self.options
+    def get_server_from_opts(self, opts):
+        """
+        Return instance of an xmlrpc connection to a slice manager, aggregate
+        or component server depending on the specified opts
+        """
+        server = self.slicemgr
+        # direct connection to an aggregate
+        if hasattr(opts, 'aggregate') and opts.aggregate:
+            server = self.get_server(opts.aggregate, opts.port, self.key_file, self.cert_file)
+        # direct connection to the nodes component manager interface
+        if hasattr(opts, 'component') and opts.component:
+            server = self.get_component_server_from_hrn(opts.component)    
+ 
+        return server
+    #==========================================================================
     # Following functions implement the commands
     #
     # Registry-related commands
-    #
+    #==========================================================================
   
-    def dispatch(self,command, cmd_opts, cmd_args):
-        getattr(self,command)(cmd_opts, cmd_args)
- 
-    def gid(self, opts, args):
-        gid = self.get_gid()
-        print "GID: %s" % (gid.save_to_string(save_parents=True))
-        return   
+    def dispatch(self, command, cmd_opts, cmd_args):
+        return getattr(self, command)(cmd_opts, cmd_args)
  
     # list entires in named authority registry
-    def list(self,opts, args):
-        user_cred = self.get_user_cred().save_to_string(save_parents=True)
+    def list(self, opts, args):
+        if len(args)!= 1:
+            self.print_help()
+            sys.exit(1)
         hrn = args[0]
-        request_hash=None
-        if self.hashrequest:
-            request_hash = self.key.compute_hash([user_cred, hrn])    
+        user_cred = self.get_user_cred().save_to_string(save_parents=True)
         try:
-            list = self.registry.list(user_cred, hrn, request_hash)
+            list = self.registry.List(hrn, user_cred)
         except IndexError:
             raise Exception, "Not enough parameters for the 'list' command"
           
@@ -538,35 +590,35 @@ class Sfi:
         if opts.file:
             file = opts.file
             if not file.startswith(os.sep):
-                file = os.path.join(self.options.sfi_dir, get_leaf(self.user) + ".gid")
+                file = os.path.join(self.options.sfi_dir, file)
             save_records_to_file(file, list)
         return
     
     # show named registry record
-    def show(self,opts, args):
-        user_cred = self.get_user_cred().save_to_string(save_parents=True)
+    def show(self, opts, args):
+        if len(args)!= 1:
+            self.print_help()
+            sys.exit(1)
         hrn = args[0]
-        request_hash=None
-        if self.hashrequest:
-            request_hash = self.key.compute_hash([user_cred, hrn])    
-        records = self.registry.resolve(user_cred, hrn, request_hash)
+        user_cred = self.get_user_cred().save_to_string(save_parents=True)
+        records = self.registry.Resolve(hrn, user_cred)
         records = filter_records(opts.type, records)
         if not records:
             print "No record of type", opts.type
         for record in records:
             if record['type'] in ['user']:
-                record = UserRecord(dict = record)
+                record = UserRecord(dict=record)
             elif record['type'] in ['slice']:
-                record = SliceRecord(dict = record)
+                record = SliceRecord(dict=record)
             elif record['type'] in ['node']:
-                record = NodeRecord(dict = record)
+                record = NodeRecord(dict=record)
             elif record['type'] in ['authority', 'ma', 'sa']:
-                record = AuthorityRecord(dict = record)
+                record = AuthorityRecord(dict=record)
             else:
-                record = GeniRecord(dict = record)
-            if (opts.format=="text"): 
+                record = SfaRecord(dict=record)
+            if (opts.format == "text"): 
                 record.dump()  
-            else: 
+            else:
                 print record.save_to_string() 
        
         if opts.file:
@@ -576,90 +628,84 @@ class Sfi:
             save_records_to_file(file, records)
         return
     
-    def delegate(self,opts, args):
-       user_cred = self.get_user_cred()
-       if opts.delegate_user:
-           object_cred = user_cred
-       elif opts.delegate_slice:
-           object_cred = self.get_slice_cred(opts.delegate_slice)
-       else:
-           print "Must specify either --user or --slice <hrn>"
-           return
-    
-       # the gid and hrn of the object we are delegating
-       object_gid = object_cred.get_gid_object()
-       object_hrn = object_gid.get_hrn()
-    
-       if not object_cred.get_delegate():
-           print "Error: Object credential", object_hrn, "does not have delegate bit set"
-           return
-    
-       records = self.registry.resolve(user_cred, args[0])
-       records = filter_records("user", records)
-    
-       if not records:
-           print "Error: Didn't find a user record for", args[0]
-           return
-    
-       # the gid of the user who will be delegated too
-       delegee_gid = records[0].get_gid_object()
-       delegee_hrn = delegee_gid.get_hrn()
-    
-       # the key and hrn of the user who will be delegating
-       user_key = Keypair(filename = self.get_key_file())
-       user_hrn = user_cred.get_gid_caller().get_hrn()
-    
-       dcred = Credential(subject=object_hrn + " delegated to " + delegee_hrn)
-       dcred.set_gid_caller(delegee_gid)
-       dcred.set_gid_object(object_gid)
-       dcred.set_privileges(object_cred.get_privileges())
-       dcred.set_delegate(True)
-       dcred.set_pubkey(object_gid.get_pubkey())
-       dcred.set_issuer(user_key, user_hrn)
-       dcred.set_parent(object_cred)
-       dcred.encode()
-       dcred.sign()
-    
-       if opts.delegate_user:
-           dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_" 
+    def delegate(self, opts, args):
+
+        delegee_hrn = args[0]
+        if opts.delegate_user:
+            user_cred = self.get_user_cred()
+            cred = self.delegate_cred(user_cred, delegee_hrn)
+        elif opts.delegate_slice:
+            slice_cred = self.get_slice_cred(opts.delegate_slice)
+            cred = self.delegate_cred(slice_cred, delegee_hrn)
+        else:
+            self.logger.warning("Must specify either --user or --slice <hrn>")
+            return
+        delegated_cred = Credential(string=cred)
+        object_hrn = delegated_cred.get_gid_object().get_hrn()
+        if opts.delegate_user:
+            dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_"
                                   + get_leaf(object_hrn) + ".cred")
-       elif opts.delegate_slice:
-           dest_fn = os.path_join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_" 
+        elif opts.delegate_slice:
+            dest_fn = os.path.join(self.options.sfi_dir, get_leaf(delegee_hrn) + "_slice_"
                                   + get_leaf(object_hrn) + ".cred")
+
+        delegated_cred.save_to_file(dest_fn, save_parents=True)
+
+        self.logger.info("delegated credential for %s to %s and wrote to %s"%(object_hrn, delegee_hrn,dest_fn))
     
-       dcred.save_to_file(dest_fn, save_parents = True)
-    
-       print "delegated credential for", object_hrn, "to", delegee_hrn, "and wrote to", dest_fn
+    def delegate_cred(self, object_cred, hrn):
+        # the gid and hrn of the object we are delegating
+        if isinstance(object_cred, str):
+            object_cred = Credential(string=object_cred) 
+        object_gid = object_cred.get_gid_object()
+        object_hrn = object_gid.get_hrn()
     
+        if not object_cred.get_privileges().get_all_delegate():
+            self.logger.error("Object credential %s does not have delegate bit set"%object_hrn)
+            return
+
+        # the delegating user's gid
+        caller_gid = self._get_gid(self.user)
+        caller_gidfile = os.path.join(self.options.sfi_dir, self.user + ".gid")
+  
+        # the gid of the user who will be delegated to
+        delegee_gid = self._get_gid(hrn)
+        delegee_hrn = delegee_gid.get_hrn()
+        delegee_gidfile = os.path.join(self.options.sfi_dir, delegee_hrn + ".gid")
+        delegee_gid.save_to_file(filename=delegee_gidfile)
+        dcred = object_cred.delegate(delegee_gidfile, self.get_key_file(), caller_gidfile)
+        return dcred.save_to_string(save_parents=True)
+     
     # removed named registry record
     #   - have to first retrieve the record to be removed
-    def remove(self,opts, args):
+    def remove(self, opts, args):
         auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
+        if len(args)!=1:
+            self.print_help()
+            sys.exit(1)
         hrn = args[0]
         type = opts.type 
         if type in ['all']:
             type = '*'
-        request_hash=None
-        if self.hashrequest: 
-            arg_list = [auth_cred, type, hrn]
-            request_hash = self.key.compute_hash(arg_list)                   
-        return self.registry.remove(auth_cred, type, hrn, request_hash)
+        return self.registry.Remove(hrn, auth_cred, type)
     
     # add named registry record
-    def add(self,opts, args):
+    def add(self, opts, args):
         auth_cred = self.get_auth_cred().save_to_string(save_parents=True)
+        if len(args)!=1:
+            self.print_help()
+            sys.exit(1)
         record_filepath = args[0]
         rec_file = self.get_record_file(record_filepath)
         record = load_record_from_file(rec_file).as_dict()
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [auth_cred]
-            request_hash = self.key.compute_hash(arg_list)
-        return self.registry.register(auth_cred, record, request_hash)
+        return self.registry.Register(record, auth_cred)
     
     # update named registry entry
-    def update(self,opts, args):
+    def update(self, opts, args):
         user_cred = self.get_user_cred()
+        if len(args)!=1:
+            self.print_help()
+            sys.exit(1)
         rec_file = self.get_record_file(args[0])
         record = load_record_from_file(rec_file)
         if record['type'] == "user":
@@ -670,7 +716,7 @@ class Sfi:
         elif record['type'] in ["slice"]:
             try:
                 cred = self.get_slice_cred(record.get_name()).save_to_string(save_parents=True)
-            except ServerException, e:
+            except xmlrpcprotocol.ServerException, e:
                # XXX smbaker -- once we have better error return codes, update this
                # to do something better than a string compare
                if "Permission error" in e.args[0]:
@@ -684,26 +730,28 @@ class Sfi:
         else:
             raise "unknown record type" + record.get_type()
         record = record.as_dict()
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [cred]  
-            request_hash = self.key.compute_hash(arg_list)
-        return self.registry.update(cred, record, request_hash)
-   
-    
+        return self.registry.Update(record, cred)
+  
+    def get_trusted_certs(self, opts, args):
+        """
+        return uhe trusted certs at this interface 
+        """ 
+        trusted_certs = self.registry.get_trusted_certs()
+        for trusted_cert in trusted_certs:
+            cert = Certificate(string=trusted_cert)
+            self.logger.debug('Sfi.get_trusted_certs -> %r'%cert.get_subject())
+        return 
+
     def aggregates(self, opts, args):
         """
         return a list of details about known aggregates
         """
         user_cred = self.get_user_cred().save_to_string(save_parents=True)
         hrn = None
-        if args: 
+        if args:
             hrn = args[0]
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [user_cred, hrn]  
-            request_hash = self.key.compute_hash(arg_list)
-        result = self.registry.get_aggregates(user_cred, hrn, request_hash)
+
+        result = self.registry.get_aggregates(user_cred, hrn)
         display_list(result)
         return 
 
@@ -715,62 +763,67 @@ class Sfi:
         hrn = None
         if args:
             hrn = args[0]
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [user_cred, hrn]  
-            request_hash = self.key.compute_hash(arg_list)
-        result = self.registry.get_registries(user_cred, hrn, request_hash)
+        result = self.registry.get_registries(user_cred, hrn)
         display_list(result)
         return
 
  
-    #
+    # ==================================================================
     # Slice-related commands
-    #
+    # ==================================================================
     
-    # list available nodes -- use 'resources' w/ no argument instead
+
+    def version(self, opts, args):
+        if opts.version_local:
+            version=version_core()
+        else:
+            if opts.version_registry:
+                server=self.registry
+            else:
+                server = self.get_server_from_opts(opts)
+            version=server.GetVersion()
+        for (k,v) in version.iteritems():
+            print "%-20s: %s"%(k,v)
 
     # list instantiated slices
-    def slices(self,opts, args):
+    def slices(self, opts, args):
+        """
+        list instantiated slices
+        """
         user_cred = self.get_user_cred().save_to_string(save_parents=True)
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [user_cred]
-            request_hash = self.key.compute_hash(arg_list)
-        results = self.slicemgr.get_slices(user_cred, request_hash)
+        creds = [user_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(user_cred, get_authority(self.authority))
+            creds.append(delegated_cred)  
+        server = self.get_server_from_opts(opts)
+        results = server.ListSlices(creds)
         display_list(results)
         return
     
     # show rspec for named slice
-    def resources(self,opts, args):
+    def resources(self, opts, args):
         user_cred = self.get_user_cred().save_to_string(save_parents=True)
         server = self.slicemgr
-        if opts.aggregate:
-            agg_hrn = opts.aggregate
-            arg_list = [user_cred, arg_hrn]
-            request_hash = self.key.compute_hash(arg_list)
-            aggregates = self.registry.get_aggregates(user_cred, agg_hrn, request_hash)
-            if not aggregates:
-                raise Exception, "No such aggregate %s" % agg_hrn
-            aggregate = aggregates[0]
-            url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])     
-            server = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
+        call_options = {}
+        server = self.get_server_from_opts(opts)
+        
         if args:
             cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
             hrn = args[0]
+            call_options = {'geni_slice_urn': hrn_to_urn(hrn, 'slice')}
         else:
             cred = user_cred
             hrn = None
-
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [cred, hrn]
-            request_hash = self.key.compute_hash(arg_list)  
-        result = server.get_resources(cred, hrn, request_hash)
+     
+        creds = [cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(cred, get_authority(self.authority))
+            creds.append(delegated_cred) 
+        result = server.ListResources(creds, call_options,unique_call_id())
         format = opts.format
-       
-        display_rspec(result, format)
-        if (opts.file is not None):
+        if opts.file is None:
+            display_rspec(result, format)
+        else:
             file = opts.file
             if not file.startswith(os.sep):
                 file = os.path.join(self.options.sfi_dir, file)
@@ -778,48 +831,38 @@ class Sfi:
         return
     
     # created named slice with given rspec
-    def create(self,opts, args):
+    def create(self, opts, args):
         slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
         user_cred = self.get_user_cred()
         slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
         rspec_file = self.get_rspec_file(args[1])
-        rspec=open(rspec_file).read()
-        server = self.slicemgr
-        if opts.aggregate:
-            aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
-            if not aggregates:
-                raise Exception, "No such aggregate %s" % opts.aggregate
-            aggregate = aggregates[0]
-            url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
-            server = GeniClient(url, self.key_file, self.cert_file, self.options.protocol)
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [slice_cred, slice_hrn, rspec]
-            request_hash = self.key.compute_hash(arg_list) 
-        return server.create_slice(slice_cred, slice_hrn, rspec, request_hash)
+        rspec = open(rspec_file).read()
+        server = self.get_server_from_opts(opts)
+        result =  server.CreateSliver(slice_urn, creds, rspec, [], unique_call_id())
+        print result
+        return result
 
     # get a ticket for the specified slice
     def get_ticket(self, opts, args):
         slice_hrn, rspec_path = args[0], args[1]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice')
         user_cred = self.get_user_cred()
         slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
         rspec_file = self.get_rspec_file(rspec_path) 
-        rspec=open(rspec_file).read()
-        server = self.slicemgr
-        if opts.aggregate:
-            aggregates = self.registry.get_aggregates(user_cred, opts.aggregate)
-            if not aggregates:
-                raise Exception, "No such aggregate %s" % opts.aggregate
-            aggregate = aggregates[0]
-            url = "http://%s:%s" % (aggregate['addr'], aggregate['port'])
-            server = GeniClient(url, self.key_file, self.cert_file, self.options.protocol)
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [slice_cred, slice_hrn, rspec]
-            request_hash = self.key.compute_hash(arg_list)
-        ticket_string = server.get_ticket(slice_cred, slice_hrn, rspec, request_hash)
+        rspec = open(rspec_file).read()
+        server = self.get_server_from_opts(opts)
+        ticket_string = server.GetTicket(slice_urn, creds, rspec, [])
         file = os.path.join(self.options.sfi_dir, get_leaf(slice_hrn) + ".ticket")
-        print "writing ticket to ", file        
+        self.logger.info("writing ticket to %s"%file)
         ticket = SfaTicket(string=ticket_string)
         ticket.save_to_file(filename=file, save_parents=True)
 
@@ -830,113 +873,157 @@ class Sfi:
         # use this to get the right slice credential 
         ticket = SfaTicket(filename=ticket_file)
         ticket.decode()
-        slice_hrn = ticket.attributes['slivers'][0]['hrn']
+        slice_hrn = ticket.gidObject.get_hrn()
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
+        #slice_hrn = ticket.attributes['slivers'][0]['hrn']
         user_cred = self.get_user_cred()
         slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
         
-        # get a list node hostnames from the nodespecs in the rspec 
-        rspec = RSpec()
-        rspec.parseString(ticket.rspec)
-        nodespecs = rspec.getDictsByTagName('NodeSpec')
-        hostnames = [nodespec['name'] for nodespec in nodespecs]
+        # get a list of node hostnames from the RSpec 
+        tree = etree.parse(StringIO(ticket.rspec))
+        root = tree.getroot()
+        hostnames = root.xpath("./network/site/node/hostname/text()")
         
         # create an xmlrpc connection to the component manager at each of these
         # components and gall redeem_ticket
         connections = {}
         for hostname in hostnames:
             try:
-                cm_port = "12346" 
-                url = "https://%(hostname)s:%(cm_port)s" % locals() 
-                print "Calling get_ticket at %(url)s " % locals(),  
-                cm = xmlrpcprotocol.get_server(url, self.key_file, self.cert_file)
-                cm.redeem_ticket(slice_cred, ticket.save_to_string(save_parents=True))
-                print "Success"
+                self.logger.info("Calling redeem_ticket at %(hostname)s " % locals())
+                server = self.get_server(hostname, CM_PORT, self.key_file, \
+                                         self.cert_file, self.options.debug)
+                server.RedeemTicket(ticket.save_to_string(save_parents=True), slice_cred)
+                self.logger.info("Success")
             except socket.gaierror:
-                print "Failed:",
-                print "Componet Manager not accepting requests" 
+                self.logger.error("redeem_ticket failed: Component Manager not accepting requests")
             except Exception, e:
-                print "Failed:", e.message
-             
+                self.logger.log_exc(e.message)
         return
  
     # delete named slice
-    def delete(self,opts, args):
+    def delete(self, opts, args):
         slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
         slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [slice_cred, slice_hrn]
-            request_hash = self.key.compute_hash(arg_list) 
-        return self.slicemgr.delete_slice(slice_cred, slice_hrn, request_hash)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        server = self.get_server_from_opts(opts)
+        return server.DeleteSliver(slice_urn, creds, unique_call_id())
     
     # start named slice
-    def start(self,opts, args):
+    def start(self, opts, args):
         slice_hrn = args[0]
-        slice_cred = self.get_slice_cred(args[0])
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [slice_cred, slice_hrn]
-            request_hash = self.key.compute_hash(arg_list)
-        return self.slicemgr.start_slice(slice_cred, slice_hrn, request_hash)
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
+        slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        server = self.get_server_from_opts(opts)
+        return server.Start(slice_urn, creds)
     
     # stop named slice
-    def stop(self,opts, args):
+    def stop(self, opts, args):
         slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
         slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [slice_cred, slice_hrn]
-            request_hash = self.key.compute_hash(arg_list)
-        return self.slicemgr.stop_slice(slice_cred, slice_hrn, request_hash)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        server = self.get_server_from_opts(opts)
+        return server.Stop(slice_urn, creds)
     
     # reset named slice
-    def reset(self,opts, args):
+    def reset(self, opts, args):
+        slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
+        server = self.get_server_from_opts(opts)
+        slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        return server.reset_slice(creds, slice_urn)
+
+    def renew(self, opts, args):
         slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
+        server = self.get_server_from_opts(opts)
         slice_cred = self.get_slice_cred(args[0]).save_to_string(save_parents=True)
-        request_hash=None
-        if self.hashrequest:
-            arg_list = [slice_cred, slice_hrn]
-            request_hash = self.key.compute_hash(arg_list)
-        return self.slicemgr.reset_slice(slice_cred, slice_hrn, request_hash)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        time = args[1]
+        return server.RenewSliver(slice_urn, creds, time)
+
+
+    def status(self, opts, args):
+        slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
+        slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        server = self.get_server_from_opts(opts)
+        print server.SliverStatus(slice_urn, creds)
+
+
+    def shutdown(self, opts, args):
+        slice_hrn = args[0]
+        slice_urn = hrn_to_urn(slice_hrn, 'slice') 
+        slice_cred = self.get_slice_cred(slice_hrn).save_to_string(save_parents=True)
+        creds = [slice_cred]
+        if opts.delegate:
+            delegated_cred = self.delegate_cred(slice_cred, get_authority(self.authority))
+            creds.append(delegated_cred)
+        server = self.get_server_from_opts(opts)
+        return server.Shutdown(slice_urn, creds)         
     
+    def print_help (self):
+        self.sfi_parser.print_help()
+        self.cmd_parser.print_help()
+
     #
     # Main: parse arguments and dispatch to command
     #
     def main(self):
-        parser = self.create_parser()
-        (options, args) = parser.parse_args()
+        self.sfi_parser = self.create_parser()
+        (options, args) = self.sfi_parser.parse_args()
         self.options = options
-   
+
+        self.logger.setLevelFromOptVerbose(self.options.verbose)
         if options.hashrequest:
-            self.hashrequest=True
+            self.hashrequest = True
  
         if len(args) <= 0:
-            print "No command given. Use -h for help."
+            self.logger.critical("No command given. Use -h for help.")
             return -1
     
         command = args[0]
-        (cmd_opts, cmd_args) = self.create_cmd_parser(command).parse_args(args[1:])
-        if self.options.verbose :
-            print "Registry %s, sm %s, dir %s, user %s, auth %s" % (options.registry, options.sm,
-                                                                   options.sfi_dir, options.user,
-                                                                   options.auth)
-            print "Command %s" %command
-            if command in ("resources"):
-                print "resources cmd_opts %s" %cmd_opts.format
-            elif command in ("list","show","remove"):
-                print "cmd_opts.type %s" %cmd_opts.type
-            print "cmd_args %s" %cmd_args
-    
+        self.cmd_parser = self.create_cmd_parser(command)
+        (cmd_opts, cmd_args) = self.cmd_parser.parse_args(args[1:])
+
         self.set_servers()
     
+        self.logger.info("Command=%s" % command)
+        if command in ("resources"):
+            self.logger.debug("resources cmd_opts %s" % cmd_opts.format)
+        elif command in ("list", "show", "remove"):
+            self.logger.debug("cmd_opts.type %s" % cmd_opts.type)
+        self.logger.debug('cmd_args %s',cmd_args)
+
         try:
             self.dispatch(command, cmd_opts, cmd_args)
         except KeyError:
-            raise 
-            print "Command not found:", command
+            self.logger.critical ("Unknown command %s"%command)
             sys.exit(1)
     
         return
     
-if __name__=="__main__":
-   Sfi().main()
+if __name__ == "__main__":
+    Sfi().main()