accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dlmar...@apache.org
Subject [19/39] accumulo git commit: ACCUMULO-4147 Add Accumulo Namespace Operations to Proxy
Date Tue, 12 Apr 2016 13:58:36 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/8839fe51/proxy/src/main/python/AccumuloProxy.py
----------------------------------------------------------------------
diff --git a/proxy/src/main/python/AccumuloProxy.py b/proxy/src/main/python/AccumuloProxy.py
index 83c216c..19bd257 100644
--- a/proxy/src/main/python/AccumuloProxy.py
+++ b/proxy/src/main/python/AccumuloProxy.py
@@ -574,6 +574,36 @@ class Iface:
     """
     pass
 
+  def grantNamespacePermission(self, login, user, namespaceName, perm):
+    """
+    Parameters:
+     - login
+     - user
+     - namespaceName
+     - perm
+    """
+    pass
+
+  def hasNamespacePermission(self, login, user, namespaceName, perm):
+    """
+    Parameters:
+     - login
+     - user
+     - namespaceName
+     - perm
+    """
+    pass
+
+  def revokeNamespacePermission(self, login, user, namespaceName, perm):
+    """
+    Parameters:
+     - login
+     - user
+     - namespaceName
+     - perm
+    """
+    pass
+
   def createBatchScanner(self, login, tableName, options):
     """
     Parameters:
