Return-Path: X-Original-To: apmail-accumulo-commits-archive@www.apache.org Delivered-To: apmail-accumulo-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 8ADB21099A for ; Wed, 4 Dec 2013 23:57:55 +0000 (UTC) Received: (qmail 40340 invoked by uid 500); 4 Dec 2013 23:57:55 -0000 Delivered-To: apmail-accumulo-commits-archive@accumulo.apache.org Received: (qmail 40212 invoked by uid 500); 4 Dec 2013 23:57:55 -0000 Mailing-List: contact commits-help@accumulo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@accumulo.apache.org Delivered-To: mailing list commits@accumulo.apache.org Received: (qmail 40056 invoked by uid 99); 4 Dec 2013 23:57:55 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 04 Dec 2013 23:57:55 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id E14DA320247; Wed, 4 Dec 2013 23:57:54 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: ctubbsii@apache.org To: commits@accumulo.apache.org Date: Wed, 04 Dec 2013 23:58:04 -0000 Message-Id: <4a0259c1d9bd44e6bfcd3540959f67c1@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [12/50] [abbrv] ACCUMULO-1479 implemented most of Table Namespace Permissions, doesnt entirely work, not well tested http://git-wip-us.apache.org/repos/asf/accumulo/blob/dfdf5113/core/src/main/java/org/apache/accumulo/core/client/impl/thrift/ClientService.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/accumulo/core/client/impl/thrift/ClientService.java b/core/src/main/java/org/apache/accumulo/core/client/impl/thrift/ClientService.java index b857c27..3ccb234 100644 --- a/core/src/main/java/org/apache/accumulo/core/client/impl/thrift/ClientService.java +++ b/core/src/main/java/org/apache/accumulo/core/client/impl/thrift/ClientService.java @@ -84,6 +84,8 @@ import org.slf4j.LoggerFactory; public boolean hasTablePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableName, byte tblPerm) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException; + public boolean hasTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte tblNspcPerm) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException; + public void grantSystemPermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, byte permission) throws ThriftSecurityException, org.apache.thrift.TException; public void revokeSystemPermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, byte permission) throws ThriftSecurityException, org.apache.thrift.TException; @@ -92,6 +94,10 @@ import org.slf4j.LoggerFactory; public void revokeTablePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableName, byte permission) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException; + public void grantTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException; + + public void revokeTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException; + public Map getConfiguration(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, ConfigurationType type) throws org.apache.thrift.TException; public Map getTableConfiguration(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String tableName) throws ThriftTableOperationException, org.apache.thrift.TException; @@ -142,6 +148,8 @@ import org.slf4j.LoggerFactory; public void hasTablePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableName, byte tblPerm, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void hasTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte tblNspcPerm, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void grantSystemPermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void revokeSystemPermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -150,6 +158,10 @@ import org.slf4j.LoggerFactory; public void revokeTablePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableName, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void grantTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void revokeTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void getConfiguration(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, ConfigurationType type, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void getTableConfiguration(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String tableName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -637,6 +649,39 @@ import org.slf4j.LoggerFactory; throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "hasTablePermission failed: unknown result"); } + public boolean hasTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte tblNspcPerm) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException + { + send_hasTableNamespacePermission(tinfo, credentials, principal, tableNamespace, tblNspcPerm); + return recv_hasTableNamespacePermission(); + } + + public void send_hasTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte tblNspcPerm) throws org.apache.thrift.TException + { + hasTableNamespacePermission_args args = new hasTableNamespacePermission_args(); + args.setTinfo(tinfo); + args.setCredentials(credentials); + args.setPrincipal(principal); + args.setTableNamespace(tableNamespace); + args.setTblNspcPerm(tblNspcPerm); + sendBase("hasTableNamespacePermission", args); + } + + public boolean recv_hasTableNamespacePermission() throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException + { + hasTableNamespacePermission_result result = new hasTableNamespacePermission_result(); + receiveBase(result, "hasTableNamespacePermission"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.sec != null) { + throw result.sec; + } + if (result.tope != null) { + throw result.tope; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "hasTableNamespacePermission failed: unknown result"); + } + public void grantSystemPermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, byte permission) throws ThriftSecurityException, org.apache.thrift.TException { send_grantSystemPermission(tinfo, credentials, principal, permission); @@ -749,6 +794,66 @@ import org.slf4j.LoggerFactory; return; } + public void grantTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException + { + send_grantTableNamespacePermission(tinfo, credentials, principal, tableNamespace, permission); + recv_grantTableNamespacePermission(); + } + + public void send_grantTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission) throws org.apache.thrift.TException + { + grantTableNamespacePermission_args args = new grantTableNamespacePermission_args(); + args.setTinfo(tinfo); + args.setCredentials(credentials); + args.setPrincipal(principal); + args.setTableNamespace(tableNamespace); + args.setPermission(permission); + sendBase("grantTableNamespacePermission", args); + } + + public void recv_grantTableNamespacePermission() throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException + { + grantTableNamespacePermission_result result = new grantTableNamespacePermission_result(); + receiveBase(result, "grantTableNamespacePermission"); + if (result.sec != null) { + throw result.sec; + } + if (result.tope != null) { + throw result.tope; + } + return; + } + + public void revokeTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission) throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException + { + send_revokeTableNamespacePermission(tinfo, credentials, principal, tableNamespace, permission); + recv_revokeTableNamespacePermission(); + } + + public void send_revokeTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission) throws org.apache.thrift.TException + { + revokeTableNamespacePermission_args args = new revokeTableNamespacePermission_args(); + args.setTinfo(tinfo); + args.setCredentials(credentials); + args.setPrincipal(principal); + args.setTableNamespace(tableNamespace); + args.setPermission(permission); + sendBase("revokeTableNamespacePermission", args); + } + + public void recv_revokeTableNamespacePermission() throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException + { + revokeTableNamespacePermission_result result = new revokeTableNamespacePermission_result(); + receiveBase(result, "revokeTableNamespacePermission"); + if (result.sec != null) { + throw result.sec; + } + if (result.tope != null) { + throw result.tope; + } + return; + } + public Map getConfiguration(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, ConfigurationType type) throws org.apache.thrift.TException { send_getConfiguration(tinfo, credentials, type); @@ -1571,6 +1676,50 @@ import org.slf4j.LoggerFactory; } } + public void hasTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte tblNspcPerm, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + hasTableNamespacePermission_call method_call = new hasTableNamespacePermission_call(tinfo, credentials, principal, tableNamespace, tblNspcPerm, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class hasTableNamespacePermission_call extends org.apache.thrift.async.TAsyncMethodCall { + private org.apache.accumulo.trace.thrift.TInfo tinfo; + private org.apache.accumulo.core.security.thrift.TCredentials credentials; + private String principal; + private String tableNamespace; + private byte tblNspcPerm; + public hasTableNamespacePermission_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte tblNspcPerm, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tinfo = tinfo; + this.credentials = credentials; + this.principal = principal; + this.tableNamespace = tableNamespace; + this.tblNspcPerm = tblNspcPerm; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("hasTableNamespacePermission", org.apache.thrift.protocol.TMessageType.CALL, 0)); + hasTableNamespacePermission_args args = new hasTableNamespacePermission_args(); + args.setTinfo(tinfo); + args.setCredentials(credentials); + args.setPrincipal(principal); + args.setTableNamespace(tableNamespace); + args.setTblNspcPerm(tblNspcPerm); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_hasTableNamespacePermission(); + } + } + public void grantSystemPermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); grantSystemPermission_call method_call = new grantSystemPermission_call(tinfo, credentials, principal, permission, resultHandler, this, ___protocolFactory, ___transport); @@ -1741,6 +1890,94 @@ import org.slf4j.LoggerFactory; } } + public void grantTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + grantTableNamespacePermission_call method_call = new grantTableNamespacePermission_call(tinfo, credentials, principal, tableNamespace, permission, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class grantTableNamespacePermission_call extends org.apache.thrift.async.TAsyncMethodCall { + private org.apache.accumulo.trace.thrift.TInfo tinfo; + private org.apache.accumulo.core.security.thrift.TCredentials credentials; + private String principal; + private String tableNamespace; + private byte permission; + public grantTableNamespacePermission_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tinfo = tinfo; + this.credentials = credentials; + this.principal = principal; + this.tableNamespace = tableNamespace; + this.permission = permission; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("grantTableNamespacePermission", org.apache.thrift.protocol.TMessageType.CALL, 0)); + grantTableNamespacePermission_args args = new grantTableNamespacePermission_args(); + args.setTinfo(tinfo); + args.setCredentials(credentials); + args.setPrincipal(principal); + args.setTableNamespace(tableNamespace); + args.setPermission(permission); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_grantTableNamespacePermission(); + } + } + + public void revokeTableNamespacePermission(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + revokeTableNamespacePermission_call method_call = new revokeTableNamespacePermission_call(tinfo, credentials, principal, tableNamespace, permission, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class revokeTableNamespacePermission_call extends org.apache.thrift.async.TAsyncMethodCall { + private org.apache.accumulo.trace.thrift.TInfo tinfo; + private org.apache.accumulo.core.security.thrift.TCredentials credentials; + private String principal; + private String tableNamespace; + private byte permission; + public revokeTableNamespacePermission_call(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, String tableNamespace, byte permission, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tinfo = tinfo; + this.credentials = credentials; + this.principal = principal; + this.tableNamespace = tableNamespace; + this.permission = permission; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("revokeTableNamespacePermission", org.apache.thrift.protocol.TMessageType.CALL, 0)); + revokeTableNamespacePermission_args args = new revokeTableNamespacePermission_args(); + args.setTinfo(tinfo); + args.setCredentials(credentials); + args.setPrincipal(principal); + args.setTableNamespace(tableNamespace); + args.setPermission(permission); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws ThriftSecurityException, ThriftTableOperationException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_revokeTableNamespacePermission(); + } + } + public void getConfiguration(org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, ConfigurationType type, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); getConfiguration_call method_call = new getConfiguration_call(tinfo, credentials, type, resultHandler, this, ___protocolFactory, ___transport); @@ -2014,10 +2251,13 @@ import org.slf4j.LoggerFactory; processMap.put("getUserAuthorizations", new getUserAuthorizations()); processMap.put("hasSystemPermission", new hasSystemPermission()); processMap.put("hasTablePermission", new hasTablePermission()); + processMap.put("hasTableNamespacePermission", new hasTableNamespacePermission()); processMap.put("grantSystemPermission", new grantSystemPermission()); processMap.put("revokeSystemPermission", new revokeSystemPermission()); processMap.put("grantTablePermission", new grantTablePermission()); processMap.put("revokeTablePermission", new revokeTablePermission()); + processMap.put("grantTableNamespacePermission", new grantTableNamespacePermission()); + processMap.put("revokeTableNamespacePermission", new revokeTableNamespacePermission()); processMap.put("getConfiguration", new getConfiguration()); processMap.put("getTableConfiguration", new getTableConfiguration()); processMap.put("getTableNamespaceConfiguration", new getTableNamespaceConfiguration()); @@ -2430,6 +2670,33 @@ import org.slf4j.LoggerFactory; } } + public static class hasTableNamespacePermission extends org.apache.thrift.ProcessFunction { + public hasTableNamespacePermission() { + super("hasTableNamespacePermission"); + } + + public hasTableNamespacePermission_args getEmptyArgsInstance() { + return new hasTableNamespacePermission_args(); + } + + protected boolean isOneway() { + return false; + } + + public hasTableNamespacePermission_result getResult(I iface, hasTableNamespacePermission_args args) throws org.apache.thrift.TException { + hasTableNamespacePermission_result result = new hasTableNamespacePermission_result(); + try { + result.success = iface.hasTableNamespacePermission(args.tinfo, args.credentials, args.principal, args.tableNamespace, args.tblNspcPerm); + result.setSuccessIsSet(true); + } catch (ThriftSecurityException sec) { + result.sec = sec; + } catch (ThriftTableOperationException tope) { + result.tope = tope; + } + return result; + } + } + public static class grantSystemPermission extends org.apache.thrift.ProcessFunction { public grantSystemPermission() { super("grantSystemPermission"); @@ -2530,6 +2797,58 @@ import org.slf4j.LoggerFactory; } } + public static class grantTableNamespacePermission extends org.apache.thrift.ProcessFunction { + public grantTableNamespacePermission() { + super("grantTableNamespacePermission"); + } + + public grantTableNamespacePermission_args getEmptyArgsInstance() { + return new grantTableNamespacePermission_args(); + } + + protected boolean isOneway() { + return false; + } + + public grantTableNamespacePermission_result getResult(I iface, grantTableNamespacePermission_args args) throws org.apache.thrift.TException { + grantTableNamespacePermission_result result = new grantTableNamespacePermission_result(); + try { + iface.grantTableNamespacePermission(args.tinfo, args.credentials, args.principal, args.tableNamespace, args.permission); + } catch (ThriftSecurityException sec) { + result.sec = sec; + } catch (ThriftTableOperationException tope) { + result.tope = tope; + } + return result; + } + } + + public static class revokeTableNamespacePermission extends org.apache.thrift.ProcessFunction { + public revokeTableNamespacePermission() { + super("revokeTableNamespacePermission"); + } + + public revokeTableNamespacePermission_args getEmptyArgsInstance() { + return new revokeTableNamespacePermission_args(); + } + + protected boolean isOneway() { + return false; + } + + public revokeTableNamespacePermission_result getResult(I iface, revokeTableNamespacePermission_args args) throws org.apache.thrift.TException { + revokeTableNamespacePermission_result result = new revokeTableNamespacePermission_result(); + try { + iface.revokeTableNamespacePermission(args.tinfo, args.credentials, args.principal, args.tableNamespace, args.permission); + } catch (ThriftSecurityException sec) { + result.sec = sec; + } catch (ThriftTableOperationException tope) { + result.tope = tope; + } + return result; + } + } + public static class getConfiguration extends org.apache.thrift.ProcessFunction { public getConfiguration() { super("getConfiguration"); @@ -19227,31 +19546,34 @@ import org.slf4j.LoggerFactory; } - public static class grantSystemPermission_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("grantSystemPermission_args"); + public static class hasTableNamespacePermission_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("hasTableNamespacePermission_args"); - private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)4); - private static final org.apache.thrift.protocol.TField CREDENTIALS_FIELD_DESC = new org.apache.thrift.protocol.TField("credentials", org.apache.thrift.protocol.TType.STRUCT, (short)5); - private static final org.apache.thrift.protocol.TField PRINCIPAL_FIELD_DESC = new org.apache.thrift.protocol.TField("principal", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField PERMISSION_FIELD_DESC = new org.apache.thrift.protocol.TField("permission", org.apache.thrift.protocol.TType.BYTE, (short)3); + private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField CREDENTIALS_FIELD_DESC = new org.apache.thrift.protocol.TField("credentials", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField PRINCIPAL_FIELD_DESC = new org.apache.thrift.protocol.TField("principal", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField TABLE_NAMESPACE_FIELD_DESC = new org.apache.thrift.protocol.TField("tableNamespace", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField TBL_NSPC_PERM_FIELD_DESC = new org.apache.thrift.protocol.TField("tblNspcPerm", org.apache.thrift.protocol.TType.BYTE, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new grantSystemPermission_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new grantSystemPermission_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new hasTableNamespacePermission_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new hasTableNamespacePermission_argsTupleSchemeFactory()); } public org.apache.accumulo.trace.thrift.TInfo tinfo; // required public org.apache.accumulo.core.security.thrift.TCredentials credentials; // required public String principal; // required - public byte permission; // required + public String tableNamespace; // required + public byte tblNspcPerm; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum { - TINFO((short)4, "tinfo"), - CREDENTIALS((short)5, "credentials"), - PRINCIPAL((short)2, "principal"), - PERMISSION((short)3, "permission"); + TINFO((short)1, "tinfo"), + CREDENTIALS((short)2, "credentials"), + PRINCIPAL((short)3, "principal"), + TABLE_NAMESPACE((short)4, "tableNamespace"), + TBL_NSPC_PERM((short)5, "tblNspcPerm"); private static final Map byName = new HashMap(); @@ -19266,14 +19588,16 @@ import org.slf4j.LoggerFactory; */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 4: // TINFO + case 1: // TINFO return TINFO; - case 5: // CREDENTIALS + case 2: // CREDENTIALS return CREDENTIALS; - case 2: // PRINCIPAL + case 3: // PRINCIPAL return PRINCIPAL; - case 3: // PERMISSION - return PERMISSION; + case 4: // TABLE_NAMESPACE + return TABLE_NAMESPACE; + case 5: // TBL_NSPC_PERM + return TBL_NSPC_PERM; default: return null; } @@ -19314,7 +19638,7 @@ import org.slf4j.LoggerFactory; } // isset id assignments - private static final int __PERMISSION_ISSET_ID = 0; + private static final int __TBLNSPCPERM_ISSET_ID = 0; private byte __isset_bitfield = 0; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { @@ -19325,33 +19649,37 @@ import org.slf4j.LoggerFactory; new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.TCredentials.class))); tmpMap.put(_Fields.PRINCIPAL, new org.apache.thrift.meta_data.FieldMetaData("principal", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PERMISSION, new org.apache.thrift.meta_data.FieldMetaData("permission", org.apache.thrift.TFieldRequirementType.DEFAULT, + tmpMap.put(_Fields.TABLE_NAMESPACE, new org.apache.thrift.meta_data.FieldMetaData("tableNamespace", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TBL_NSPC_PERM, new org.apache.thrift.meta_data.FieldMetaData("tblNspcPerm", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(grantSystemPermission_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(hasTableNamespacePermission_args.class, metaDataMap); } - public grantSystemPermission_args() { + public hasTableNamespacePermission_args() { } - public grantSystemPermission_args( + public hasTableNamespacePermission_args( org.apache.accumulo.trace.thrift.TInfo tinfo, org.apache.accumulo.core.security.thrift.TCredentials credentials, String principal, - byte permission) + String tableNamespace, + byte tblNspcPerm) { this(); this.tinfo = tinfo; this.credentials = credentials; this.principal = principal; - this.permission = permission; - setPermissionIsSet(true); + this.tableNamespace = tableNamespace; + this.tblNspcPerm = tblNspcPerm; + setTblNspcPermIsSet(true); } /** * Performs a deep copy on other. */ - public grantSystemPermission_args(grantSystemPermission_args other) { + public hasTableNamespacePermission_args(hasTableNamespacePermission_args other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetTinfo()) { this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo); @@ -19362,11 +19690,3370 @@ import org.slf4j.LoggerFactory; if (other.isSetPrincipal()) { this.principal = other.principal; } - this.permission = other.permission; + if (other.isSetTableNamespace()) { + this.tableNamespace = other.tableNamespace; + } + this.tblNspcPerm = other.tblNspcPerm; + } + + public hasTableNamespacePermission_args deepCopy() { + return new hasTableNamespacePermission_args(this); + } + + @Override + public void clear() { + this.tinfo = null; + this.credentials = null; + this.principal = null; + this.tableNamespace = null; + setTblNspcPermIsSet(false); + this.tblNspcPerm = 0; + } + + public org.apache.accumulo.trace.thrift.TInfo getTinfo() { + return this.tinfo; + } + + public hasTableNamespacePermission_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) { + this.tinfo = tinfo; + return this; + } + + public void unsetTinfo() { + this.tinfo = null; + } + + /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */ + public boolean isSetTinfo() { + return this.tinfo != null; + } + + public void setTinfoIsSet(boolean value) { + if (!value) { + this.tinfo = null; + } + } + + public org.apache.accumulo.core.security.thrift.TCredentials getCredentials() { + return this.credentials; + } + + public hasTableNamespacePermission_args setCredentials(org.apache.accumulo.core.security.thrift.TCredentials credentials) { + this.credentials = credentials; + return this; + } + + public void unsetCredentials() { + this.credentials = null; + } + + /** Returns true if field credentials is set (has been assigned a value) and false otherwise */ + public boolean isSetCredentials() { + return this.credentials != null; + } + + public void setCredentialsIsSet(boolean value) { + if (!value) { + this.credentials = null; + } + } + + public String getPrincipal() { + return this.principal; + } + + public hasTableNamespacePermission_args setPrincipal(String principal) { + this.principal = principal; + return this; + } + + public void unsetPrincipal() { + this.principal = null; + } + + /** Returns true if field principal is set (has been assigned a value) and false otherwise */ + public boolean isSetPrincipal() { + return this.principal != null; + } + + public void setPrincipalIsSet(boolean value) { + if (!value) { + this.principal = null; + } + } + + public String getTableNamespace() { + return this.tableNamespace; + } + + public hasTableNamespacePermission_args setTableNamespace(String tableNamespace) { + this.tableNamespace = tableNamespace; + return this; + } + + public void unsetTableNamespace() { + this.tableNamespace = null; + } + + /** Returns true if field tableNamespace is set (has been assigned a value) and false otherwise */ + public boolean isSetTableNamespace() { + return this.tableNamespace != null; + } + + public void setTableNamespaceIsSet(boolean value) { + if (!value) { + this.tableNamespace = null; + } + } + + public byte getTblNspcPerm() { + return this.tblNspcPerm; + } + + public hasTableNamespacePermission_args setTblNspcPerm(byte tblNspcPerm) { + this.tblNspcPerm = tblNspcPerm; + setTblNspcPermIsSet(true); + return this; + } + + public void unsetTblNspcPerm() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TBLNSPCPERM_ISSET_ID); + } + + /** Returns true if field tblNspcPerm is set (has been assigned a value) and false otherwise */ + public boolean isSetTblNspcPerm() { + return EncodingUtils.testBit(__isset_bitfield, __TBLNSPCPERM_ISSET_ID); + } + + public void setTblNspcPermIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TBLNSPCPERM_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TINFO: + if (value == null) { + unsetTinfo(); + } else { + setTinfo((org.apache.accumulo.trace.thrift.TInfo)value); + } + break; + + case CREDENTIALS: + if (value == null) { + unsetCredentials(); + } else { + setCredentials((org.apache.accumulo.core.security.thrift.TCredentials)value); + } + break; + + case PRINCIPAL: + if (value == null) { + unsetPrincipal(); + } else { + setPrincipal((String)value); + } + break; + + case TABLE_NAMESPACE: + if (value == null) { + unsetTableNamespace(); + } else { + setTableNamespace((String)value); + } + break; + + case TBL_NSPC_PERM: + if (value == null) { + unsetTblNspcPerm(); + } else { + setTblNspcPerm((Byte)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TINFO: + return getTinfo(); + + case CREDENTIALS: + return getCredentials(); + + case PRINCIPAL: + return getPrincipal(); + + case TABLE_NAMESPACE: + return getTableNamespace(); + + case TBL_NSPC_PERM: + return Byte.valueOf(getTblNspcPerm()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TINFO: + return isSetTinfo(); + case CREDENTIALS: + return isSetCredentials(); + case PRINCIPAL: + return isSetPrincipal(); + case TABLE_NAMESPACE: + return isSetTableNamespace(); + case TBL_NSPC_PERM: + return isSetTblNspcPerm(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof hasTableNamespacePermission_args) + return this.equals((hasTableNamespacePermission_args)that); + return false; + } + + public boolean equals(hasTableNamespacePermission_args that) { + if (that == null) + return false; + + boolean this_present_tinfo = true && this.isSetTinfo(); + boolean that_present_tinfo = true && that.isSetTinfo(); + if (this_present_tinfo || that_present_tinfo) { + if (!(this_present_tinfo && that_present_tinfo)) + return false; + if (!this.tinfo.equals(that.tinfo)) + return false; + } + + boolean this_present_credentials = true && this.isSetCredentials(); + boolean that_present_credentials = true && that.isSetCredentials(); + if (this_present_credentials || that_present_credentials) { + if (!(this_present_credentials && that_present_credentials)) + return false; + if (!this.credentials.equals(that.credentials)) + return false; + } + + boolean this_present_principal = true && this.isSetPrincipal(); + boolean that_present_principal = true && that.isSetPrincipal(); + if (this_present_principal || that_present_principal) { + if (!(this_present_principal && that_present_principal)) + return false; + if (!this.principal.equals(that.principal)) + return false; + } + + boolean this_present_tableNamespace = true && this.isSetTableNamespace(); + boolean that_present_tableNamespace = true && that.isSetTableNamespace(); + if (this_present_tableNamespace || that_present_tableNamespace) { + if (!(this_present_tableNamespace && that_present_tableNamespace)) + return false; + if (!this.tableNamespace.equals(that.tableNamespace)) + return false; + } + + boolean this_present_tblNspcPerm = true; + boolean that_present_tblNspcPerm = true; + if (this_present_tblNspcPerm || that_present_tblNspcPerm) { + if (!(this_present_tblNspcPerm && that_present_tblNspcPerm)) + return false; + if (this.tblNspcPerm != that.tblNspcPerm) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(hasTableNamespacePermission_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + hasTableNamespacePermission_args typedOther = (hasTableNamespacePermission_args)other; + + lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTinfo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCredentials()).compareTo(typedOther.isSetCredentials()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCredentials()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.credentials, typedOther.credentials); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPrincipal()).compareTo(typedOther.isSetPrincipal()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPrincipal()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.principal, typedOther.principal); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTableNamespace()).compareTo(typedOther.isSetTableNamespace()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTableNamespace()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableNamespace, typedOther.tableNamespace); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTblNspcPerm()).compareTo(typedOther.isSetTblNspcPerm()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTblNspcPerm()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tblNspcPerm, typedOther.tblNspcPerm); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("hasTableNamespacePermission_args("); + boolean first = true; + + sb.append("tinfo:"); + if (this.tinfo == null) { + sb.append("null"); + } else { + sb.append(this.tinfo); + } + first = false; + if (!first) sb.append(", "); + sb.append("credentials:"); + if (this.credentials == null) { + sb.append("null"); + } else { + sb.append(this.credentials); + } + first = false; + if (!first) sb.append(", "); + sb.append("principal:"); + if (this.principal == null) { + sb.append("null"); + } else { + sb.append(this.principal); + } + first = false; + if (!first) sb.append(", "); + sb.append("tableNamespace:"); + if (this.tableNamespace == null) { + sb.append("null"); + } else { + sb.append(this.tableNamespace); + } + first = false; + if (!first) sb.append(", "); + sb.append("tblNspcPerm:"); + sb.append(this.tblNspcPerm); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (tinfo != null) { + tinfo.validate(); + } + if (credentials != null) { + credentials.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class hasTableNamespacePermission_argsStandardSchemeFactory implements SchemeFactory { + public hasTableNamespacePermission_argsStandardScheme getScheme() { + return new hasTableNamespacePermission_argsStandardScheme(); + } + } + + private static class hasTableNamespacePermission_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, hasTableNamespacePermission_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // TINFO + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo(); + struct.tinfo.read(iprot); + struct.setTinfoIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // CREDENTIALS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.credentials = new org.apache.accumulo.core.security.thrift.TCredentials(); + struct.credentials.read(iprot); + struct.setCredentialsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PRINCIPAL + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.principal = iprot.readString(); + struct.setPrincipalIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // TABLE_NAMESPACE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.tableNamespace = iprot.readString(); + struct.setTableNamespaceIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // TBL_NSPC_PERM + if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) { + struct.tblNspcPerm = iprot.readByte(); + struct.setTblNspcPermIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, hasTableNamespacePermission_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.tinfo != null) { + oprot.writeFieldBegin(TINFO_FIELD_DESC); + struct.tinfo.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.credentials != null) { + oprot.writeFieldBegin(CREDENTIALS_FIELD_DESC); + struct.credentials.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.principal != null) { + oprot.writeFieldBegin(PRINCIPAL_FIELD_DESC); + oprot.writeString(struct.principal); + oprot.writeFieldEnd(); + } + if (struct.tableNamespace != null) { + oprot.writeFieldBegin(TABLE_NAMESPACE_FIELD_DESC); + oprot.writeString(struct.tableNamespace); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(TBL_NSPC_PERM_FIELD_DESC); + oprot.writeByte(struct.tblNspcPerm); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class hasTableNamespacePermission_argsTupleSchemeFactory implements SchemeFactory { + public hasTableNamespacePermission_argsTupleScheme getScheme() { + return new hasTableNamespacePermission_argsTupleScheme(); + } + } + + private static class hasTableNamespacePermission_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, hasTableNamespacePermission_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTinfo()) { + optionals.set(0); + } + if (struct.isSetCredentials()) { + optionals.set(1); + } + if (struct.isSetPrincipal()) { + optionals.set(2); + } + if (struct.isSetTableNamespace()) { + optionals.set(3); + } + if (struct.isSetTblNspcPerm()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetTinfo()) { + struct.tinfo.write(oprot); + } + if (struct.isSetCredentials()) { + struct.credentials.write(oprot); + } + if (struct.isSetPrincipal()) { + oprot.writeString(struct.principal); + } + if (struct.isSetTableNamespace()) { + oprot.writeString(struct.tableNamespace); + } + if (struct.isSetTblNspcPerm()) { + oprot.writeByte(struct.tblNspcPerm); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, hasTableNamespacePermission_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.tinfo = new org.apache.accumulo.trace.thrift.TInfo(); + struct.tinfo.read(iprot); + struct.setTinfoIsSet(true); + } + if (incoming.get(1)) { + struct.credentials = new org.apache.accumulo.core.security.thrift.TCredentials(); + struct.credentials.read(iprot); + struct.setCredentialsIsSet(true); + } + if (incoming.get(2)) { + struct.principal = iprot.readString(); + struct.setPrincipalIsSet(true); + } + if (incoming.get(3)) { + struct.tableNamespace = iprot.readString(); + struct.setTableNamespaceIsSet(true); + } + if (incoming.get(4)) { + struct.tblNspcPerm = iprot.readByte(); + struct.setTblNspcPermIsSet(true); + } + } + } + + } + + public static class hasTableNamespacePermission_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("hasTableNamespacePermission_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0); + private static final org.apache.thrift.protocol.TField SEC_FIELD_DESC = new org.apache.thrift.protocol.TField("sec", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField TOPE_FIELD_DESC = new org.apache.thrift.protocol.TField("tope", org.apache.thrift.protocol.TType.STRUCT, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new hasTableNamespacePermission_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new hasTableNamespacePermission_resultTupleSchemeFactory()); + } + + public boolean success; // required + public ThriftSecurityException sec; // required + public ThriftTableOperationException tope; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + SEC((short)1, "sec"), + TOPE((short)2, "tope"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // SEC + return SEC; + case 2: // TOPE + return TOPE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.SEC, new org.apache.thrift.meta_data.FieldMetaData("sec", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.TOPE, new org.apache.thrift.meta_data.FieldMetaData("tope", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(hasTableNamespacePermission_result.class, metaDataMap); + } + + public hasTableNamespacePermission_result() { + } + + public hasTableNamespacePermission_result( + boolean success, + ThriftSecurityException sec, + ThriftTableOperationException tope) + { + this(); + this.success = success; + setSuccessIsSet(true); + this.sec = sec; + this.tope = tope; + } + + /** + * Performs a deep copy on other. + */ + public hasTableNamespacePermission_result(hasTableNamespacePermission_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + if (other.isSetSec()) { + this.sec = new ThriftSecurityException(other.sec); + } + if (other.isSetTope()) { + this.tope = new ThriftTableOperationException(other.tope); + } + } + + public hasTableNamespacePermission_result deepCopy() { + return new hasTableNamespacePermission_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + this.sec = null; + this.tope = null; + } + + public boolean isSuccess() { + return this.success; + } + + public hasTableNamespacePermission_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public ThriftSecurityException getSec() { + return this.sec; + } + + public hasTableNamespacePermission_result setSec(ThriftSecurityException sec) { + this.sec = sec; + return this; + } + + public void unsetSec() { + this.sec = null; + } + + /** Returns true if field sec is set (has been assigned a value) and false otherwise */ + public boolean isSetSec() { + return this.sec != null; + } + + public void setSecIsSet(boolean value) { + if (!value) { + this.sec = null; + } + } + + public ThriftTableOperationException getTope() { + return this.tope; + } + + public hasTableNamespacePermission_result setTope(ThriftTableOperationException tope) { + this.tope = tope; + return this; + } + + public void unsetTope() { + this.tope = null; + } + + /** Returns true if field tope is set (has been assigned a value) and false otherwise */ + public boolean isSetTope() { + return this.tope != null; + } + + public void setTopeIsSet(boolean value) { + if (!value) { + this.tope = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean)value); + } + break; + + case SEC: + if (value == null) { + unsetSec(); + } else { + setSec((ThriftSecurityException)value); + } + break; + + case TOPE: + if (value == null) { + unsetTope(); + } else { + setTope((ThriftTableOperationException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return Boolean.valueOf(isSuccess()); + + case SEC: + return getSec(); + + case TOPE: + return getTope(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case SEC: + return isSetSec(); + case TOPE: + return isSetTope(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof hasTableNamespacePermission_result) + return this.equals((hasTableNamespacePermission_result)that); + return false; + } + + public boolean equals(hasTableNamespacePermission_result that) { + if (that == null) + return false; + + boolean this_present_success = true; + boolean that_present_success = true; + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (this.success != that.success) + return false; + } + + boolean this_present_sec = true && this.isSetSec(); + boolean that_present_sec = true && that.isSetSec(); + if (this_present_sec || that_present_sec) { + if (!(this_present_sec && that_present_sec)) + return false; + if (!this.sec.equals(that.sec)) + return false; + } + + boolean this_present_tope = true && this.isSetTope(); + boolean that_present_tope = true && that.isSetTope(); + if (this_present_tope || that_present_tope) { + if (!(this_present_tope && that_present_tope)) + return false; + if (!this.tope.equals(that.tope)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(hasTableNamespacePermission_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + hasTableNamespacePermission_result typedOther = (hasTableNamespacePermission_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSec()).compareTo(typedOther.isSetSec()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSec()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sec, typedOther.sec); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTope()).compareTo(typedOther.isSetTope()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTope()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tope, typedOther.tope); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("hasTableNamespacePermission_result("); + boolean first = true; + + sb.append("success:"); + sb.append(this.success); + first = false; + if (!first) sb.append(", "); + sb.append("sec:"); + if (this.sec == null) { + sb.append("null"); + } else { + sb.append(this.sec); + } + first = false; + if (!first) sb.append(", "); + sb.append("tope:"); + if (this.tope == null) { + sb.append("null"); + } else { + sb.append(this.tope); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class hasTableNamespacePermission_resultStandardSchemeFactory implements SchemeFactory { + public hasTableNamespacePermission_resultStandardScheme getScheme() { + return new hasTableNamespacePermission_resultStandardScheme(); + } + } + + private static class hasTableNamespacePermission_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, hasTableNamespacePermission_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // SEC + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.sec = new ThriftSecurityException(); + struct.sec.read(iprot); + struct.setSecIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TOPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.tope = new ThriftTableOperationException(); + struct.tope.read(iprot); + struct.setTopeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, hasTableNamespacePermission_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeBool(struct.success); + oprot.writeFieldEnd(); + } + if (struct.sec != null) { + oprot.writeFieldBegin(SEC_FIELD_DESC); + struct.sec.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.tope != null) { + oprot.writeFieldBegin(TOPE_FIELD_DESC); + struct.tope.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class hasTableNamespacePermission_resultTupleSchemeFactory implements SchemeFactory { + public hasTableNamespacePermission_resultTupleScheme getScheme() { + return new hasTableNamespacePermission_resultTupleScheme(); + } + } + + private static class hasTableNamespacePermission_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, hasTableNamespacePermission_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetSec()) { + optionals.set(1); + } + if (struct.isSetTope()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + if (struct.isSetSec()) { + struct.sec.write(oprot); + } + if (struct.isSetTope()) { + struct.tope.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, hasTableNamespacePermission_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.sec = new ThriftSecurityException(); + struct.sec.read(iprot); + struct.setSecIsSet(true); + } + if (incoming.get(2)) { + struct.tope = new ThriftTableOperationException(); + struct.tope.read(iprot); + struct.setTopeIsSet(true); + } + } + } + + } + + public static class grantSystemPermission_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("grantSystemPermission_args"); + + private static final org.apache.thrift.protocol.TField TINFO_FIELD_DESC = new org.apache.thrift.protocol.TField("tinfo", org.apache.thrift.protocol.TType.STRUCT, (short)4); + private static final org.apache.thrift.protocol.TField CREDENTIALS_FIELD_DESC = new org.apache.thrift.protocol.TField("credentials", org.apache.thrift.protocol.TType.STRUCT, (short)5); + private static final org.apache.thrift.protocol.TField PRINCIPAL_FIELD_DESC = new org.apache.thrift.protocol.TField("principal", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField PERMISSION_FIELD_DESC = new org.apache.thrift.protocol.TField("permission", org.apache.thrift.protocol.TType.BYTE, (short)3); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new grantSystemPermission_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new grantSystemPermission_argsTupleSchemeFactory()); + } + + public org.apache.accumulo.trace.thrift.TInfo tinfo; // required + public org.apache.accumulo.core.security.thrift.TCredentials credentials; // required + public String principal; // required + public byte permission; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TINFO((short)4, "tinfo"), + CREDENTIALS((short)5, "credentials"), + PRINCIPAL((short)2, "principal"), + PERMISSION((short)3, "permission"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 4: // TINFO + return TINFO; + case 5: // CREDENTIALS + return CREDENTIALS; + case 2: // PRINCIPAL + return PRINCIPAL; + case 3: // PERMISSION + return PERMISSION; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PERMISSION_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TINFO, new org.apache.thrift.meta_data.FieldMetaData("tinfo", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.trace.thrift.TInfo.class))); + tmpMap.put(_Fields.CREDENTIALS, new org.apache.thrift.meta_data.FieldMetaData("credentials", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, org.apache.accumulo.core.security.thrift.TCredentials.class))); + tmpMap.put(_Fields.PRINCIPAL, new org.apache.thrift.meta_data.FieldMetaData("principal", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PERMISSION, new org.apache.thrift.meta_data.FieldMetaData("permission", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(grantSystemPermission_args.class, metaDataMap); + } + + public grantSystemPermission_args() { + } + + public grantSystemPermission_args( + org.apache.accumulo.trace.thrift.TInfo tinfo, + org.apache.accumulo.core.security.thrift.TCredentials credentials, + String principal, + byte permission) + { + this(); + this.tinfo = tinfo; + this.credentials = credentials; + this.principal = principal; + this.permission = permission; + setPermissionIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public grantSystemPermission_args(grantSystemPermission_args other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetTinfo()) { + this.tinfo = new org.apache.accumulo.trace.thrift.TInfo(other.tinfo); + } + if (other.isSetCredentials()) { + this.credentials = new org.apache.accumulo.core.security.thrift.TCredentials(other.credentials); + } + if (other.isSetPrincipal()) { + this.principal = other.principal; + } + this.permission = other.permission; + } + + public grantSystemPermission_args deepCopy() { + return new grantSystemPermission_args(this); + } + + @Override + public void clear() { + this.tinfo = null; + this.credentials = null; + this.principal = null; + setPermissionIsSet(false); + this.permission = 0; + } + + public org.apache.accumulo.trace.thrift.TInfo getTinfo() { + return this.tinfo; + } + + public grantSystemPermission_args setTinfo(org.apache.accumulo.trace.thrift.TInfo tinfo) { + this.tinfo = tinfo; + return this; + } + + public void unsetTinfo() { + this.tinfo = null; + } + + /** Returns true if field tinfo is set (has been assigned a value) and false otherwise */ + public boolean isSetTinfo() { + return this.tinfo != null; + } + + public void setTinfoIsSet(boolean value) { + if (!value) { + this.tinfo = null; + } + } + + public org.apache.accumulo.core.security.thrift.TCredentials getCredentials() { + return this.credentials; + } + + public grantSystemPermission_args setCredentials(org.apache.accumulo.core.security.thrift.TCredentials credentials) { + this.credentials = credentials; + return this; + } + + public void unsetCredentials() { + this.credentials = null; + } + + /** Returns true if field credentials is set (has been assigned a value) and false otherwise */ + public boolean isSetCredentials() { + return this.credentials != null; + } + + public void setCredentialsIsSet(boolean value) { + if (!value) { + this.credentials = null; + } + } + + public String getPrincipal() { + return this.principal; + } + + public grantSystemPermission_args setPrincipal(String principal) { + this.principal = principal; + return this; + } + + public void unsetPrincipal() { + this.principal = null; + } + + /** Returns true if field principal is set (has been assigned a value) and false otherwise */ + public boolean isSetPrincipal() { + return this.principal != null; + } + + public void setPrincipalIsSet(boolean value) { + if (!value) { + this.principal = null; + } + } + + public byte getPermission() { + return this.permission; + } + + public grantSystemPermission_args setPermission(byte permission) { + this.permission = permission; + setPermissionIsSet(true); + return this; + } + + public void unsetPermission() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PERMISSION_ISSET_ID); + } + + /** Returns true if field permission is set (has been assigned a value) and false otherwise */ + public boolean isSetPermission() { + return EncodingUtils.testBit(__isset_bitfield, __PERMISSION_ISSET_ID); + } + + public void setPermissionIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PERMISSION_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TINFO: + if (value == null) { + unsetTinfo(); + } else { + setTinfo((org.apache.accumulo.trace.thrift.TInfo)value); + } + break; + + case CREDENTIALS: + if (value == null) { + unsetCredentials(); + } else { + setCredentials((org.apache.accumulo.core.security.thrift.TCredentials)value); + } + break; + + case PRINCIPAL: + if (value == null) { + unsetPrincipal(); + } else { + setPrincipal((String)value); + } + break; + + case PERMISSION: + if (value == null) { + unsetPermission(); + } else { + setPermission((Byte)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TINFO: + return getTinfo(); + + case CREDENTIALS: + return getCredentials(); + + case PRINCIPAL: + return getPrincipal(); + + case PERMISSION: + return Byte.valueOf(getPermission()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case TINFO: + return isSetTinfo(); + case CREDENTIALS: + return isSetCredentials(); + case PRINCIPAL: + return isSetPrincipal(); + case PERMISSION: + return isSetPermission(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof grantSystemPermission_args) + return this.equals((grantSystemPermission_args)that); + return false; + } + + public boolean equals(grantSystemPermission_args that) { + if (that == null) + return false; + + boolean this_present_tinfo = true && this.isSetTinfo(); + boolean that_present_tinfo = true && that.isSetTinfo(); + if (this_present_tinfo || that_present_tinfo) { + if (!(this_present_tinfo && that_present_tinfo)) + return false; + if (!this.tinfo.equals(that.tinfo)) + return false; + } + + boolean this_present_credentials = true && this.isSetCredentials(); + boolean that_present_credentials = true && that.isSetCredentials(); + if (this_present_credentials || that_present_credentials) { + if (!(this_present_credentials && that_present_credentials)) + return false; + if (!this.credentials.equals(that.credentials)) + return false; + } + + boolean this_present_principal = true && this.isSetPrincipal(); + boolean that_present_principal = true && that.isSetPrincipal(); + if (this_present_principal || that_present_principal) { + if (!(this_present_principal && that_present_principal)) + return false; + if (!this.principal.equals(that.principal)) + return false; + } + + boolean this_present_permission = true; + boolean that_present_permission = true; + if (this_present_permission || that_present_permission) { + if (!(this_present_permission && that_present_permission)) + return false; + if (this.permission != that.permission) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + public int compareTo(grantSystemPermission_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + grantSystemPermission_args typedOther = (grantSystemPermission_args)other; + + lastComparison = Boolean.valueOf(isSetTinfo()).compareTo(typedOther.isSetTinfo()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTinfo()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tinfo, typedOther.tinfo); +