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>