@@ -710,6 +740,170 @@ class Iface:
     """
     pass
 
+  def systemNamespace(self):
+    pass
+
+  def defaultNamespace(self):
+    pass
+
+  def listNamespaces(self, login):
+    """
+    Parameters:
+     - login
+    """
+    pass
+
+  def namespaceExists(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    pass
+
+  def createNamespace(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    pass
+
+  def deleteNamespace(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    pass
+
+  def renameNamespace(self, login, oldNamespaceName, newNamespaceName):
+    """
+    Parameters:
+     - login
+     - oldNamespaceName
+     - newNamespaceName
+    """
+    pass
+
+  def setNamespaceProperty(self, login, namespaceName, property, value):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - property
+     - value
+    """
+    pass
+
+  def removeNamespaceProperty(self, login, namespaceName, property):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - property
+    """
+    pass
+
+  def getNamespaceProperties(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    pass
+
+  def namespaceIdMap(self, login):
+    """
+    Parameters:
+     - login
+    """
+    pass
+
+  def attachNamespaceIterator(self, login, namespaceName, setting, scopes):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - setting
+     - scopes
+    """
+    pass
+
+  def removeNamespaceIterator(self, login, namespaceName, name, scopes):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - name
+     - scopes
+    """
+    pass
+
+  def getNamespaceIteratorSetting(self, login, namespaceName, name, scope):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - name
+     - scope
+    """
+    pass
+
+  def listNamespaceIterators(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    pass
+
+  def checkNamespaceIteratorConflicts(self, login, namespaceName, setting, scopes):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - setting
+     - scopes
+    """
+    pass
+
+  def addNamespaceConstraint(self, login, namespaceName, constraintClassName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - constraintClassName
+    """
+    pass
+
+  def removeNamespaceConstraint(self, login, namespaceName, id):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - id
+    """
+    pass
+
+  def listNamespaceConstraints(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    pass
+
+  def testNamespaceClassLoad(self, login, namespaceName, className, asTypeName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - className
+     - asTypeName
+    """
+    pass
+
 
 class Client(Iface):
   def __init__(self, iprot, oprot=None):
@@ -3050,6 +3244,125 @@ class Client(Iface):
       raise result.ouch3
     return
 
+  def grantNamespacePermission(self, login, user, namespaceName, perm):
+    """
+    Parameters:
+     - login
+     - user
+     - namespaceName
+     - perm
+    """
+    self.send_grantNamespacePermission(login, user, namespaceName, perm)
+    self.recv_grantNamespacePermission()
+
+  def send_grantNamespacePermission(self, login, user, namespaceName, perm):
+    self._oprot.writeMessageBegin('grantNamespacePermission', TMessageType.CALL, self._seqid)
+    args = grantNamespacePermission_args()
+    args.login = login
+    args.user = user
+    args.namespaceName = namespaceName
+    args.perm = perm
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_grantNamespacePermission(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = grantNamespacePermission_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    return
+
+  def hasNamespacePermission(self, login, user, namespaceName, perm):
+    """
+    Parameters:
+     - login
+     - user
+     - namespaceName
+     - perm
+    """
+    self.send_hasNamespacePermission(login, user, namespaceName, perm)
+    return self.recv_hasNamespacePermission()
+
+  def send_hasNamespacePermission(self, login, user, namespaceName, perm):
+    self._oprot.writeMessageBegin('hasNamespacePermission', TMessageType.CALL, self._seqid)
+    args = hasNamespacePermission_args()
+    args.login = login
+    args.user = user
+    args.namespaceName = namespaceName
+    args.perm = perm
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_hasNamespacePermission(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = hasNamespacePermission_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "hasNamespacePermission failed: unknown result")
+
+  def revokeNamespacePermission(self, login, user, namespaceName, perm):
+    """
+    Parameters:
+     - login
+     - user
+     - namespaceName
+     - perm
+    """
+    self.send_revokeNamespacePermission(login, user, namespaceName, perm)
+    self.recv_revokeNamespacePermission()
+
+  def send_revokeNamespacePermission(self, login, user, namespaceName, perm):
+    self._oprot.writeMessageBegin('revokeNamespacePermission', TMessageType.CALL, self._seqid)
+    args = revokeNamespacePermission_args()
+    args.login = login
+    args.user = user
+    args.namespaceName = namespaceName
+    args.perm = perm
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_revokeNamespacePermission(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = revokeNamespacePermission_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    return
+
   def createBatchScanner(self, login, tableName, options):
     """
     Parameters:
@@ -3652,1286 +3965,918 @@ class Client(Iface):
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getFollowing failed: unknown result")
 
+  def systemNamespace(self):
+    self.send_systemNamespace()
+    return self.recv_systemNamespace()
 
-class Processor(Iface, TProcessor):
-  def __init__(self, handler):
-    self._handler = handler
-    self._processMap = {}
-    self._processMap["login"] = Processor.process_login
-    self._processMap["addConstraint"] = Processor.process_addConstraint
-    self._processMap["addSplits"] = Processor.process_addSplits
-    self._processMap["attachIterator"] = Processor.process_attachIterator
-    self._processMap["checkIteratorConflicts"] = Processor.process_checkIteratorConflicts
-    self._processMap["clearLocatorCache"] = Processor.process_clearLocatorCache
-    self._processMap["cloneTable"] = Processor.process_cloneTable
-    self._processMap["compactTable"] = Processor.process_compactTable
-    self._processMap["cancelCompaction"] = Processor.process_cancelCompaction
-    self._processMap["createTable"] = Processor.process_createTable
-    self._processMap["deleteTable"] = Processor.process_deleteTable
-    self._processMap["deleteRows"] = Processor.process_deleteRows
-    self._processMap["exportTable"] = Processor.process_exportTable
-    self._processMap["flushTable"] = Processor.process_flushTable
-    self._processMap["getDiskUsage"] = Processor.process_getDiskUsage
-    self._processMap["getLocalityGroups"] = Processor.process_getLocalityGroups
-    self._processMap["getIteratorSetting"] = Processor.process_getIteratorSetting
-    self._processMap["getMaxRow"] = Processor.process_getMaxRow
-    self._processMap["getTableProperties"] = Processor.process_getTableProperties
-    self._processMap["importDirectory"] = Processor.process_importDirectory
-    self._processMap["importTable"] = Processor.process_importTable
-    self._processMap["listSplits"] = Processor.process_listSplits
-    self._processMap["listTables"] = Processor.process_listTables
-    self._processMap["listIterators"] = Processor.process_listIterators
-    self._processMap["listConstraints"] = Processor.process_listConstraints
-    self._processMap["mergeTablets"] = Processor.process_mergeTablets
-    self._processMap["offlineTable"] = Processor.process_offlineTable
-    self._processMap["onlineTable"] = Processor.process_onlineTable
-    self._processMap["removeConstraint"] = Processor.process_removeConstraint
-    self._processMap["removeIterator"] = Processor.process_removeIterator
-    self._processMap["removeTableProperty"] = Processor.process_removeTableProperty
-    self._processMap["renameTable"] = Processor.process_renameTable
-    self._processMap["setLocalityGroups"] = Processor.process_setLocalityGroups
-    self._processMap["setTableProperty"] = Processor.process_setTableProperty
-    self._processMap["splitRangeByTablets"] = Processor.process_splitRangeByTablets
-    self._processMap["tableExists"] = Processor.process_tableExists
-    self._processMap["tableIdMap"] = Processor.process_tableIdMap
-    self._processMap["testTableClassLoad"] = Processor.process_testTableClassLoad
-    self._processMap["pingTabletServer"] = Processor.process_pingTabletServer
-    self._processMap["getActiveScans"] = Processor.process_getActiveScans
-    self._processMap["getActiveCompactions"] = Processor.process_getActiveCompactions
-    self._processMap["getSiteConfiguration"] = Processor.process_getSiteConfiguration
-    self._processMap["getSystemConfiguration"] = Processor.process_getSystemConfiguration
-    self._processMap["getTabletServers"] = Processor.process_getTabletServers
-    self._processMap["removeProperty"] = Processor.process_removeProperty
-    self._processMap["setProperty"] = Processor.process_setProperty
-    self._processMap["testClassLoad"] = Processor.process_testClassLoad
-    self._processMap["authenticateUser"] = Processor.process_authenticateUser
-    self._processMap["changeUserAuthorizations"] = Processor.process_changeUserAuthorizations
-    self._processMap["changeLocalUserPassword"] = Processor.process_changeLocalUserPassword
-    self._processMap["createLocalUser"] = Processor.process_createLocalUser
-    self._processMap["dropLocalUser"] = Processor.process_dropLocalUser
-    self._processMap["getUserAuthorizations"] = Processor.process_getUserAuthorizations
-    self._processMap["grantSystemPermission"] = Processor.process_grantSystemPermission
-    self._processMap["grantTablePermission"] = Processor.process_grantTablePermission
-    self._processMap["hasSystemPermission"] = Processor.process_hasSystemPermission
-    self._processMap["hasTablePermission"] = Processor.process_hasTablePermission
-    self._processMap["listLocalUsers"] = Processor.process_listLocalUsers
-    self._processMap["revokeSystemPermission"] = Processor.process_revokeSystemPermission
-    self._processMap["revokeTablePermission"] = Processor.process_revokeTablePermission
-    self._processMap["createBatchScanner"] = Processor.process_createBatchScanner
-    self._processMap["createScanner"] = Processor.process_createScanner
-    self._processMap["hasNext"] = Processor.process_hasNext
-    self._processMap["nextEntry"] = Processor.process_nextEntry
-    self._processMap["nextK"] = Processor.process_nextK
-    self._processMap["closeScanner"] = Processor.process_closeScanner
-    self._processMap["updateAndFlush"] = Processor.process_updateAndFlush
-    self._processMap["createWriter"] = Processor.process_createWriter
-    self._processMap["update"] = Processor.process_update
-    self._processMap["flush"] = Processor.process_flush
-    self._processMap["closeWriter"] = Processor.process_closeWriter
-    self._processMap["updateRowConditionally"] = Processor.process_updateRowConditionally
-    self._processMap["createConditionalWriter"] = Processor.process_createConditionalWriter
-    self._processMap["updateRowsConditionally"] = Processor.process_updateRowsConditionally
-    self._processMap["closeConditionalWriter"] = Processor.process_closeConditionalWriter
-    self._processMap["getRowRange"] = Processor.process_getRowRange
-    self._processMap["getFollowing"] = Processor.process_getFollowing
+  def send_systemNamespace(self):
+    self._oprot.writeMessageBegin('systemNamespace', TMessageType.CALL, self._seqid)
+    args = systemNamespace_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process(self, iprot, oprot):
-    (name, type, seqid) = iprot.readMessageBegin()
-    if name not in self._processMap:
-      iprot.skip(TType.STRUCT)
+  def recv_systemNamespace(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
       iprot.readMessageEnd()
-      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
-      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
-      x.write(oprot)
-      oprot.writeMessageEnd()
-      oprot.trans.flush()
-      return
-    else:
-      self._processMap[name](self, seqid, iprot, oprot)
-    return True
-
-  def process_login(self, seqid, iprot, oprot):
-    args = login_args()
-    args.read(iprot)
+      raise x
+    result = systemNamespace_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = login_result()
-    try:
-      result.success = self._handler.login(args.principal, args.loginProperties)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("login", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "systemNamespace failed: unknown result")
 
-  def process_addConstraint(self, seqid, iprot, oprot):
-    args = addConstraint_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addConstraint_result()
-    try:
-      result.success = self._handler.addConstraint(args.login, args.tableName, args.constraintClassName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("addConstraint", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def defaultNamespace(self):
+    self.send_defaultNamespace()
+    return self.recv_defaultNamespace()
 
-  def process_addSplits(self, seqid, iprot, oprot):
-    args = addSplits_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addSplits_result()
-    try:
-      self._handler.addSplits(args.login, args.tableName, args.splits)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("addSplits", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_defaultNamespace(self):
+    self._oprot.writeMessageBegin('defaultNamespace', TMessageType.CALL, self._seqid)
+    args = defaultNamespace_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_attachIterator(self, seqid, iprot, oprot):
-    args = attachIterator_args()
-    args.read(iprot)
+  def recv_defaultNamespace(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = defaultNamespace_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = attachIterator_result()
-    try:
-      self._handler.attachIterator(args.login, args.tableName, args.setting, args.scopes)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloSecurityException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("attachIterator", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "defaultNamespace failed: unknown result")
 
-  def process_checkIteratorConflicts(self, seqid, iprot, oprot):
-    args = checkIteratorConflicts_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = checkIteratorConflicts_result()
-    try:
-      self._handler.checkIteratorConflicts(args.login, args.tableName, args.setting, args.scopes)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloSecurityException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("checkIteratorConflicts", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def listNamespaces(self, login):
+    """
+    Parameters:
+     - login
+    """
+    self.send_listNamespaces(login)
+    return self.recv_listNamespaces()
 
-  def process_clearLocatorCache(self, seqid, iprot, oprot):
-    args = clearLocatorCache_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = clearLocatorCache_result()
-    try:
-      self._handler.clearLocatorCache(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except TableNotFoundException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("clearLocatorCache", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_listNamespaces(self, login):
+    self._oprot.writeMessageBegin('listNamespaces', TMessageType.CALL, self._seqid)
+    args = listNamespaces_args()
+    args.login = login
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_cloneTable(self, seqid, iprot, oprot):
-    args = cloneTable_args()
-    args.read(iprot)
+  def recv_listNamespaces(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = listNamespaces_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = cloneTable_result()
-    try:
-      self._handler.cloneTable(args.login, args.tableName, args.newTableName, args.flush, args.propertiesToSet, args.propertiesToExclude)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except TableExistsException as ouch4:
-      msg_type = TMessageType.REPLY
-      result.ouch4 = ouch4
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("cloneTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "listNamespaces failed: unknown result")
 
-  def process_compactTable(self, seqid, iprot, oprot):
-    args = compactTable_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = compactTable_result()
-    try:
-      self._handler.compactTable(args.login, args.tableName, args.startRow, args.endRow, args.iterators, args.flush, args.wait, args.compactionStrategy)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloSecurityException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except TableNotFoundException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except AccumuloException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("compactTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def namespaceExists(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    self.send_namespaceExists(login, namespaceName)
+    return self.recv_namespaceExists()
 
-  def process_cancelCompaction(self, seqid, iprot, oprot):
-    args = cancelCompaction_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = cancelCompaction_result()
-    try:
-      self._handler.cancelCompaction(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloSecurityException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except TableNotFoundException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except AccumuloException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("cancelCompaction", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_namespaceExists(self, login, namespaceName):
+    self._oprot.writeMessageBegin('namespaceExists', TMessageType.CALL, self._seqid)
+    args = namespaceExists_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_createTable(self, seqid, iprot, oprot):
-    args = createTable_args()
-    args.read(iprot)
+  def recv_namespaceExists(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = namespaceExists_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = createTable_result()
-    try:
-      self._handler.createTable(args.login, args.tableName, args.versioningIter, args.type)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableExistsException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("createTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "namespaceExists failed: unknown result")
 
-  def process_deleteTable(self, seqid, iprot, oprot):
-    args = deleteTable_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = deleteTable_result()
-    try:
-      self._handler.deleteTable(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("deleteTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def createNamespace(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    self.send_createNamespace(login, namespaceName)
+    self.recv_createNamespace()
 
-  def process_deleteRows(self, seqid, iprot, oprot):
-    args = deleteRows_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = deleteRows_result()
-    try:
-      self._handler.deleteRows(args.login, args.tableName, args.startRow, args.endRow)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("deleteRows", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_createNamespace(self, login, namespaceName):
+    self._oprot.writeMessageBegin('createNamespace', TMessageType.CALL, self._seqid)
+    args = createNamespace_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_exportTable(self, seqid, iprot, oprot):
-    args = exportTable_args()
-    args.read(iprot)
+  def recv_createNamespace(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = createNamespace_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = exportTable_result()
-    try:
-      self._handler.exportTable(args.login, args.tableName, args.exportDir)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("exportTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
 
-  def process_flushTable(self, seqid, iprot, oprot):
-    args = flushTable_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = flushTable_result()
-    try:
-      self._handler.flushTable(args.login, args.tableName, args.startRow, args.endRow, args.wait)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("flushTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def deleteNamespace(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    self.send_deleteNamespace(login, namespaceName)
+    self.recv_deleteNamespace()
 
-  def process_getDiskUsage(self, seqid, iprot, oprot):
-    args = getDiskUsage_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getDiskUsage_result()
-    try:
-      result.success = self._handler.getDiskUsage(args.login, args.tables)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getDiskUsage", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_deleteNamespace(self, login, namespaceName):
+    self._oprot.writeMessageBegin('deleteNamespace', TMessageType.CALL, self._seqid)
+    args = deleteNamespace_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_getLocalityGroups(self, seqid, iprot, oprot):
-    args = getLocalityGroups_args()
-    args.read(iprot)
+  def recv_deleteNamespace(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = deleteNamespace_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = getLocalityGroups_result()
-    try:
-      result.success = self._handler.getLocalityGroups(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getLocalityGroups", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    if result.ouch4 is not None:
+      raise result.ouch4
+    return
 
-  def process_getIteratorSetting(self, seqid, iprot, oprot):
-    args = getIteratorSetting_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getIteratorSetting_result()
-    try:
-      result.success = self._handler.getIteratorSetting(args.login, args.tableName, args.iteratorName, args.scope)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getIteratorSetting", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def renameNamespace(self, login, oldNamespaceName, newNamespaceName):
+    """
+    Parameters:
+     - login
+     - oldNamespaceName
+     - newNamespaceName
+    """
+    self.send_renameNamespace(login, oldNamespaceName, newNamespaceName)
+    self.recv_renameNamespace()
 
-  def process_getMaxRow(self, seqid, iprot, oprot):
-    args = getMaxRow_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getMaxRow_result()
-    try:
-      result.success = self._handler.getMaxRow(args.login, args.tableName, args.auths, args.startRow, args.startInclusive, args.endRow, args.endInclusive)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getMaxRow", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_renameNamespace(self, login, oldNamespaceName, newNamespaceName):
+    self._oprot.writeMessageBegin('renameNamespace', TMessageType.CALL, self._seqid)
+    args = renameNamespace_args()
+    args.login = login
+    args.oldNamespaceName = oldNamespaceName
+    args.newNamespaceName = newNamespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_getTableProperties(self, seqid, iprot, oprot):
-    args = getTableProperties_args()
-    args.read(iprot)
+  def recv_renameNamespace(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = renameNamespace_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = getTableProperties_result()
-    try:
-      result.success = self._handler.getTableProperties(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getTableProperties", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    if result.ouch4 is not None:
+      raise result.ouch4
+    return
 
-  def process_importDirectory(self, seqid, iprot, oprot):
-    args = importDirectory_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = importDirectory_result()
-    try:
-      self._handler.importDirectory(args.login, args.tableName, args.importDir, args.failureDir, args.setTime)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except TableNotFoundException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except AccumuloSecurityException as ouch4:
-      msg_type = TMessageType.REPLY
-      result.ouch4 = ouch4
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("importDirectory", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def setNamespaceProperty(self, login, namespaceName, property, value):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - property
+     - value
+    """
+    self.send_setNamespaceProperty(login, namespaceName, property, value)
+    self.recv_setNamespaceProperty()
 
-  def process_importTable(self, seqid, iprot, oprot):
-    args = importTable_args()
-    args.read(iprot)
+  def send_setNamespaceProperty(self, login, namespaceName, property, value):
+    self._oprot.writeMessageBegin('setNamespaceProperty', TMessageType.CALL, self._seqid)
+    args = setNamespaceProperty_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.property = property
+    args.value = value
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_setNamespaceProperty(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = setNamespaceProperty_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = importTable_result()
-    try:
-      self._handler.importTable(args.login, args.tableName, args.importDir)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except TableExistsException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except AccumuloSecurityException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("importTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
 
-  def process_listSplits(self, seqid, iprot, oprot):
-    args = listSplits_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = listSplits_result()
-    try:
-      result.success = self._handler.listSplits(args.login, args.tableName, args.maxSplits)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("listSplits", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def removeNamespaceProperty(self, login, namespaceName, property):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - property
+    """
+    self.send_removeNamespaceProperty(login, namespaceName, property)
+    self.recv_removeNamespaceProperty()
 
-  def process_listTables(self, seqid, iprot, oprot):
-    args = listTables_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = listTables_result()
-    try:
-      result.success = self._handler.listTables(args.login)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("listTables", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_removeNamespaceProperty(self, login, namespaceName, property):
+    self._oprot.writeMessageBegin('removeNamespaceProperty', TMessageType.CALL, self._seqid)
+    args = removeNamespaceProperty_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.property = property
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_listIterators(self, seqid, iprot, oprot):
-    args = listIterators_args()
-    args.read(iprot)
+  def recv_removeNamespaceProperty(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = removeNamespaceProperty_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = listIterators_result()
-    try:
-      result.success = self._handler.listIterators(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("listIterators", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
 
-  def process_listConstraints(self, seqid, iprot, oprot):
-    args = listConstraints_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = listConstraints_result()
-    try:
-      result.success = self._handler.listConstraints(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("listConstraints", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def getNamespaceProperties(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    self.send_getNamespaceProperties(login, namespaceName)
+    return self.recv_getNamespaceProperties()
 
-  def process_mergeTablets(self, seqid, iprot, oprot):
-    args = mergeTablets_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = mergeTablets_result()
-    try:
-      self._handler.mergeTablets(args.login, args.tableName, args.startRow, args.endRow)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("mergeTablets", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_getNamespaceProperties(self, login, namespaceName):
+    self._oprot.writeMessageBegin('getNamespaceProperties', TMessageType.CALL, self._seqid)
+    args = getNamespaceProperties_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_offlineTable(self, seqid, iprot, oprot):
-    args = offlineTable_args()
-    args.read(iprot)
+  def recv_getNamespaceProperties(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = getNamespaceProperties_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = offlineTable_result()
-    try:
-      self._handler.offlineTable(args.login, args.tableName, args.wait)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("offlineTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNamespaceProperties failed: unknown result")
 
-  def process_onlineTable(self, seqid, iprot, oprot):
-    args = onlineTable_args()
-    args.read(iprot)
+  def namespaceIdMap(self, login):
+    """
+    Parameters:
+     - login
+    """
+    self.send_namespaceIdMap(login)
+    return self.recv_namespaceIdMap()
+
+  def send_namespaceIdMap(self, login):
+    self._oprot.writeMessageBegin('namespaceIdMap', TMessageType.CALL, self._seqid)
+    args = namespaceIdMap_args()
+    args.login = login
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_namespaceIdMap(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = namespaceIdMap_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = onlineTable_result()
-    try:
-      self._handler.onlineTable(args.login, args.tableName, args.wait)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("onlineTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "namespaceIdMap failed: unknown result")
 
-  def process_removeConstraint(self, seqid, iprot, oprot):
-    args = removeConstraint_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = removeConstraint_result()
-    try:
-      self._handler.removeConstraint(args.login, args.tableName, args.constraint)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("removeConstraint", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def attachNamespaceIterator(self, login, namespaceName, setting, scopes):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - setting
+     - scopes
+    """
+    self.send_attachNamespaceIterator(login, namespaceName, setting, scopes)
+    self.recv_attachNamespaceIterator()
 
-  def process_removeIterator(self, seqid, iprot, oprot):
-    args = removeIterator_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = removeIterator_result()
-    try:
-      self._handler.removeIterator(args.login, args.tableName, args.iterName, args.scopes)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("removeIterator", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_attachNamespaceIterator(self, login, namespaceName, setting, scopes):
+    self._oprot.writeMessageBegin('attachNamespaceIterator', TMessageType.CALL, self._seqid)
+    args = attachNamespaceIterator_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.setting = setting
+    args.scopes = scopes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_removeTableProperty(self, seqid, iprot, oprot):
-    args = removeTableProperty_args()
-    args.read(iprot)
+  def recv_attachNamespaceIterator(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = attachNamespaceIterator_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = removeTableProperty_result()
-    try:
-      self._handler.removeTableProperty(args.login, args.tableName, args.property)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("removeTableProperty", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
 
-  def process_renameTable(self, seqid, iprot, oprot):
-    args = renameTable_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = renameTable_result()
-    try:
-      self._handler.renameTable(args.login, args.oldTableName, args.newTableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except TableExistsException as ouch4:
-      msg_type = TMessageType.REPLY
-      result.ouch4 = ouch4
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("renameTable", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def removeNamespaceIterator(self, login, namespaceName, name, scopes):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - name
+     - scopes
+    """
+    self.send_removeNamespaceIterator(login, namespaceName, name, scopes)
+    self.recv_removeNamespaceIterator()
 
-  def process_setLocalityGroups(self, seqid, iprot, oprot):
-    args = setLocalityGroups_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = setLocalityGroups_result()
-    try:
-      self._handler.setLocalityGroups(args.login, args.tableName, args.groups)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("setLocalityGroups", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_removeNamespaceIterator(self, login, namespaceName, name, scopes):
+    self._oprot.writeMessageBegin('removeNamespaceIterator', TMessageType.CALL, self._seqid)
+    args = removeNamespaceIterator_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.name = name
+    args.scopes = scopes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_setTableProperty(self, seqid, iprot, oprot):
-    args = setTableProperty_args()
-    args.read(iprot)
+  def recv_removeNamespaceIterator(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = removeNamespaceIterator_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = setTableProperty_result()
-    try:
-      self._handler.setTableProperty(args.login, args.tableName, args.property, args.value)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("setTableProperty", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
 
-  def process_splitRangeByTablets(self, seqid, iprot, oprot):
-    args = splitRangeByTablets_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = splitRangeByTablets_result()
-    try:
-      result.success = self._handler.splitRangeByTablets(args.login, args.tableName, args.range, args.maxSplits)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("splitRangeByTablets", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def getNamespaceIteratorSetting(self, login, namespaceName, name, scope):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - name
+     - scope
+    """
+    self.send_getNamespaceIteratorSetting(login, namespaceName, name, scope)
+    return self.recv_getNamespaceIteratorSetting()
 
-  def process_tableExists(self, seqid, iprot, oprot):
-    args = tableExists_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = tableExists_result()
-    try:
-      result.success = self._handler.tableExists(args.login, args.tableName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("tableExists", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_getNamespaceIteratorSetting(self, login, namespaceName, name, scope):
+    self._oprot.writeMessageBegin('getNamespaceIteratorSetting', TMessageType.CALL, self._seqid)
+    args = getNamespaceIteratorSetting_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.name = name
+    args.scope = scope
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_tableIdMap(self, seqid, iprot, oprot):
-    args = tableIdMap_args()
-    args.read(iprot)
+  def recv_getNamespaceIteratorSetting(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = getNamespaceIteratorSetting_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = tableIdMap_result()
-    try:
-      result.success = self._handler.tableIdMap(args.login)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("tableIdMap", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNamespaceIteratorSetting failed: unknown result")
 
-  def process_testTableClassLoad(self, seqid, iprot, oprot):
-    args = testTableClassLoad_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = testTableClassLoad_result()
-    try:
-      result.success = self._handler.testTableClassLoad(args.login, args.tableName, args.className, args.asTypeName)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except TableNotFoundException as ouch3:
-      msg_type = TMessageType.REPLY
-      result.ouch3 = ouch3
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("testTableClassLoad", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def listNamespaceIterators(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    self.send_listNamespaceIterators(login, namespaceName)
+    return self.recv_listNamespaceIterators()
 
-  def process_pingTabletServer(self, seqid, iprot, oprot):
-    args = pingTabletServer_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = pingTabletServer_result()
-    try:
-      self._handler.pingTabletServer(args.login, args.tserver)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("pingTabletServer", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_listNamespaceIterators(self, login, namespaceName):
+    self._oprot.writeMessageBegin('listNamespaceIterators', TMessageType.CALL, self._seqid)
+    args = listNamespaceIterators_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_getActiveScans(self, seqid, iprot, oprot):
-    args = getActiveScans_args()
-    args.read(iprot)
+  def recv_listNamespaceIterators(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = listNamespaceIterators_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = getActiveScans_result()
-    try:
-      result.success = self._handler.getActiveScans(args.login, args.tserver)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getActiveScans", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "listNamespaceIterators failed: unknown result")
 
-  def process_getActiveCompactions(self, seqid, iprot, oprot):
-    args = getActiveCompactions_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getActiveCompactions_result()
-    try:
-      result.success = self._handler.getActiveCompactions(args.login, args.tserver)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getActiveCompactions", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def checkNamespaceIteratorConflicts(self, login, namespaceName, setting, scopes):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - setting
+     - scopes
+    """
+    self.send_checkNamespaceIteratorConflicts(login, namespaceName, setting, scopes)
+    self.recv_checkNamespaceIteratorConflicts()
 
-  def process_getSiteConfiguration(self, seqid, iprot, oprot):
-    args = getSiteConfiguration_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = getSiteConfiguration_result()
-    try:
-      result.success = self._handler.getSiteConfiguration(args.login)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getSiteConfiguration", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+  def send_checkNamespaceIteratorConflicts(self, login, namespaceName, setting, scopes):
+    self._oprot.writeMessageBegin('checkNamespaceIteratorConflicts', TMessageType.CALL, self._seqid)
+    args = checkNamespaceIteratorConflicts_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.setting = setting
+    args.scopes = scopes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
 
-  def process_getSystemConfiguration(self, seqid, iprot, oprot):
-    args = getSystemConfiguration_args()
-    args.read(iprot)
+  def recv_checkNamespaceIteratorConflicts(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = checkNamespaceIteratorConflicts_result()
+    result.read(iprot)
     iprot.readMessageEnd()
-    result = getSystemConfiguration_result()
-    try:
-      result.success = self._handler.getSystemConfiguration(args.login)
-      msg_type = TMessageType.REPLY
-    except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
-      raise
-    except AccumuloException as ouch1:
-      msg_type = TMessageType.REPLY
-      result.ouch1 = ouch1
-    except AccumuloSecurityException as ouch2:
-      msg_type = TMessageType.REPLY
-      result.ouch2 = ouch2
-    except Exception as ex:
-      msg_type = TMessageType.EXCEPTION
-      logging.exception(ex)
-      result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
-    oprot.writeMessageBegin("getSystemConfiguration", msg_type, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
 
-  def process_getTabletServers(self, seqid, iprot, oprot):
-    args = getTabletServers_args()
+  def addNamespaceConstraint(self, login, namespaceName, constraintClassName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - constraintClassName
+    """
+    self.send_addNamespaceConstraint(login, namespaceName, constraintClassName)
+    return self.recv_addNamespaceConstraint()
+
+  def send_addNamespaceConstraint(self, login, namespaceName, constraintClassName):
+    self._oprot.writeMessageBegin('addNamespaceConstraint', TMessageType.CALL, self._seqid)
+    args = addNamespaceConstraint_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.constraintClassName = constraintClassName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_addNamespaceConstraint(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = addNamespaceConstraint_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addNamespaceConstraint failed: unknown result")
+
+  def removeNamespaceConstraint(self, login, namespaceName, id):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - id
+    """
+    self.send_removeNamespaceConstraint(login, namespaceName, id)
+    self.recv_removeNamespaceConstraint()
+
+  def send_removeNamespaceConstraint(self, login, namespaceName, id):
+    self._oprot.writeMessageBegin('removeNamespaceConstraint', TMessageType.CALL, self._seqid)
+    args = removeNamespaceConstraint_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_removeNamespaceConstraint(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = removeNamespaceConstraint_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    return
+
+  def listNamespaceConstraints(self, login, namespaceName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+    """
+    self.send_listNamespaceConstraints(login, namespaceName)
+    return self.recv_listNamespaceConstraints()
+
+  def send_listNamespaceConstraints(self, login, namespaceName):
+    self._oprot.writeMessageBegin('listNamespaceConstraints', TMessageType.CALL, self._seqid)
+    args = listNamespaceConstraints_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_listNamespaceConstraints(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = listNamespaceConstraints_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "listNamespaceConstraints failed: unknown result")
+
+  def testNamespaceClassLoad(self, login, namespaceName, className, asTypeName):
+    """
+    Parameters:
+     - login
+     - namespaceName
+     - className
+     - asTypeName
+    """
+    self.send_testNamespaceClassLoad(login, namespaceName, className, asTypeName)
+    return self.recv_testNamespaceClassLoad()
+
+  def send_testNamespaceClassLoad(self, login, namespaceName, className, asTypeName):
+    self._oprot.writeMessageBegin('testNamespaceClassLoad', TMessageType.CALL, self._seqid)
+    args = testNamespaceClassLoad_args()
+    args.login = login
+    args.namespaceName = namespaceName
+    args.className = className
+    args.asTypeName = asTypeName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_testNamespaceClassLoad(self):
+    iprot = self._iprot
+    (fname, mtype, rseqid) = iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(iprot)
+      iprot.readMessageEnd()
+      raise x
+    result = testNamespaceClassLoad_result()
+    result.read(iprot)
+    iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.ouch1 is not None:
+      raise result.ouch1
+    if result.ouch2 is not None:
+      raise result.ouch2
+    if result.ouch3 is not None:
+      raise result.ouch3
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "testNamespaceClassLoad failed: unknown result")
+
+
+class Processor(Iface, TProcessor):
+  def __init__(self, handler):
+    self._handler = handler
+    self._processMap = {}
+    self._processMap["login"] = Processor.process_login
+    self._processMap["addConstraint"] = Processor.process_addConstraint
+    self._processMap["addSplits"] = Processor.process_addSplits
+    self._processMap["attachIterator"] = Processor.process_attachIterator
+    self._processMap["checkIteratorConflicts"] = Processor.process_checkIteratorConflicts
+    self._processMap["clearLocatorCache"] = Processor.process_clearLocatorCache
+    self._processMap["cloneTable"] = Processor.process_cloneTable
+    self._processMap["compactTable"] = Processor.process_compactTable
+    self._processMap["cancelCompaction"] = Processor.process_cancelCompaction
+    self._processMap["createTable"] = Processor.process_createTable
+    self._processMap["deleteTable"] = Processor.process_deleteTable
+    self._processMap["deleteRows"] = Processor.process_deleteRows
+    self._processMap["exportTable"] = Processor.process_exportTable
+    self._processMap["flushTable"] = Processor.process_flushTable
+    self._processMap["getDiskUsage"] = Processor.process_getDiskUsage
+    self._processMap["getLocalityGroups"] = Processor.process_getLocalityGroups
+    self._processMap["getIteratorSetting"] = Processor.process_getIteratorSetting
+    self._processMap["getMaxRow"] = Processor.process_getMaxRow
+    self._processMap["getTableProperties"] = Processor.process_getTableProperties
+    self._processMap["importDirectory"] = Processor.process_importDirectory
+    self._processMap["importTable"] = Processor.process_importTable
+    self._processMap["listSplits"] = Processor.process_listSplits
+    self._processMap["listTables"] = Processor.process_listTables
+    self._processMap["listIterators"] = Processor.process_listIterators
+    self._processMap["listConstraints"] = Processor.process_listConstraints
+    self._processMap["mergeTablets"] = Processor.process_mergeTablets
+    self._processMap["offlineTable"] = Processor.process_offlineTable
+    self._processMap["onlineTable"] = Processor.process_onlineTable
+    self._processMap["removeConstraint"] = Processor.process_removeConstraint
+    self._processMap["removeIterator"] = Processor.process_removeIterator
+    self._processMap["removeTableProperty"] = Processor.process_removeTableProperty
+    self._processMap["renameTable"] = Processor.process_renameTable
+    self._processMap["setLocalityGroups"] = Processor.process_setLocalityGroups
+    self._processMap["setTableProperty"] = Processor.process_setTableProperty
+    self._processMap["splitRangeByTablets"] = Processor.process_splitRangeByTablets
+    self._processMap["tableExists"] = Processor.process_tableExists
+    self._processMap["tableIdMap"] = Processor.process_tableIdMap
+    self._processMap["testTableClassLoad"] = Processor.process_testTableClassLoad
+    self._processMap["pingTabletServer"] = Processor.process_pingTabletServer
+    self._processMap["getActiveScans"] = Processor.process_getActiveScans
+    self._processMap["getActiveCompactions"] = Processor.process_getActiveCompactions
+    self._processMap["getSiteConfiguration"] = Processor.process_getSiteConfiguration
+    self._processMap["getSystemConfiguration"] = Processor.process_getSystemConfiguration
+    self._processMap["getTabletServers"] = Processor.process_getTabletServers
+    self._processMap["removeProperty"] = Processor.process_removeProperty
+    self._processMap["setProperty"] = Processor.process_setProperty
+    self._processMap["testClassLoad"] = Processor.process_testClassLoad
+    self._processMap["authenticateUser"] = Processor.process_authenticateUser
+    self._processMap["changeUserAuthorizations"] = Processor.process_changeUserAuthorizations
+    self._processMap["changeLocalUserPassword"] = Processor.process_changeLocalUserPassword
+    self._processMap["createLocalUser"] = Processor.process_createLocalUser
+    self._processMap["dropLocalUser"] = Processor.process_dropLocalUser
+    self._processMap["getUserAuthorizations"] = Processor.process_getUserAuthorizations
+    self._processMap["grantSystemPermission"] = Processor.process_grantSystemPermission
+    self._processMap["grantTablePermission"] = Processor.process_grantTablePermission
+    self._processMap["hasSystemPermission"] = Processor.process_hasSystemPermission
+    self._processMap["hasTablePermission"] = Processor.process_hasTablePermission
+    self._processMap["listLocalUsers"] = Processor.process_listLocalUsers
+    self._processMap["revokeSystemPermission"] = Processor.process_revokeSystemPermission
+    self._processMap["revokeTablePermission"] = Processor.process_revokeTablePermission
+    self._processMap["grantNamespacePermission"] = Processor.process_grantNamespacePermission
+    self._processMap["hasNamespacePermission"] = Processor.process_hasNamespacePermission
+    self._processMap["revokeNamespacePermission"] = Processor.process_revokeNamespacePermission
+    self._processMap["createBatchScanner"] = Processor.process_createBatchScanner
+    self._processMap["createScanner"] = Processor.process_createScanner
+    self._processMap["hasNext"] = Processor.process_hasNext
+    self._processMap["nextEntry"] = Processor.process_nextEntry
+    self._processMap["nextK"] = Processor.process_nextK
+    self._processMap["closeScanner"] = Processor.process_closeScanner
+    self._processMap["updateAndFlush"] = Processor.process_updateAndFlush
+    self._processMap["createWriter"] = Processor.process_createWriter
+    self._processMap["update"] = Processor.process_update
+    self._processMap["flush"] = Processor.process_flush
+    self._processMap["closeWriter"] = Processor.process_closeWriter
+    self._processMap["updateRowConditionally"] = Processor.process_updateRowConditionally
+    self._processMap["createConditionalWriter"] = Processor.process_createConditionalWriter
+    self._processMap["updateRowsConditionally"] = 

<TRUNCATED>

Mime
View raw message