diff --git beeline/pom.xml beeline/pom.xml
index 02bfaaa..6ec1d1a 100644
--- beeline/pom.xml
+++ beeline/pom.xml
@@ -145,6 +145,19 @@
${basedir}/src/java
${basedir}/src/test
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+
+
+
+ test-jar
+
+
+
+
+
diff --git beeline/src/java/org/apache/hive/beeline/BeeLine.java beeline/src/java/org/apache/hive/beeline/BeeLine.java
index 563d242..9afa5af 100644
--- beeline/src/java/org/apache/hive/beeline/BeeLine.java
+++ beeline/src/java/org/apache/hive/beeline/BeeLine.java
@@ -502,6 +502,7 @@ boolean initArgs(String[] args) {
List commands = new LinkedList();
List files = new LinkedList();
String driver = null, user = null, pass = null, url = null, cmd = null;
+ String auth = null;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("--help") || args[i].equals("-h")) {
@@ -554,6 +555,9 @@ boolean initArgs(String[] args) {
driver = args[i++ + 1];
} else if (args[i].equals("-n")) {
user = args[i++ + 1];
+ } else if (args[i].equals("-a")) {
+ auth = args[i++ + 1];
+ getOpts().setAuthType(auth);
} else if (args[i].equals("-p")) {
pass = args[i++ + 1];
} else if (args[i].equals("-u")) {
diff --git beeline/src/java/org/apache/hive/beeline/BeeLineOpts.java beeline/src/java/org/apache/hive/beeline/BeeLineOpts.java
index 91e20ec..44cabdf 100644
--- beeline/src/java/org/apache/hive/beeline/BeeLineOpts.java
+++ beeline/src/java/org/apache/hive/beeline/BeeLineOpts.java
@@ -86,6 +86,8 @@
private String historyFile = new File(saveDir(), "history").getAbsolutePath();
private String scriptFile = null;
+ private String authType = null;
+
private Map hiveVariables = new HashMap();
private Map hiveConfVariables = new HashMap();
@@ -248,6 +250,13 @@ public void setFastConnect(boolean fastConnect) {
this.fastConnect = fastConnect;
}
+ public String getAuthType() {
+ return authType;
+ }
+
+ public void setAuthType(String authType) {
+ this.authType = authType;
+ }
public boolean getFastConnect() {
return fastConnect;
diff --git beeline/src/java/org/apache/hive/beeline/Commands.java beeline/src/java/org/apache/hive/beeline/Commands.java
index d2d7fd3..8694864 100644
--- beeline/src/java/org/apache/hive/beeline/Commands.java
+++ beeline/src/java/org/apache/hive/beeline/Commands.java
@@ -876,6 +876,7 @@ public boolean connect(String line) throws Exception {
if (pass != null) {
props.setProperty("password", pass);
}
+
return connect(props);
}
@@ -922,6 +923,7 @@ public boolean connect(Properties props) throws IOException {
"javax.jdo.option.ConnectionPassword",
"ConnectionPassword",
});
+ String auth = getProperty(props, new String[] {"auth"});
if (url == null || url.length() == 0) {
return beeLine.error("Property \"url\" is required");
@@ -937,14 +939,23 @@ public boolean connect(Properties props) throws IOException {
if (username == null) {
username = beeLine.getConsoleReader().readLine("Enter username for " + url + ": ");
}
+ props.setProperty("user", username);
if (password == null) {
password = beeLine.getConsoleReader().readLine("Enter password for " + url + ": ",
new Character('*'));
}
+ props.setProperty("password", password);
+
+ if (auth == null) {
+ auth = beeLine.getOpts().getAuthType();
+ }
+ if (auth != null) {
+ props.setProperty("auth", auth);
+ }
try {
beeLine.getDatabaseConnections().setConnection(
- new DatabaseConnection(beeLine, driver, url, username, password));
+ new DatabaseConnection(beeLine, driver, url, props));
beeLine.getDatabaseConnection().getConnection();
beeLine.setCompletions();
@@ -1171,8 +1182,8 @@ private boolean stopRecording(String line) {
} catch (Exception e) {
beeLine.handleException(e);
}
- beeLine.output(beeLine.loc("record-closed", beeLine.getRecordOutputFile()));
beeLine.setRecordOutputFile(null);
+ beeLine.output(beeLine.loc("record-closed", beeLine.getRecordOutputFile()));
return true;
}
@@ -1191,8 +1202,9 @@ private boolean startRecording(String line) {
}
try {
- beeLine.setRecordOutputFile(new OutputFile(parts[1]));
- beeLine.output(beeLine.loc("record-started", beeLine.getRecordOutputFile()));
+ OutputFile recordOutput = new OutputFile(parts[1]);
+ beeLine.output(beeLine.loc("record-started", recordOutput));
+ beeLine.setRecordOutputFile(recordOutput);
return true;
} catch (Exception e) {
return beeLine.error(e);
diff --git beeline/src/java/org/apache/hive/beeline/DatabaseConnection.java beeline/src/java/org/apache/hive/beeline/DatabaseConnection.java
index 94178ef..00b49af 100644
--- beeline/src/java/org/apache/hive/beeline/DatabaseConnection.java
+++ beeline/src/java/org/apache/hive/beeline/DatabaseConnection.java
@@ -30,6 +30,7 @@
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.List;
+import java.util.Properties;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@@ -49,19 +50,17 @@
private DatabaseMetaData meta;
private final String driver;
private final String url;
- private final String username;
- private final String password;
+ private final Properties info;
private Schema schema = null;
private Completor sqlCompletor = null;
public DatabaseConnection(BeeLine beeLine, String driver, String url,
- String username, String password) throws SQLException {
+ Properties info) throws SQLException {
this.beeLine = beeLine;
this.driver = driver;
- this.username = username;
- this.password = password;
this.url = url;
+ this.info = info;
}
@Override
@@ -133,9 +132,6 @@ boolean connect() throws SQLException {
return beeLine.error(e);
}
- Properties info = new Properties();
- info.put(HIVE_AUTH_USER, username);
- info.put(HIVE_AUTH_PASSWD, password);
Map hiveVars = beeLine.getOpts().getHiveVariables();
for (Map.Entry var : hiveVars.entrySet()) {
info.put(HIVE_VAR_PREFIX + var.getKey(), var.getValue());
@@ -312,4 +308,4 @@ public Column(String name) {
}
}
}
-}
\ No newline at end of file
+}
diff --git beeline/src/test/org/apache/hive/beeline/ProxyAuthTest.java beeline/src/test/org/apache/hive/beeline/ProxyAuthTest.java
new file mode 100644
index 0000000..95146e9
--- /dev/null
+++ beeline/src/test/org/apache/hive/beeline/ProxyAuthTest.java
@@ -0,0 +1,382 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hive.beeline;
+
+import java.io.*;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hive.jdbc.HiveConnection;
+import org.apache.hive.beeline.BeeLine;
+import org.apache.hadoop.hive.shims.ShimLoader;
+import org.apache.hive.service.auth.HiveAuthFactory;
+
+/**
+ * Simple client application to test various direct and proxy connection to HiveServer2
+ * Note that it's not an automated test at this point. It requires a manually configured
+ * secure HivServer2. It also requires a super user and a normal user principal.
+ * Steps to run the test -
+ * kinit
+ * hive --service jar beeline/target/hive-beeline-0.13.0-SNAPSHOT-tests.jar \
+ * org.apache.hive.beeline.ProxyAuthTest \
+ *
+ */
+public class ProxyAuthTest {
+ private static final String driverName = "org.apache.hive.jdbc.HiveDriver";
+ private static final String BEELINE_EXIT = "beeline.system.exit";
+ private static Connection con = null;
+ private static boolean noClose = false;
+ private static String tabName = "jdbc_test";
+ private static String tabDataFileName;
+ private static String scriptFileName;
+ private static String [] dmlStmts;
+ private static String [] dfsStmts;
+ private static String [] selectStmts;
+ private static String [] cleanUpStmts;
+ private static InputStream inpStream = null;
+ private static int tabCount = 1;
+ private static File resultFile= null;
+
+ public static void main(String[] args) throws Exception {
+ if (args.length < 4) {
+ System.out.println("Usage ProxyAuthTest [testTab]");
+ System.exit(1);
+ }
+
+ File currentResultFile = null;
+ String [] beeLineArgs = {};
+
+ Class.forName(driverName);
+ String host = args[0];
+ String port = args[1];
+ String serverPrincipal = args[2];
+ String proxyUser = args[3];
+ String url = null;
+ if (args.length > 4) {
+ tabName = args[4];
+ }
+
+ generateData();
+ generateSQL(null);
+
+ try {
+ /*
+ * Connect via kerberos and get delegation token
+ */
+ url = "jdbc:hive2://" + host + ":" + port + "/default;principal=" + serverPrincipal;
+ con = DriverManager.getConnection(url);
+ System.out.println("Connected successfully to " + url);
+ // get delegation token for the given proxy user
+ String token = ((HiveConnection)con).getDelegationToken(proxyUser, serverPrincipal);
+ if ("true".equals(System.getProperty("proxyAuth.debug", "false"))) {
+ System.out.println("Got token: " + token);
+ }
+ con.close();
+
+ // so that beeline won't kill the JVM
+ System.setProperty(BEELINE_EXIT, "true");
+
+ // connect using principal via Beeline with inputStream
+ url = "jdbc:hive2://" + host + ":" + port + "/default;principal=" + serverPrincipal;
+ currentResultFile = generateSQL(null);
+ beeLineArgs = new String[] { "-u", url, "-n", "foo", "-p", "bar"};
+ System.out.println("Connection with kerberos, user/password via args, using input rediction");
+ BeeLine.mainWithInputRedirection(beeLineArgs, inpStream);
+ compareResults( currentResultFile);
+
+ // connect using principal via Beeline with inputStream
+ url = "jdbc:hive2://" + host + ":" + port + "/default;principal=" + serverPrincipal;
+ currentResultFile = generateSQL(null);
+ beeLineArgs = new String[] { "-u", url, "-n", "foo", "-p", "bar", "-f" , scriptFileName};
+ System.out.println("Connection with kerberos, user/password via args, using input script");
+ BeeLine.main(beeLineArgs);
+ compareResults( currentResultFile);
+
+ // connect using principal via Beeline with inputStream
+ url = "jdbc:hive2://" + host + ":" + port + "/default;principal=" + serverPrincipal;
+ currentResultFile = generateSQL(url+ " foo bar ");
+ beeLineArgs = new String[] { "-u", url, "-f" , scriptFileName};
+ System.out.println("Connection with kerberos, user/password via connect, using input script");
+ BeeLine.main(beeLineArgs);
+ compareResults( currentResultFile);
+
+ // connect using principal via Beeline with inputStream
+ url = "jdbc:hive2://" + host + ":" + port + "/default;principal=" + serverPrincipal;
+ currentResultFile = generateSQL(url+ " foo bar ");
+ beeLineArgs = new String[] { "-u", url, "-f" , scriptFileName};
+ System.out.println("Connection with kerberos, user/password via connect, using input redirect");
+ BeeLine.mainWithInputRedirection(beeLineArgs, inpStream);
+ compareResults( currentResultFile);
+
+ /*
+ * Connect using the delegation token passed via configuration object
+ */
+ System.out.println("Store token into ugi and try");
+ storeTokenInJobConf(token);
+ url = "jdbc:hive2://" + host + ":" + port + "/default;auth=delegationToken";
+ con = DriverManager.getConnection(url);
+ System.out.println("Connecting to " + url);
+ runTest();
+ con.close();
+
+ // connect using token via Beeline with inputStream
+ url = "jdbc:hive2://" + host + ":" + port + "/default";
+ currentResultFile = generateSQL(null);
+ beeLineArgs = new String[] { "-u", url, "-n", "foo", "-p", "bar", "-a", "delegationToken" };
+ System.out.println("Connection with token, user/password via args, using input redirection");
+ BeeLine.mainWithInputRedirection(beeLineArgs, inpStream);
+ compareResults( currentResultFile);
+
+ // connect using token via Beeline using script
+ url = "jdbc:hive2://" + host + ":" + port + "/default";
+ currentResultFile = generateSQL(null);
+ beeLineArgs = new String[] { "-u", url, "-n", "foo", "-p", "bar", "-a", "delegationToken",
+ "-f", scriptFileName};
+ System.out.println("Connection with token, user/password via args, using input script");
+ BeeLine.main(beeLineArgs);
+ compareResults( currentResultFile);
+
+ // connect using token via Beeline using script
+ url = "jdbc:hive2://" + host + ":" + port + "/default";
+ currentResultFile = generateSQL(url + " foo bar ");
+ beeLineArgs = new String [] {"-a", "delegationToken", "-f", scriptFileName};
+ System.out.println("Connection with token, user/password via connect, using input script");
+ BeeLine.main(beeLineArgs);
+ compareResults( currentResultFile);
+
+ // connect using token via Beeline using script
+ url = "jdbc:hive2://" + host + ":" + port + "/default";
+ currentResultFile = generateSQL(url + " foo bar ");
+ System.out.println("Connection with token, user/password via connect, using input script");
+ beeLineArgs = new String [] {"-f", scriptFileName, "-a", "delegationToken"};
+ BeeLine.main(beeLineArgs);
+ compareResults( currentResultFile);
+
+ /*
+ * Connect via kerberos with trusted proxy user
+ */
+ url = "jdbc:hive2://" + host + ":" + port + "/default;principal=" + serverPrincipal
+ + ";hive.server2.proxy.user=" + proxyUser;
+ con = DriverManager.getConnection(url);
+ System.out.println("Connected successfully to " + url);
+ runTest();
+
+ ((HiveConnection)con).cancelDelegationToken(token);
+ con.close();
+ } catch (SQLException e) {
+ System.out.println("*** SQLException: " + e.getMessage() + " : " + e.getSQLState());
+ e.printStackTrace();
+ }
+
+ /* verify the connection fails after canceling the token */
+ try {
+ url = "jdbc:hive2://" + host + ":" + port + "/default;auth=delegationToken";
+ con = DriverManager.getConnection(url);
+ throw new Exception ("connection should have failed after token cancelation");
+ } catch (SQLException e) {
+ // Expected to fail due to canceled token
+ }
+ }
+
+ private static void storeTokenInJobConf(String tokenStr) throws Exception {
+ ShimLoader.getHadoopShims().setTokenStr(ShimLoader.getHadoopShims().getUGIForConf(new Configuration()),
+ tokenStr, HiveAuthFactory.HS2_CLIENT_TOKEN);
+ System.out.println("Stored token " + tokenStr);
+ }
+
+ // run sql operations
+ private static void runTest() throws Exception {
+ // craete table and check dir ownership
+ runDMLs();
+
+ // run queries
+ for (String stmt: dfsStmts) {
+ runQuery(stmt);
+ }
+
+ // run queries
+ for (String stmt: selectStmts) {
+ runQuery(stmt);
+ }
+
+ // delete all the objects created
+ cleanUp();
+ }
+
+ // create tables and load data
+ private static void runDMLs() throws Exception {
+ for (String stmt : dmlStmts) {
+ exStatement(stmt);
+ }
+ }
+
+ // drop tables
+ private static void cleanUp() throws Exception {
+ for (String stmt : cleanUpStmts) {
+ exStatement(stmt);
+ }
+ }
+
+ private static void runQuery(String sqlStmt) throws Exception {
+ Statement stmt = con.createStatement();
+ ResultSet res = stmt.executeQuery(sqlStmt);
+
+ ResultSetMetaData meta = res.getMetaData();
+ System.out.println("Resultset has " + meta.getColumnCount() + " columns");
+ for (int i = 1; i <= meta.getColumnCount(); i++) {
+ System.out.println("Column #" + i + " Name: " + meta.getColumnName(i) +
+ " Type: " + meta.getColumnType(i));
+ }
+
+ while (res.next()) {
+ for (int i = 1; i <= meta.getColumnCount(); i++) {
+ System.out.println("Column #" + i + ": " + res.getString(i));
+ }
+ }
+ res.close();
+ stmt.close();
+ }
+
+ // Execute the given sql statement
+ private static void exStatement(String query) throws Exception {
+ Statement stmt = con.createStatement();
+ stmt.execute(query);
+ if (!noClose) {
+ stmt.close();
+ }
+ }
+
+ // generate SQL stmts to execute
+ private static File generateSQL(String url) throws Exception {
+ String current = new java.io.File( "." ).getCanonicalPath();
+ String currentDir = System.getProperty("user.dir");
+ String queryTab = tabName + "_" + (tabCount++);
+ dmlStmts = new String[] {
+ "USE default",
+ "drop table if exists " + queryTab,
+ "create table " + queryTab + "(id int, name string) " +
+ "ROW FORMAT DELIMITED FIELDS TERMINATED BY '|'",
+ "load data local inpath '" + tabDataFileName + "' into table " + queryTab
+ };
+ selectStmts = new String[] {
+ "select * from " + queryTab + " limit 5",
+ "select name, id from " + queryTab + " where id < 3",
+ };
+ dfsStmts = new String[] {
+// "set " + SESSION_USER_NAME,
+// "dfs -ls -d ${hiveconf:hive.metastore.warehouse.dir}/" + queryTab
+ };
+ cleanUpStmts = new String[] {
+ "drop table if exists " + queryTab
+ };
+
+ // write sql statements to file
+ return writeArrayToByteStream(url);
+ }
+
+ // generate data file for test
+ private static void generateData() throws Exception {
+ String fileData[] = {
+ "1|aaa",
+ "2|bbb",
+ "3|ccc",
+ "4|ddd",
+ "5|eee",
+ };
+
+ File tmpFile = File.createTempFile(tabName, ".data");
+ tmpFile.deleteOnExit();
+ tabDataFileName = tmpFile.getPath();
+ FileWriter fstream = new FileWriter(tabDataFileName);
+ BufferedWriter out = new BufferedWriter(fstream);
+ for (String line: fileData) {
+ out.write(line);
+ out.newLine();
+ }
+ out.close();
+ tmpFile.setWritable(true, true);
+ }
+
+ // Create a input stream of given name.ext and write sql statements to to it
+ // Returns the result File object which will contain the query results
+ private static File writeArrayToByteStream(String url) throws Exception {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+ if (url != null) {
+ writeCmdLine("!connect " + url, out);
+ }
+ writeCmdLine("!brief", out);
+ writeCmdLine("!set silent true", out);
+ resultFile = File.createTempFile(tabName, ".out");
+ if (!"true".equals(System.getProperty("proxyAuth.debug", "false"))) {
+ resultFile.deleteOnExit();
+ }
+ writeCmdLine("!record " + resultFile.getPath(), out);
+
+ for (String stmt: dmlStmts) {
+ writeSqlLine(stmt, out);
+ }
+
+ for (String stmt: selectStmts) {
+ writeSqlLine(stmt, out);
+ }
+
+ for (String stmt: cleanUpStmts) {
+ writeSqlLine(stmt, out);
+ }
+ writeCmdLine("!record", out);
+ writeCmdLine("!quit", out);
+
+ File tmpFile = File.createTempFile(tabName, ".q");
+ tmpFile.deleteOnExit();
+ scriptFileName = tmpFile.getPath();
+ FileOutputStream fstream = new FileOutputStream(scriptFileName);
+ out.writeTo(fstream);
+
+ inpStream = new ByteArrayInputStream(out.toByteArray());
+ return resultFile;
+ }
+
+ // write stmt + ";" + System.getProperty("line.separator")
+ private static void writeSqlLine(String stmt, OutputStream out) throws Exception {
+ out.write(stmt.getBytes());
+ out.write(";".getBytes());
+ out.write(System.getProperty("line.separator").getBytes());
+ }
+
+ private static void writeCmdLine(String cmdLine, OutputStream out) throws Exception {
+ out.write(cmdLine.getBytes());
+ out.write(System.getProperty("line.separator").getBytes());
+ }
+
+ private static void compareResults(File file2) throws IOException {
+ // load the expected results
+ File baseResultFile = new File(System.getProperty("proxyAuth.res.file"), "data/files/ProxyAuth.res");
+ if (!FileUtils.contentEquals(baseResultFile, file2)) {
+ throw new IOException("File compare failed: " + file2.getPath() + " differs");
+ }
+ }
+}
+
diff --git common/src/java/org/apache/hadoop/hive/conf/HiveConf.java common/src/java/org/apache/hadoop/hive/conf/HiveConf.java
index edc3d38..3c633a2 100644
--- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java
+++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java
@@ -871,6 +871,7 @@
// HiveServer2 auth configuration
HIVE_SERVER2_AUTHENTICATION("hive.server2.authentication", "NONE",
new StringsValidator("NOSASL", "NONE", "LDAP", "KERBEROS", "PAM", "CUSTOM")),
+ HIVE_SERVER2_ALLOW_USER_SUBSTITUTION("hive.server2.allow.user.substitution", true),
HIVE_SERVER2_KERBEROS_KEYTAB("hive.server2.authentication.kerberos.keytab", ""),
HIVE_SERVER2_KERBEROS_PRINCIPAL("hive.server2.authentication.kerberos.principal", ""),
HIVE_SERVER2_PLAIN_LDAP_URL("hive.server2.authentication.ldap.url", null),
diff --git conf/hive-default.xml.template conf/hive-default.xml.template
index a5a85b4..7515941 100644
--- conf/hive-default.xml.template
+++ conf/hive-default.xml.template
@@ -2444,6 +2444,13 @@
'1', and '0' as extened, legal boolean literal, in addition to 'TRUE' and 'FALSE'.
The default is false, which means only 'TRUE' and 'FALSE' are treated as legal
boolean literal.
+
+
+
+ hive.server2.allow.user.substitution
+ true
+
+ Allow alternate user to be specified as part of HiveServer2 open connection request
diff --git data/files/ProxyAuth.res data/files/ProxyAuth.res
new file mode 100644
index 0000000..96eca8f
--- /dev/null
+++ data/files/ProxyAuth.res
@@ -0,0 +1,15 @@
++-----+-------+
+| id | name |
++-----+-------+
+| 1 | aaa |
+| 2 | bbb |
+| 3 | ccc |
+| 4 | ddd |
+| 5 | eee |
++-----+-------+
++-------+-----+
+| name | id |
++-------+-----+
+| aaa | 1 |
+| bbb | 2 |
++-------+-----+
diff --git itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
index 8210e75..c91df83 100644
--- itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
+++ itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
@@ -260,7 +260,7 @@ private void checkBadUrl(String url) throws SQLException {
try{
DriverManager.getConnection(url, "", "");
fail("should have thrown IllegalArgumentException but did not ");
- }catch(IllegalArgumentException i){
+ } catch(SQLException i) {
assertTrue(i.getMessage().contains("Bad URL format. Hostname not found "
+ " in authority part of the url"));
}
diff --git jdbc/src/java/org/apache/hadoop/hive/jdbc/HiveConnection.java jdbc/src/java/org/apache/hadoop/hive/jdbc/HiveConnection.java
index d08e05b..59ce692 100644
--- jdbc/src/java/org/apache/hadoop/hive/jdbc/HiveConnection.java
+++ jdbc/src/java/org/apache/hadoop/hive/jdbc/HiveConnection.java
@@ -121,7 +121,6 @@ public HiveConnection(String uri, Properties info) throws SQLException {
isClosed = false;
configureConnection();
}
-
public void abort(Executor executor) throws SQLException {
// JDK 1.7
diff --git jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
index 4102d7a..6659ace 100644
--- jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
+++ jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
@@ -19,6 +19,7 @@
package org.apache.hive.jdbc;
import java.io.FileInputStream;
+import java.io.IOException;
import java.security.KeyStore;
import java.sql.Array;
import java.sql.Blob;
@@ -54,16 +55,23 @@
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.ql.session.SessionState;
+import org.apache.hadoop.hive.shims.ShimLoader;
import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.auth.KerberosSaslHelper;
import org.apache.hive.service.auth.PlainSaslHelper;
import org.apache.hive.service.auth.SaslQOP;
import org.apache.hive.service.cli.thrift.EmbeddedThriftBinaryCLIService;
import org.apache.hive.service.cli.thrift.TCLIService;
+import org.apache.hive.service.cli.thrift.TCancelDelegationTokenReq;
+import org.apache.hive.service.cli.thrift.TCancelDelegationTokenResp;
import org.apache.hive.service.cli.thrift.TCloseSessionReq;
+import org.apache.hive.service.cli.thrift.TGetDelegationTokenReq;
+import org.apache.hive.service.cli.thrift.TGetDelegationTokenResp;
import org.apache.hive.service.cli.thrift.TOpenSessionReq;
import org.apache.hive.service.cli.thrift.TOpenSessionResp;
import org.apache.hive.service.cli.thrift.TProtocolVersion;
+import org.apache.hive.service.cli.thrift.TRenewDelegationTokenReq;
+import org.apache.hive.service.cli.thrift.TRenewDelegationTokenResp;
import org.apache.hive.service.cli.thrift.TSessionHandle;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
@@ -85,6 +93,7 @@
private static final String HIVE_AUTH_TYPE= "auth";
private static final String HIVE_AUTH_QOP = "sasl.qop";
private static final String HIVE_AUTH_SIMPLE = "noSasl";
+ private static final String HIVE_AUTH_TOKEN = "delegationToken";
private static final String HIVE_AUTH_USER = "user";
private static final String HIVE_AUTH_PRINCIPAL = "principal";
private static final String HIVE_AUTH_PASSWD = "password";
@@ -119,7 +128,12 @@ public HiveConnection(String uri, Properties info) throws SQLException {
setupLoginTimeout();
jdbcURI = uri;
// parse the connection uri
- Utils.JdbcConnectionParams connParams = Utils.parseURL(jdbcURI);
+ Utils.JdbcConnectionParams connParams;
+ try {
+ connParams = Utils.parseURL(uri);
+ } catch (IllegalArgumentException e) {
+ throw new SQLException(e);
+ }
// extract parsed connection parameters:
// JDBC URL: jdbc:hive2://:/dbName;sess_var_list?hive_conf_list#hive_var_list
// each list: =;= and so on
@@ -148,13 +162,17 @@ public HiveConnection(String uri, Properties info) throws SQLException {
if (isEmbeddedMode) {
client = new EmbeddedThriftBinaryCLIService();
} else {
- // extract user/password from JDBC connection properties if its not supplied in the connection URL
+ // extract user/password from JDBC connection properties if its not supplied in the
+ // connection URL
if (info.containsKey(HIVE_AUTH_USER)) {
sessConfMap.put(HIVE_AUTH_USER, info.getProperty(HIVE_AUTH_USER));
if (info.containsKey(HIVE_AUTH_PASSWD)) {
sessConfMap.put(HIVE_AUTH_PASSWD, info.getProperty(HIVE_AUTH_PASSWD));
}
}
+ if (info.containsKey(HIVE_AUTH_TYPE)) {
+ sessConfMap.put(HIVE_AUTH_TYPE, info.getProperty(HIVE_AUTH_TYPE));
+ }
// open the client transport
openTransport();
// set up the client
@@ -170,7 +188,7 @@ public HiveConnection(String uri, Properties info) throws SQLException {
supportedProtocols.add(TProtocolVersion.HIVE_CLI_SERVICE_PROTOCOL_V6);
// open client session
- openSession();
+ openSession(connParams.getSessionVars());
configureConnection(connParams.getDbName());
}
@@ -259,14 +277,26 @@ private CloseableHttpClient getHttpClient(Boolean useSsl) throws SQLException {
}
}
+ /**
+ * Create transport per the connection options
+ * Supported transport options are:
+ * - SASL based transports over
+ * + Kerberos
+ * + Delegation token
+ * + SSL
+ * + non-SSL
+ * - Raw (non-SASL) socket
+ *
+ * Kerberos and Delegation token supports SASL QOP configurations
+ */
private TTransport createBinaryTransport() throws SQLException {
try {
// handle secure connection if specified
if (!HIVE_AUTH_SIMPLE.equals(sessConfMap.get(HIVE_AUTH_TYPE))) {
// If Kerberos
+ Map saslProps = new HashMap();
+ SaslQOP saslQOP = SaslQOP.AUTH;
if (sessConfMap.containsKey(HIVE_AUTH_PRINCIPAL)) {
- Map saslProps = new HashMap();
- SaslQOP saslQOP = SaslQOP.AUTH;
if (sessConfMap.containsKey(HIVE_AUTH_QOP)) {
try {
saslQOP = SaslQOP.fromString(sessConfMap.get(HIVE_AUTH_QOP));
@@ -281,30 +311,43 @@ private TTransport createBinaryTransport() throws SQLException {
sessConfMap.get(HIVE_AUTH_PRINCIPAL), host,
HiveAuthFactory.getSocketTransport(host, port, loginTimeout), saslProps);
} else {
- String userName = sessConfMap.get(HIVE_AUTH_USER);
- if ((userName == null) || userName.isEmpty()) {
- userName = HIVE_ANONYMOUS_USER;
- }
- String passwd = sessConfMap.get(HIVE_AUTH_PASSWD);
- if ((passwd == null) || passwd.isEmpty()) {
- passwd = HIVE_ANONYMOUS_PASSWD;
- }
- String useSslStr = sessConfMap.get(HIVE_USE_SSL);
- if ("true".equalsIgnoreCase(useSslStr)) {
- String sslTrustStore = sessConfMap.get(HIVE_SSL_TRUST_STORE);
- String sslTrustStorePassword = sessConfMap.get(HIVE_SSL_TRUST_STORE_PASSWORD);
- if (sslTrustStore == null || sslTrustStore.isEmpty()) {
- transport = HiveAuthFactory.getSSLSocket(host, port, loginTimeout);
- } else {
- transport = HiveAuthFactory.getSSLSocket(host, port, loginTimeout,
+ // If there's a delegation token available then use token based connection
+ String tokenStr = getClientDelegationToken(sessConfMap);
+ if (tokenStr != null) {
+ transport = KerberosSaslHelper.getTokenTransport(tokenStr,
+ host, HiveAuthFactory.getSocketTransport(host, port, loginTimeout), saslProps);
+ } else {
+ // we are using PLAIN Sasl connection with user/password
+ String userName = sessConfMap.get(HIVE_AUTH_USER);
+ if ((userName == null) || userName.isEmpty()) {
+ userName = HIVE_ANONYMOUS_USER;
+ }
+ String passwd = sessConfMap.get(HIVE_AUTH_PASSWD);
+ if ((passwd == null) || passwd.isEmpty()) {
+ passwd = HIVE_ANONYMOUS_PASSWD;
+ }
+ String useSslStr = sessConfMap.get(HIVE_USE_SSL);
+ if ("true".equalsIgnoreCase(useSslStr)) {
+ // get SSL socket
+ String sslTrustStore = sessConfMap.get(HIVE_SSL_TRUST_STORE);
+ String sslTrustStorePassword = sessConfMap.get(HIVE_SSL_TRUST_STORE_PASSWORD);
+ if (sslTrustStore == null || sslTrustStore.isEmpty()) {
+ transport = HiveAuthFactory.getSSLSocket(host, port, loginTimeout);
+ } else {
+ transport = HiveAuthFactory.getSSLSocket(host, port, loginTimeout,
sslTrustStore, sslTrustStorePassword);
+ }
+ transport = PlainSaslHelper.getPlainTransport(userName, passwd, transport);
+ } else {
+ // get non-SSL socket transport
+ transport = HiveAuthFactory.getSocketTransport(host, port, loginTimeout);
}
- } else {
- transport = HiveAuthFactory.getSocketTransport(host, port, loginTimeout);
- }
+ // Overlay the SASL transport on top of the base socket transport (SSL or non-SSL)
transport = PlainSaslHelper.getPlainTransport(userName, passwd, transport);
+ }
}
} else {
+ // Raw socket connection (non-sasl)
transport = HiveAuthFactory.getSocketTransport(host, port, loginTimeout);
}
} catch (SaslException e) {
@@ -327,11 +370,32 @@ private boolean isHttpTransportMode() {
return false;
}
- private void openSession() throws SQLException {
+ // Lookup the delegation token. First in the connection URL, then Configuration
+ private String getClientDelegationToken(Map jdbcConnConf)
+ throws SQLException {
+ String tokenStr = null;
+ if (HIVE_AUTH_TOKEN.equalsIgnoreCase(jdbcConnConf.get(HIVE_AUTH_TYPE))) {
+ // check delegation token in job conf if any
+ try {
+ tokenStr = ShimLoader.getHadoopShims().
+ getTokenStrForm(HiveAuthFactory.HS2_CLIENT_TOKEN);
+ } catch (IOException e) {
+ throw new SQLException("Error reading token ", e);
+ }
+ }
+ return tokenStr;
+ }
+
+ private void openSession(Map sessVars) throws SQLException {
TOpenSessionReq openReq = new TOpenSessionReq();
// set the session configuration
- // openReq.setConfiguration(null);
+ if (sessVars.containsKey(HiveAuthFactory.HS2_PROXY_USER)) {
+ Map openConf = new HashMap();
+ openConf.put(HiveAuthFactory.HS2_PROXY_USER,
+ sessVars.get(HiveAuthFactory.HS2_PROXY_USER));
+ openReq.setConfiguration(openConf);
+ }
try {
TOpenSessionResp openResp = client.OpenSession(openReq);
@@ -420,6 +484,44 @@ public void abort(Executor executor) throws SQLException {
throw new SQLException("Method not supported");
}
+ public String getDelegationToken(String owner, String renewer) throws SQLException {
+ TGetDelegationTokenReq req = new TGetDelegationTokenReq(sessHandle, owner, renewer);
+ try {
+ TGetDelegationTokenResp tokenResp = client.GetDelegationToken(req);
+ Utils.verifySuccess(tokenResp.getStatus());
+ return tokenResp.getDelegationToken();
+ } catch (TException e) {
+ throw new SQLException("Could not retrieve token: " +
+ e.getMessage(), " 08S01", e);
+ }
+ }
+
+ public void cancelDelegationToken(String tokenStr) throws SQLException {
+ TCancelDelegationTokenReq cancelReq = new TCancelDelegationTokenReq(sessHandle, tokenStr);
+ try {
+ TCancelDelegationTokenResp cancelResp =
+ client.CancelDelegationToken(cancelReq);
+ Utils.verifySuccess(cancelResp.getStatus());
+ return;
+ } catch (TException e) {
+ throw new SQLException("Could not cancel token: " +
+ e.getMessage(), " 08S01", e);
+ }
+ }
+
+ public void renewDelegationToken(String tokenStr) throws SQLException {
+ TRenewDelegationTokenReq cancelReq = new TRenewDelegationTokenReq(sessHandle, tokenStr);
+ try {
+ TRenewDelegationTokenResp renewResp =
+ client.RenewDelegationToken(cancelReq);
+ Utils.verifySuccess(renewResp.getStatus());
+ return;
+ } catch (TException e) {
+ throw new SQLException("Could not renew token: " +
+ e.getMessage(), " 08S01", e);
+ }
+ }
+
/*
* (non-Javadoc)
*
diff --git jdbc/src/java/org/apache/hive/jdbc/Utils.java jdbc/src/java/org/apache/hive/jdbc/Utils.java
index 608837e..87fec11 100644
--- jdbc/src/java/org/apache/hive/jdbc/Utils.java
+++ jdbc/src/java/org/apache/hive/jdbc/Utils.java
@@ -145,7 +145,7 @@ public static JdbcConnectionParams parseURL(String uri) throws IllegalArgumentEx
JdbcConnectionParams connParams = new JdbcConnectionParams();
if (!uri.startsWith(URL_PREFIX)) {
- throw new IllegalArgumentException("Bad URL format");
+ throw new IllegalArgumentException("Bad URL format: Missing prefix " + URL_PREFIX);
}
// For URLs with no other configuration
@@ -197,7 +197,9 @@ public static JdbcConnectionParams parseURL(String uri) throws IllegalArgumentEx
if (sessVars != null) {
Matcher sessMatcher = pattern.matcher(sessVars);
while (sessMatcher.find()) {
- connParams.getSessionVars().put(sessMatcher.group(1), sessMatcher.group(2));
+ if (connParams.getSessionVars().put(sessMatcher.group(1), sessMatcher.group(2)) != null) {
+ throw new IllegalArgumentException("Bad URL format: Multiple values for property " + sessMatcher.group(1));
+ }
}
}
}
diff --git service/if/TCLIService.thrift service/if/TCLIService.thrift
index 43e6976..f2b24b9 100644
--- service/if/TCLIService.thrift
+++ service/if/TCLIService.thrift
@@ -1066,6 +1066,57 @@ struct TFetchResultsResp {
3: optional TRowSet results
}
+// GetDelegationToken()
+// Retrieve delegation token for the current user
+struct TGetDelegationTokenReq {
+ // session handle
+ 1: required TSessionHandle sessionHandle
+
+ // userid for the proxy user
+ 2: required string owner
+
+ // designated renewer userid
+ 3: required string renewer
+}
+
+struct TGetDelegationTokenResp {
+ // status of the request
+ 1: required TStatus status
+
+ // delegation token string
+ 2: optional string delegationToken
+}
+
+// CancelDelegationToken()
+// Cancel the given delegation token
+struct TCancelDelegationTokenReq {
+ // session handle
+ 1: required TSessionHandle sessionHandle
+
+ // delegation token to cancel
+ 2: required string delegationToken
+}
+
+struct TCancelDelegationTokenResp {
+ // status of the request
+ 1: required TStatus status
+}
+
+// RenewDelegationToken()
+// Renew the given delegation token
+struct TRenewDelegationTokenReq {
+ // session handle
+ 1: required TSessionHandle sessionHandle
+
+ // delegation token to renew
+ 2: required string delegationToken
+}
+
+struct TRenewDelegationTokenResp {
+ // status of the request
+ 1: required TStatus status
+}
+
service TCLIService {
TOpenSessionResp OpenSession(1:TOpenSessionReq req);
@@ -1097,6 +1148,12 @@ service TCLIService {
TCloseOperationResp CloseOperation(1:TCloseOperationReq req);
TGetResultSetMetadataResp GetResultSetMetadata(1:TGetResultSetMetadataReq req);
-
+
TFetchResultsResp FetchResults(1:TFetchResultsReq req);
+
+ TGetDelegationTokenResp GetDelegationToken(1:TGetDelegationTokenReq req);
+
+ TCancelDelegationTokenResp CancelDelegationToken(1:TCancelDelegationTokenReq req);
+
+ TRenewDelegationTokenResp RenewDelegationToken(1:TRenewDelegationTokenReq req);
}
diff --git service/src/gen/thrift/gen-cpp/TCLIService.cpp service/src/gen/thrift/gen-cpp/TCLIService.cpp
index f8afc09..209ce63 100644
--- service/src/gen/thrift/gen-cpp/TCLIService.cpp
+++ service/src/gen/thrift/gen-cpp/TCLIService.cpp
@@ -2600,6 +2600,492 @@ uint32_t TCLIService_FetchResults_presult::read(::apache::thrift::protocol::TPro
return xfer;
}
+uint32_t TCLIService_GetDelegationToken_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->req.read(iprot);
+ this->__isset.req = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_GetDelegationToken_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCLIService_GetDelegationToken_args");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->req.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_GetDelegationToken_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCLIService_GetDelegationToken_pargs");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->req)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_GetDelegationToken_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_GetDelegationToken_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("TCLIService_GetDelegationToken_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_GetDelegationToken_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_CancelDelegationToken_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->req.read(iprot);
+ this->__isset.req = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_CancelDelegationToken_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCLIService_CancelDelegationToken_args");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->req.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_CancelDelegationToken_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCLIService_CancelDelegationToken_pargs");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->req)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_CancelDelegationToken_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_CancelDelegationToken_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("TCLIService_CancelDelegationToken_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_CancelDelegationToken_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_RenewDelegationToken_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->req.read(iprot);
+ this->__isset.req = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_RenewDelegationToken_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCLIService_RenewDelegationToken_args");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->req.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_RenewDelegationToken_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCLIService_RenewDelegationToken_pargs");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->req)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_RenewDelegationToken_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_RenewDelegationToken_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("TCLIService_RenewDelegationToken_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t TCLIService_RenewDelegationToken_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
void TCLIServiceClient::OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req)
{
send_OpenSession(req);
@@ -3528,6 +4014,180 @@ void TCLIServiceClient::recv_FetchResults(TFetchResultsResp& _return)
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "FetchResults failed: unknown result");
}
+void TCLIServiceClient::GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req)
+{
+ send_GetDelegationToken(req);
+ recv_GetDelegationToken(_return);
+}
+
+void TCLIServiceClient::send_GetDelegationToken(const TGetDelegationTokenReq& req)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("GetDelegationToken", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_GetDelegationToken_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void TCLIServiceClient::recv_GetDelegationToken(TGetDelegationTokenResp& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("GetDelegationToken") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ TCLIService_GetDelegationToken_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "GetDelegationToken failed: unknown result");
+}
+
+void TCLIServiceClient::CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req)
+{
+ send_CancelDelegationToken(req);
+ recv_CancelDelegationToken(_return);
+}
+
+void TCLIServiceClient::send_CancelDelegationToken(const TCancelDelegationTokenReq& req)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("CancelDelegationToken", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_CancelDelegationToken_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void TCLIServiceClient::recv_CancelDelegationToken(TCancelDelegationTokenResp& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("CancelDelegationToken") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ TCLIService_CancelDelegationToken_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "CancelDelegationToken failed: unknown result");
+}
+
+void TCLIServiceClient::RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req)
+{
+ send_RenewDelegationToken(req);
+ recv_RenewDelegationToken(_return);
+}
+
+void TCLIServiceClient::send_RenewDelegationToken(const TRenewDelegationTokenReq& req)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("RenewDelegationToken", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_RenewDelegationToken_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void TCLIServiceClient::recv_RenewDelegationToken(TRenewDelegationTokenResp& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("RenewDelegationToken") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ TCLIService_RenewDelegationToken_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "RenewDelegationToken failed: unknown result");
+}
+
bool TCLIServiceProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
ProcessMap::iterator pfn;
pfn = processMap_.find(fname);
@@ -4411,6 +5071,168 @@ void TCLIServiceProcessor::process_FetchResults(int32_t seqid, ::apache::thrift:
}
}
+void TCLIServiceProcessor::process_GetDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("TCLIService.GetDelegationToken", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TCLIService.GetDelegationToken");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "TCLIService.GetDelegationToken");
+ }
+
+ TCLIService_GetDelegationToken_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "TCLIService.GetDelegationToken", bytes);
+ }
+
+ TCLIService_GetDelegationToken_result result;
+ try {
+ iface_->GetDelegationToken(result.success, args.req);
+ result.__isset.success = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "TCLIService.GetDelegationToken");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("GetDelegationToken", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "TCLIService.GetDelegationToken");
+ }
+
+ oprot->writeMessageBegin("GetDelegationToken", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "TCLIService.GetDelegationToken", bytes);
+ }
+}
+
+void TCLIServiceProcessor::process_CancelDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("TCLIService.CancelDelegationToken", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TCLIService.CancelDelegationToken");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "TCLIService.CancelDelegationToken");
+ }
+
+ TCLIService_CancelDelegationToken_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "TCLIService.CancelDelegationToken", bytes);
+ }
+
+ TCLIService_CancelDelegationToken_result result;
+ try {
+ iface_->CancelDelegationToken(result.success, args.req);
+ result.__isset.success = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "TCLIService.CancelDelegationToken");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("CancelDelegationToken", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "TCLIService.CancelDelegationToken");
+ }
+
+ oprot->writeMessageBegin("CancelDelegationToken", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "TCLIService.CancelDelegationToken", bytes);
+ }
+}
+
+void TCLIServiceProcessor::process_RenewDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("TCLIService.RenewDelegationToken", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TCLIService.RenewDelegationToken");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "TCLIService.RenewDelegationToken");
+ }
+
+ TCLIService_RenewDelegationToken_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "TCLIService.RenewDelegationToken", bytes);
+ }
+
+ TCLIService_RenewDelegationToken_result result;
+ try {
+ iface_->RenewDelegationToken(result.success, args.req);
+ result.__isset.success = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "TCLIService.RenewDelegationToken");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("RenewDelegationToken", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "TCLIService.RenewDelegationToken");
+ }
+
+ oprot->writeMessageBegin("RenewDelegationToken", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "TCLIService.RenewDelegationToken", bytes);
+ }
+}
+
::boost::shared_ptr< ::apache::thrift::TProcessor > TCLIServiceProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
::apache::thrift::ReleaseHandler< TCLIServiceIfFactory > cleanup(handlerFactory_);
::boost::shared_ptr< TCLIServiceIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
diff --git service/src/gen/thrift/gen-cpp/TCLIService.h service/src/gen/thrift/gen-cpp/TCLIService.h
index 055cfa6..030475b 100644
--- service/src/gen/thrift/gen-cpp/TCLIService.h
+++ service/src/gen/thrift/gen-cpp/TCLIService.h
@@ -31,6 +31,9 @@ class TCLIServiceIf {
virtual void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) = 0;
virtual void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) = 0;
virtual void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) = 0;
+ virtual void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) = 0;
+ virtual void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) = 0;
+ virtual void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) = 0;
};
class TCLIServiceIfFactory {
@@ -108,6 +111,15 @@ class TCLIServiceNull : virtual public TCLIServiceIf {
void FetchResults(TFetchResultsResp& /* _return */, const TFetchResultsReq& /* req */) {
return;
}
+ void GetDelegationToken(TGetDelegationTokenResp& /* _return */, const TGetDelegationTokenReq& /* req */) {
+ return;
+ }
+ void CancelDelegationToken(TCancelDelegationTokenResp& /* _return */, const TCancelDelegationTokenReq& /* req */) {
+ return;
+ }
+ void RenewDelegationToken(TRenewDelegationTokenResp& /* _return */, const TRenewDelegationTokenReq& /* req */) {
+ return;
+ }
};
typedef struct _TCLIService_OpenSession_args__isset {
@@ -1838,6 +1850,330 @@ class TCLIService_FetchResults_presult {
};
+typedef struct _TCLIService_GetDelegationToken_args__isset {
+ _TCLIService_GetDelegationToken_args__isset() : req(false) {}
+ bool req;
+} _TCLIService_GetDelegationToken_args__isset;
+
+class TCLIService_GetDelegationToken_args {
+ public:
+
+ TCLIService_GetDelegationToken_args() {
+ }
+
+ virtual ~TCLIService_GetDelegationToken_args() throw() {}
+
+ TGetDelegationTokenReq req;
+
+ _TCLIService_GetDelegationToken_args__isset __isset;
+
+ void __set_req(const TGetDelegationTokenReq& val) {
+ req = val;
+ }
+
+ bool operator == (const TCLIService_GetDelegationToken_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_GetDelegationToken_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_GetDelegationToken_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetDelegationToken_pargs {
+ public:
+
+
+ virtual ~TCLIService_GetDelegationToken_pargs() throw() {}
+
+ const TGetDelegationTokenReq* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetDelegationToken_result__isset {
+ _TCLIService_GetDelegationToken_result__isset() : success(false) {}
+ bool success;
+} _TCLIService_GetDelegationToken_result__isset;
+
+class TCLIService_GetDelegationToken_result {
+ public:
+
+ TCLIService_GetDelegationToken_result() {
+ }
+
+ virtual ~TCLIService_GetDelegationToken_result() throw() {}
+
+ TGetDelegationTokenResp success;
+
+ _TCLIService_GetDelegationToken_result__isset __isset;
+
+ void __set_success(const TGetDelegationTokenResp& val) {
+ success = val;
+ }
+
+ bool operator == (const TCLIService_GetDelegationToken_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_GetDelegationToken_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_GetDelegationToken_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetDelegationToken_presult__isset {
+ _TCLIService_GetDelegationToken_presult__isset() : success(false) {}
+ bool success;
+} _TCLIService_GetDelegationToken_presult__isset;
+
+class TCLIService_GetDelegationToken_presult {
+ public:
+
+
+ virtual ~TCLIService_GetDelegationToken_presult() throw() {}
+
+ TGetDelegationTokenResp* success;
+
+ _TCLIService_GetDelegationToken_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_CancelDelegationToken_args__isset {
+ _TCLIService_CancelDelegationToken_args__isset() : req(false) {}
+ bool req;
+} _TCLIService_CancelDelegationToken_args__isset;
+
+class TCLIService_CancelDelegationToken_args {
+ public:
+
+ TCLIService_CancelDelegationToken_args() {
+ }
+
+ virtual ~TCLIService_CancelDelegationToken_args() throw() {}
+
+ TCancelDelegationTokenReq req;
+
+ _TCLIService_CancelDelegationToken_args__isset __isset;
+
+ void __set_req(const TCancelDelegationTokenReq& val) {
+ req = val;
+ }
+
+ bool operator == (const TCLIService_CancelDelegationToken_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_CancelDelegationToken_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_CancelDelegationToken_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_CancelDelegationToken_pargs {
+ public:
+
+
+ virtual ~TCLIService_CancelDelegationToken_pargs() throw() {}
+
+ const TCancelDelegationTokenReq* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CancelDelegationToken_result__isset {
+ _TCLIService_CancelDelegationToken_result__isset() : success(false) {}
+ bool success;
+} _TCLIService_CancelDelegationToken_result__isset;
+
+class TCLIService_CancelDelegationToken_result {
+ public:
+
+ TCLIService_CancelDelegationToken_result() {
+ }
+
+ virtual ~TCLIService_CancelDelegationToken_result() throw() {}
+
+ TCancelDelegationTokenResp success;
+
+ _TCLIService_CancelDelegationToken_result__isset __isset;
+
+ void __set_success(const TCancelDelegationTokenResp& val) {
+ success = val;
+ }
+
+ bool operator == (const TCLIService_CancelDelegationToken_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_CancelDelegationToken_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_CancelDelegationToken_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CancelDelegationToken_presult__isset {
+ _TCLIService_CancelDelegationToken_presult__isset() : success(false) {}
+ bool success;
+} _TCLIService_CancelDelegationToken_presult__isset;
+
+class TCLIService_CancelDelegationToken_presult {
+ public:
+
+
+ virtual ~TCLIService_CancelDelegationToken_presult() throw() {}
+
+ TCancelDelegationTokenResp* success;
+
+ _TCLIService_CancelDelegationToken_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_RenewDelegationToken_args__isset {
+ _TCLIService_RenewDelegationToken_args__isset() : req(false) {}
+ bool req;
+} _TCLIService_RenewDelegationToken_args__isset;
+
+class TCLIService_RenewDelegationToken_args {
+ public:
+
+ TCLIService_RenewDelegationToken_args() {
+ }
+
+ virtual ~TCLIService_RenewDelegationToken_args() throw() {}
+
+ TRenewDelegationTokenReq req;
+
+ _TCLIService_RenewDelegationToken_args__isset __isset;
+
+ void __set_req(const TRenewDelegationTokenReq& val) {
+ req = val;
+ }
+
+ bool operator == (const TCLIService_RenewDelegationToken_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_RenewDelegationToken_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_RenewDelegationToken_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_RenewDelegationToken_pargs {
+ public:
+
+
+ virtual ~TCLIService_RenewDelegationToken_pargs() throw() {}
+
+ const TRenewDelegationTokenReq* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_RenewDelegationToken_result__isset {
+ _TCLIService_RenewDelegationToken_result__isset() : success(false) {}
+ bool success;
+} _TCLIService_RenewDelegationToken_result__isset;
+
+class TCLIService_RenewDelegationToken_result {
+ public:
+
+ TCLIService_RenewDelegationToken_result() {
+ }
+
+ virtual ~TCLIService_RenewDelegationToken_result() throw() {}
+
+ TRenewDelegationTokenResp success;
+
+ _TCLIService_RenewDelegationToken_result__isset __isset;
+
+ void __set_success(const TRenewDelegationTokenResp& val) {
+ success = val;
+ }
+
+ bool operator == (const TCLIService_RenewDelegationToken_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_RenewDelegationToken_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_RenewDelegationToken_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_RenewDelegationToken_presult__isset {
+ _TCLIService_RenewDelegationToken_presult__isset() : success(false) {}
+ bool success;
+} _TCLIService_RenewDelegationToken_presult__isset;
+
+class TCLIService_RenewDelegationToken_presult {
+ public:
+
+
+ virtual ~TCLIService_RenewDelegationToken_presult() throw() {}
+
+ TRenewDelegationTokenResp* success;
+
+ _TCLIService_RenewDelegationToken_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
class TCLIServiceClient : virtual public TCLIServiceIf {
public:
TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -1906,6 +2242,15 @@ class TCLIServiceClient : virtual public TCLIServiceIf {
void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req);
void send_FetchResults(const TFetchResultsReq& req);
void recv_FetchResults(TFetchResultsResp& _return);
+ void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req);
+ void send_GetDelegationToken(const TGetDelegationTokenReq& req);
+ void recv_GetDelegationToken(TGetDelegationTokenResp& _return);
+ void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req);
+ void send_CancelDelegationToken(const TCancelDelegationTokenReq& req);
+ void recv_CancelDelegationToken(TCancelDelegationTokenResp& _return);
+ void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req);
+ void send_RenewDelegationToken(const TRenewDelegationTokenReq& req);
+ void recv_RenewDelegationToken(TRenewDelegationTokenResp& _return);
protected:
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
@@ -1937,6 +2282,9 @@ class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
void process_CloseOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_GetResultSetMetadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_FetchResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_GetDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_CancelDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_RenewDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
public:
TCLIServiceProcessor(boost::shared_ptr iface) :
iface_(iface) {
@@ -1956,6 +2304,9 @@ class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
processMap_["CloseOperation"] = &TCLIServiceProcessor::process_CloseOperation;
processMap_["GetResultSetMetadata"] = &TCLIServiceProcessor::process_GetResultSetMetadata;
processMap_["FetchResults"] = &TCLIServiceProcessor::process_FetchResults;
+ processMap_["GetDelegationToken"] = &TCLIServiceProcessor::process_GetDelegationToken;
+ processMap_["CancelDelegationToken"] = &TCLIServiceProcessor::process_CancelDelegationToken;
+ processMap_["RenewDelegationToken"] = &TCLIServiceProcessor::process_RenewDelegationToken;
}
virtual ~TCLIServiceProcessor() {}
@@ -2144,6 +2495,36 @@ class TCLIServiceMultiface : virtual public TCLIServiceIf {
return;
}
+ void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->GetDelegationToken(_return, req);
+ }
+ ifaces_[i]->GetDelegationToken(_return, req);
+ return;
+ }
+
+ void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->CancelDelegationToken(_return, req);
+ }
+ ifaces_[i]->CancelDelegationToken(_return, req);
+ return;
+ }
+
+ void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->RenewDelegationToken(_return, req);
+ }
+ ifaces_[i]->RenewDelegationToken(_return, req);
+ return;
+ }
+
};
}}}}} // namespace
diff --git service/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp service/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp
index d1d31cb..988bb4c 100644
--- service/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp
+++ service/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp
@@ -102,6 +102,21 @@ class TCLIServiceHandler : virtual public TCLIServiceIf {
printf("FetchResults\n");
}
+ void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) {
+ // Your implementation goes here
+ printf("GetDelegationToken\n");
+ }
+
+ void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) {
+ // Your implementation goes here
+ printf("CancelDelegationToken\n");
+ }
+
+ void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) {
+ // Your implementation goes here
+ printf("RenewDelegationToken\n");
+ }
+
};
int main(int argc, char **argv) {
diff --git service/src/gen/thrift/gen-cpp/TCLIService_types.cpp service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
index ff7df74..92199a0 100644
--- service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
+++ service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -6326,4 +6326,467 @@ void swap(TFetchResultsResp &a, TFetchResultsResp &b) {
swap(a.__isset, b.__isset);
}
+const char* TGetDelegationTokenReq::ascii_fingerprint = "07EA0311716A27924914E4354ED22D6C";
+const uint8_t TGetDelegationTokenReq::binary_fingerprint[16] = {0x07,0xEA,0x03,0x11,0x71,0x6A,0x27,0x92,0x49,0x14,0xE4,0x35,0x4E,0xD2,0x2D,0x6C};
+
+uint32_t TGetDelegationTokenReq::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_sessionHandle = false;
+ bool isset_owner = false;
+ bool isset_renewer = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ isset_sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->owner);
+ isset_owner = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->renewer);
+ isset_renewer = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_owner)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_renewer)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TGetDelegationTokenReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TGetDelegationTokenReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("owner", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->owner);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("renewer", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->renewer);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TGetDelegationTokenReq &a, TGetDelegationTokenReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.owner, b.owner);
+ swap(a.renewer, b.renewer);
+}
+
+const char* TGetDelegationTokenResp::ascii_fingerprint = "C0E132DC412CEA08D771EAC38CEA1DA6";
+const uint8_t TGetDelegationTokenResp::binary_fingerprint[16] = {0xC0,0xE1,0x32,0xDC,0x41,0x2C,0xEA,0x08,0xD7,0x71,0xEA,0xC3,0x8C,0xEA,0x1D,0xA6};
+
+uint32_t TGetDelegationTokenResp::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_status = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->status.read(iprot);
+ isset_status = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->delegationToken);
+ this->__isset.delegationToken = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_status)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TGetDelegationTokenResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TGetDelegationTokenResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.delegationToken) {
+ xfer += oprot->writeFieldBegin("delegationToken", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->delegationToken);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TGetDelegationTokenResp &a, TGetDelegationTokenResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+ swap(a.delegationToken, b.delegationToken);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TCancelDelegationTokenReq::ascii_fingerprint = "1A3D66269336B7EC66998BFE1BECDE75";
+const uint8_t TCancelDelegationTokenReq::binary_fingerprint[16] = {0x1A,0x3D,0x66,0x26,0x93,0x36,0xB7,0xEC,0x66,0x99,0x8B,0xFE,0x1B,0xEC,0xDE,0x75};
+
+uint32_t TCancelDelegationTokenReq::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_sessionHandle = false;
+ bool isset_delegationToken = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ isset_sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->delegationToken);
+ isset_delegationToken = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_delegationToken)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TCancelDelegationTokenReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCancelDelegationTokenReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("delegationToken", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->delegationToken);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TCancelDelegationTokenReq &a, TCancelDelegationTokenReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.delegationToken, b.delegationToken);
+}
+
+const char* TCancelDelegationTokenResp::ascii_fingerprint = "7142E89F09DC7C5F6FA916C7393F46C2";
+const uint8_t TCancelDelegationTokenResp::binary_fingerprint[16] = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
+uint32_t TCancelDelegationTokenResp::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_status = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->status.read(iprot);
+ isset_status = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_status)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TCancelDelegationTokenResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TCancelDelegationTokenResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TCancelDelegationTokenResp &a, TCancelDelegationTokenResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+}
+
+const char* TRenewDelegationTokenReq::ascii_fingerprint = "1A3D66269336B7EC66998BFE1BECDE75";
+const uint8_t TRenewDelegationTokenReq::binary_fingerprint[16] = {0x1A,0x3D,0x66,0x26,0x93,0x36,0xB7,0xEC,0x66,0x99,0x8B,0xFE,0x1B,0xEC,0xDE,0x75};
+
+uint32_t TRenewDelegationTokenReq::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_sessionHandle = false;
+ bool isset_delegationToken = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ isset_sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->delegationToken);
+ isset_delegationToken = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_delegationToken)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TRenewDelegationTokenReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TRenewDelegationTokenReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("delegationToken", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->delegationToken);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TRenewDelegationTokenReq &a, TRenewDelegationTokenReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.delegationToken, b.delegationToken);
+}
+
+const char* TRenewDelegationTokenResp::ascii_fingerprint = "7142E89F09DC7C5F6FA916C7393F46C2";
+const uint8_t TRenewDelegationTokenResp::binary_fingerprint[16] = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
+uint32_t TRenewDelegationTokenResp::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_status = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->status.read(iprot);
+ isset_status = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_status)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TRenewDelegationTokenResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TRenewDelegationTokenResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TRenewDelegationTokenResp &a, TRenewDelegationTokenResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+}
+
}}}}} // namespace
diff --git service/src/gen/thrift/gen-cpp/TCLIService_types.h service/src/gen/thrift/gen-cpp/TCLIService_types.h
index 950bf25..e884b44 100644
--- service/src/gen/thrift/gen-cpp/TCLIService_types.h
+++ service/src/gen/thrift/gen-cpp/TCLIService_types.h
@@ -3718,6 +3718,272 @@ class TFetchResultsResp {
void swap(TFetchResultsResp &a, TFetchResultsResp &b);
+
+class TGetDelegationTokenReq {
+ public:
+
+ static const char* ascii_fingerprint; // = "07EA0311716A27924914E4354ED22D6C";
+ static const uint8_t binary_fingerprint[16]; // = {0x07,0xEA,0x03,0x11,0x71,0x6A,0x27,0x92,0x49,0x14,0xE4,0x35,0x4E,0xD2,0x2D,0x6C};
+
+ TGetDelegationTokenReq() : owner(), renewer() {
+ }
+
+ virtual ~TGetDelegationTokenReq() throw() {}
+
+ TSessionHandle sessionHandle;
+ std::string owner;
+ std::string renewer;
+
+ void __set_sessionHandle(const TSessionHandle& val) {
+ sessionHandle = val;
+ }
+
+ void __set_owner(const std::string& val) {
+ owner = val;
+ }
+
+ void __set_renewer(const std::string& val) {
+ renewer = val;
+ }
+
+ bool operator == (const TGetDelegationTokenReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (!(owner == rhs.owner))
+ return false;
+ if (!(renewer == rhs.renewer))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetDelegationTokenReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetDelegationTokenReq & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TGetDelegationTokenReq &a, TGetDelegationTokenReq &b);
+
+typedef struct _TGetDelegationTokenResp__isset {
+ _TGetDelegationTokenResp__isset() : delegationToken(false) {}
+ bool delegationToken;
+} _TGetDelegationTokenResp__isset;
+
+class TGetDelegationTokenResp {
+ public:
+
+ static const char* ascii_fingerprint; // = "C0E132DC412CEA08D771EAC38CEA1DA6";
+ static const uint8_t binary_fingerprint[16]; // = {0xC0,0xE1,0x32,0xDC,0x41,0x2C,0xEA,0x08,0xD7,0x71,0xEA,0xC3,0x8C,0xEA,0x1D,0xA6};
+
+ TGetDelegationTokenResp() : delegationToken() {
+ }
+
+ virtual ~TGetDelegationTokenResp() throw() {}
+
+ TStatus status;
+ std::string delegationToken;
+
+ _TGetDelegationTokenResp__isset __isset;
+
+ void __set_status(const TStatus& val) {
+ status = val;
+ }
+
+ void __set_delegationToken(const std::string& val) {
+ delegationToken = val;
+ __isset.delegationToken = true;
+ }
+
+ bool operator == (const TGetDelegationTokenResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ if (__isset.delegationToken != rhs.__isset.delegationToken)
+ return false;
+ else if (__isset.delegationToken && !(delegationToken == rhs.delegationToken))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetDelegationTokenResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetDelegationTokenResp & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TGetDelegationTokenResp &a, TGetDelegationTokenResp &b);
+
+
+class TCancelDelegationTokenReq {
+ public:
+
+ static const char* ascii_fingerprint; // = "1A3D66269336B7EC66998BFE1BECDE75";
+ static const uint8_t binary_fingerprint[16]; // = {0x1A,0x3D,0x66,0x26,0x93,0x36,0xB7,0xEC,0x66,0x99,0x8B,0xFE,0x1B,0xEC,0xDE,0x75};
+
+ TCancelDelegationTokenReq() : delegationToken() {
+ }
+
+ virtual ~TCancelDelegationTokenReq() throw() {}
+
+ TSessionHandle sessionHandle;
+ std::string delegationToken;
+
+ void __set_sessionHandle(const TSessionHandle& val) {
+ sessionHandle = val;
+ }
+
+ void __set_delegationToken(const std::string& val) {
+ delegationToken = val;
+ }
+
+ bool operator == (const TCancelDelegationTokenReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (!(delegationToken == rhs.delegationToken))
+ return false;
+ return true;
+ }
+ bool operator != (const TCancelDelegationTokenReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCancelDelegationTokenReq & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TCancelDelegationTokenReq &a, TCancelDelegationTokenReq &b);
+
+
+class TCancelDelegationTokenResp {
+ public:
+
+ static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+ static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
+ TCancelDelegationTokenResp() {
+ }
+
+ virtual ~TCancelDelegationTokenResp() throw() {}
+
+ TStatus status;
+
+ void __set_status(const TStatus& val) {
+ status = val;
+ }
+
+ bool operator == (const TCancelDelegationTokenResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ return true;
+ }
+ bool operator != (const TCancelDelegationTokenResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCancelDelegationTokenResp & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TCancelDelegationTokenResp &a, TCancelDelegationTokenResp &b);
+
+
+class TRenewDelegationTokenReq {
+ public:
+
+ static const char* ascii_fingerprint; // = "1A3D66269336B7EC66998BFE1BECDE75";
+ static const uint8_t binary_fingerprint[16]; // = {0x1A,0x3D,0x66,0x26,0x93,0x36,0xB7,0xEC,0x66,0x99,0x8B,0xFE,0x1B,0xEC,0xDE,0x75};
+
+ TRenewDelegationTokenReq() : delegationToken() {
+ }
+
+ virtual ~TRenewDelegationTokenReq() throw() {}
+
+ TSessionHandle sessionHandle;
+ std::string delegationToken;
+
+ void __set_sessionHandle(const TSessionHandle& val) {
+ sessionHandle = val;
+ }
+
+ void __set_delegationToken(const std::string& val) {
+ delegationToken = val;
+ }
+
+ bool operator == (const TRenewDelegationTokenReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (!(delegationToken == rhs.delegationToken))
+ return false;
+ return true;
+ }
+ bool operator != (const TRenewDelegationTokenReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TRenewDelegationTokenReq & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TRenewDelegationTokenReq &a, TRenewDelegationTokenReq &b);
+
+
+class TRenewDelegationTokenResp {
+ public:
+
+ static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+ static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
+ TRenewDelegationTokenResp() {
+ }
+
+ virtual ~TRenewDelegationTokenResp() throw() {}
+
+ TStatus status;
+
+ void __set_status(const TStatus& val) {
+ status = val;
+ }
+
+ bool operator == (const TRenewDelegationTokenResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ return true;
+ }
+ bool operator != (const TRenewDelegationTokenResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TRenewDelegationTokenResp & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TRenewDelegationTokenResp &a, TRenewDelegationTokenResp &b);
+
}}}}} // namespace
#endif
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIService.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIService.java
index b296c66..54851b8 100644
--- service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIService.java
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCLIService.java
@@ -67,6 +67,12 @@
public TFetchResultsResp FetchResults(TFetchResultsReq req) throws org.apache.thrift.TException;
+ public TGetDelegationTokenResp GetDelegationToken(TGetDelegationTokenReq req) throws org.apache.thrift.TException;
+
+ public TCancelDelegationTokenResp CancelDelegationToken(TCancelDelegationTokenReq req) throws org.apache.thrift.TException;
+
+ public TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req) throws org.apache.thrift.TException;
+
}
public interface AsyncIface {
@@ -103,6 +109,12 @@
public void FetchResults(TFetchResultsReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;
+ public void GetDelegationToken(TGetDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;
+
+ public void CancelDelegationToken(TCancelDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;
+
+ public void RenewDelegationToken(TRenewDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;
+
}
public static class Client extends org.apache.thrift.TServiceClient implements Iface {
@@ -493,6 +505,75 @@ public TFetchResultsResp recv_FetchResults() throws org.apache.thrift.TException
throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "FetchResults failed: unknown result");
}
+ public TGetDelegationTokenResp GetDelegationToken(TGetDelegationTokenReq req) throws org.apache.thrift.TException
+ {
+ send_GetDelegationToken(req);
+ return recv_GetDelegationToken();
+ }
+
+ public void send_GetDelegationToken(TGetDelegationTokenReq req) throws org.apache.thrift.TException
+ {
+ GetDelegationToken_args args = new GetDelegationToken_args();
+ args.setReq(req);
+ sendBase("GetDelegationToken", args);
+ }
+
+ public TGetDelegationTokenResp recv_GetDelegationToken() throws org.apache.thrift.TException
+ {
+ GetDelegationToken_result result = new GetDelegationToken_result();
+ receiveBase(result, "GetDelegationToken");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "GetDelegationToken failed: unknown result");
+ }
+
+ public TCancelDelegationTokenResp CancelDelegationToken(TCancelDelegationTokenReq req) throws org.apache.thrift.TException
+ {
+ send_CancelDelegationToken(req);
+ return recv_CancelDelegationToken();
+ }
+
+ public void send_CancelDelegationToken(TCancelDelegationTokenReq req) throws org.apache.thrift.TException
+ {
+ CancelDelegationToken_args args = new CancelDelegationToken_args();
+ args.setReq(req);
+ sendBase("CancelDelegationToken", args);
+ }
+
+ public TCancelDelegationTokenResp recv_CancelDelegationToken() throws org.apache.thrift.TException
+ {
+ CancelDelegationToken_result result = new CancelDelegationToken_result();
+ receiveBase(result, "CancelDelegationToken");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "CancelDelegationToken failed: unknown result");
+ }
+
+ public TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req) throws org.apache.thrift.TException
+ {
+ send_RenewDelegationToken(req);
+ return recv_RenewDelegationToken();
+ }
+
+ public void send_RenewDelegationToken(TRenewDelegationTokenReq req) throws org.apache.thrift.TException
+ {
+ RenewDelegationToken_args args = new RenewDelegationToken_args();
+ args.setReq(req);
+ sendBase("RenewDelegationToken", args);
+ }
+
+ public TRenewDelegationTokenResp recv_RenewDelegationToken() throws org.apache.thrift.TException
+ {
+ RenewDelegationToken_result result = new RenewDelegationToken_result();
+ receiveBase(result, "RenewDelegationToken");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "RenewDelegationToken failed: unknown result");
+ }
+
}
public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
public static class Factory implements org.apache.thrift.async.TAsyncClientFactory {
@@ -1023,6 +1104,102 @@ public TFetchResultsResp getResult() throws org.apache.thrift.TException {
}
}
+ public void GetDelegationToken(TGetDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ GetDelegationToken_call method_call = new GetDelegationToken_call(req, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class GetDelegationToken_call extends org.apache.thrift.async.TAsyncMethodCall {
+ private TGetDelegationTokenReq req;
+ public GetDelegationToken_call(TGetDelegationTokenReq req, 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.req = req;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("GetDelegationToken", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ GetDelegationToken_args args = new GetDelegationToken_args();
+ args.setReq(req);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TGetDelegationTokenResp getResult() throws 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_GetDelegationToken();
+ }
+ }
+
+ public void CancelDelegationToken(TCancelDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ CancelDelegationToken_call method_call = new CancelDelegationToken_call(req, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class CancelDelegationToken_call extends org.apache.thrift.async.TAsyncMethodCall {
+ private TCancelDelegationTokenReq req;
+ public CancelDelegationToken_call(TCancelDelegationTokenReq req, 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.req = req;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("CancelDelegationToken", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ CancelDelegationToken_args args = new CancelDelegationToken_args();
+ args.setReq(req);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TCancelDelegationTokenResp getResult() throws 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_CancelDelegationToken();
+ }
+ }
+
+ public void RenewDelegationToken(TRenewDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ RenewDelegationToken_call method_call = new RenewDelegationToken_call(req, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class RenewDelegationToken_call extends org.apache.thrift.async.TAsyncMethodCall {
+ private TRenewDelegationTokenReq req;
+ public RenewDelegationToken_call(TRenewDelegationTokenReq req, 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.req = req;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("RenewDelegationToken", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ RenewDelegationToken_args args = new RenewDelegationToken_args();
+ args.setReq(req);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TRenewDelegationTokenResp getResult() throws 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_RenewDelegationToken();
+ }
+ }
+
}
public static class Processor extends org.apache.thrift.TBaseProcessor implements org.apache.thrift.TProcessor {
@@ -1052,6 +1229,9 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction {
+ public GetDelegationToken() {
+ super("GetDelegationToken");
+ }
+
+ public GetDelegationToken_args getEmptyArgsInstance() {
+ return new GetDelegationToken_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public GetDelegationToken_result getResult(I iface, GetDelegationToken_args args) throws org.apache.thrift.TException {
+ GetDelegationToken_result result = new GetDelegationToken_result();
+ result.success = iface.GetDelegationToken(args.req);
+ return result;
+ }
+ }
+
+ public static class CancelDelegationToken extends org.apache.thrift.ProcessFunction {
+ public CancelDelegationToken() {
+ super("CancelDelegationToken");
+ }
+
+ public CancelDelegationToken_args getEmptyArgsInstance() {
+ return new CancelDelegationToken_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public CancelDelegationToken_result getResult(I iface, CancelDelegationToken_args args) throws org.apache.thrift.TException {
+ CancelDelegationToken_result result = new CancelDelegationToken_result();
+ result.success = iface.CancelDelegationToken(args.req);
+ return result;
+ }
+ }
+
+ public static class RenewDelegationToken extends org.apache.thrift.ProcessFunction {
+ public RenewDelegationToken() {
+ super("RenewDelegationToken");
+ }
+
+ public RenewDelegationToken_args getEmptyArgsInstance() {
+ return new RenewDelegationToken_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public RenewDelegationToken_result getResult(I iface, RenewDelegationToken_args args) throws org.apache.thrift.TException {
+ RenewDelegationToken_result result = new RenewDelegationToken_result();
+ result.success = iface.RenewDelegationToken(args.req);
+ return result;
+ }
+ }
+
}
public static class OpenSession_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable {
@@ -12993,4 +13233,2182 @@ public void read(org.apache.thrift.protocol.TProtocol prot, FetchResults_result
}
+ public static class GetDelegationToken_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("GetDelegationToken_args");
+
+ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new GetDelegationToken_argsStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new GetDelegationToken_argsTupleSchemeFactory());
+ }
+
+ private TGetDelegationTokenReq req; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REQ((short)1, "req");
+
+ 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 1: // REQ
+ return REQ;
+ 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
+ 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.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGetDelegationTokenReq.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetDelegationToken_args.class, metaDataMap);
+ }
+
+ public GetDelegationToken_args() {
+ }
+
+ public GetDelegationToken_args(
+ TGetDelegationTokenReq req)
+ {
+ this();
+ this.req = req;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public GetDelegationToken_args(GetDelegationToken_args other) {
+ if (other.isSetReq()) {
+ this.req = new TGetDelegationTokenReq(other.req);
+ }
+ }
+
+ public GetDelegationToken_args deepCopy() {
+ return new GetDelegationToken_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.req = null;
+ }
+
+ public TGetDelegationTokenReq getReq() {
+ return this.req;
+ }
+
+ public void setReq(TGetDelegationTokenReq req) {
+ this.req = req;
+ }
+
+ public void unsetReq() {
+ this.req = null;
+ }
+
+ /** Returns true if field req is set (has been assigned a value) and false otherwise */
+ public boolean isSetReq() {
+ return this.req != null;
+ }
+
+ public void setReqIsSet(boolean value) {
+ if (!value) {
+ this.req = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case REQ:
+ if (value == null) {
+ unsetReq();
+ } else {
+ setReq((TGetDelegationTokenReq)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REQ:
+ return getReq();
+
+ }
+ 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 REQ:
+ return isSetReq();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof GetDelegationToken_args)
+ return this.equals((GetDelegationToken_args)that);
+ return false;
+ }
+
+ public boolean equals(GetDelegationToken_args that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_req = true && this.isSetReq();
+ boolean that_present_req = true && that.isSetReq();
+ if (this_present_req || that_present_req) {
+ if (!(this_present_req && that_present_req))
+ return false;
+ if (!this.req.equals(that.req))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_req = true && (isSetReq());
+ builder.append(present_req);
+ if (present_req)
+ builder.append(req);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(GetDelegationToken_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ GetDelegationToken_args typedOther = (GetDelegationToken_args)other;
+
+ lastComparison = Boolean.valueOf(isSetReq()).compareTo(typedOther.isSetReq());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReq()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, typedOther.req);
+ 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("GetDelegationToken_args(");
+ boolean first = true;
+
+ sb.append("req:");
+ if (this.req == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.req);
+ }
+ 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 (req != null) {
+ req.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 {
+ 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 GetDelegationToken_argsStandardSchemeFactory implements SchemeFactory {
+ public GetDelegationToken_argsStandardScheme getScheme() {
+ return new GetDelegationToken_argsStandardScheme();
+ }
+ }
+
+ private static class GetDelegationToken_argsStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, GetDelegationToken_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: // REQ
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.req = new TGetDelegationTokenReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, GetDelegationToken_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.req != null) {
+ oprot.writeFieldBegin(REQ_FIELD_DESC);
+ struct.req.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class GetDelegationToken_argsTupleSchemeFactory implements SchemeFactory {
+ public GetDelegationToken_argsTupleScheme getScheme() {
+ return new GetDelegationToken_argsTupleScheme();
+ }
+ }
+
+ private static class GetDelegationToken_argsTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, GetDelegationToken_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetReq()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReq()) {
+ struct.req.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, GetDelegationToken_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.req = new TGetDelegationTokenReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ }
+ }
+ }
+
+ }
+
+ public static class GetDelegationToken_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("GetDelegationToken_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new GetDelegationToken_resultStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new GetDelegationToken_resultTupleSchemeFactory());
+ }
+
+ private TGetDelegationTokenResp success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ 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;
+ 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
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGetDelegationTokenResp.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetDelegationToken_result.class, metaDataMap);
+ }
+
+ public GetDelegationToken_result() {
+ }
+
+ public GetDelegationToken_result(
+ TGetDelegationTokenResp success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public GetDelegationToken_result(GetDelegationToken_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TGetDelegationTokenResp(other.success);
+ }
+ }
+
+ public GetDelegationToken_result deepCopy() {
+ return new GetDelegationToken_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ public TGetDelegationTokenResp getSuccess() {
+ return this.success;
+ }
+
+ public void setSuccess(TGetDelegationTokenResp success) {
+ this.success = success;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TGetDelegationTokenResp)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ 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();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof GetDelegationToken_result)
+ return this.equals((GetDelegationToken_result)that);
+ return false;
+ }
+
+ public boolean equals(GetDelegationToken_result that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_success = true && (isSetSuccess());
+ builder.append(present_success);
+ if (present_success)
+ builder.append(success);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(GetDelegationToken_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ GetDelegationToken_result typedOther = (GetDelegationToken_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;
+ }
+ }
+ 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("GetDelegationToken_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ 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 (success != null) {
+ success.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 {
+ 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 GetDelegationToken_resultStandardSchemeFactory implements SchemeFactory {
+ public GetDelegationToken_resultStandardScheme getScheme() {
+ return new GetDelegationToken_resultStandardScheme();
+ }
+ }
+
+ private static class GetDelegationToken_resultStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, GetDelegationToken_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.STRUCT) {
+ struct.success = new TGetDelegationTokenResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, GetDelegationToken_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class GetDelegationToken_resultTupleSchemeFactory implements SchemeFactory {
+ public GetDelegationToken_resultTupleScheme getScheme() {
+ return new GetDelegationToken_resultTupleScheme();
+ }
+ }
+
+ private static class GetDelegationToken_resultTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, GetDelegationToken_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, GetDelegationToken_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = new TGetDelegationTokenResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ }
+
+ public static class CancelDelegationToken_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("CancelDelegationToken_args");
+
+ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new CancelDelegationToken_argsStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new CancelDelegationToken_argsTupleSchemeFactory());
+ }
+
+ private TCancelDelegationTokenReq req; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REQ((short)1, "req");
+
+ 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 1: // REQ
+ return REQ;
+ 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
+ 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.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCancelDelegationTokenReq.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CancelDelegationToken_args.class, metaDataMap);
+ }
+
+ public CancelDelegationToken_args() {
+ }
+
+ public CancelDelegationToken_args(
+ TCancelDelegationTokenReq req)
+ {
+ this();
+ this.req = req;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public CancelDelegationToken_args(CancelDelegationToken_args other) {
+ if (other.isSetReq()) {
+ this.req = new TCancelDelegationTokenReq(other.req);
+ }
+ }
+
+ public CancelDelegationToken_args deepCopy() {
+ return new CancelDelegationToken_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.req = null;
+ }
+
+ public TCancelDelegationTokenReq getReq() {
+ return this.req;
+ }
+
+ public void setReq(TCancelDelegationTokenReq req) {
+ this.req = req;
+ }
+
+ public void unsetReq() {
+ this.req = null;
+ }
+
+ /** Returns true if field req is set (has been assigned a value) and false otherwise */
+ public boolean isSetReq() {
+ return this.req != null;
+ }
+
+ public void setReqIsSet(boolean value) {
+ if (!value) {
+ this.req = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case REQ:
+ if (value == null) {
+ unsetReq();
+ } else {
+ setReq((TCancelDelegationTokenReq)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REQ:
+ return getReq();
+
+ }
+ 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 REQ:
+ return isSetReq();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof CancelDelegationToken_args)
+ return this.equals((CancelDelegationToken_args)that);
+ return false;
+ }
+
+ public boolean equals(CancelDelegationToken_args that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_req = true && this.isSetReq();
+ boolean that_present_req = true && that.isSetReq();
+ if (this_present_req || that_present_req) {
+ if (!(this_present_req && that_present_req))
+ return false;
+ if (!this.req.equals(that.req))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_req = true && (isSetReq());
+ builder.append(present_req);
+ if (present_req)
+ builder.append(req);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(CancelDelegationToken_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ CancelDelegationToken_args typedOther = (CancelDelegationToken_args)other;
+
+ lastComparison = Boolean.valueOf(isSetReq()).compareTo(typedOther.isSetReq());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReq()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, typedOther.req);
+ 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("CancelDelegationToken_args(");
+ boolean first = true;
+
+ sb.append("req:");
+ if (this.req == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.req);
+ }
+ 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 (req != null) {
+ req.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 {
+ 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 CancelDelegationToken_argsStandardSchemeFactory implements SchemeFactory {
+ public CancelDelegationToken_argsStandardScheme getScheme() {
+ return new CancelDelegationToken_argsStandardScheme();
+ }
+ }
+
+ private static class CancelDelegationToken_argsStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, CancelDelegationToken_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: // REQ
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.req = new TCancelDelegationTokenReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, CancelDelegationToken_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.req != null) {
+ oprot.writeFieldBegin(REQ_FIELD_DESC);
+ struct.req.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class CancelDelegationToken_argsTupleSchemeFactory implements SchemeFactory {
+ public CancelDelegationToken_argsTupleScheme getScheme() {
+ return new CancelDelegationToken_argsTupleScheme();
+ }
+ }
+
+ private static class CancelDelegationToken_argsTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, CancelDelegationToken_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetReq()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReq()) {
+ struct.req.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, CancelDelegationToken_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.req = new TCancelDelegationTokenReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ }
+ }
+ }
+
+ }
+
+ public static class CancelDelegationToken_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("CancelDelegationToken_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new CancelDelegationToken_resultStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new CancelDelegationToken_resultTupleSchemeFactory());
+ }
+
+ private TCancelDelegationTokenResp success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ 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;
+ 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
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TCancelDelegationTokenResp.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CancelDelegationToken_result.class, metaDataMap);
+ }
+
+ public CancelDelegationToken_result() {
+ }
+
+ public CancelDelegationToken_result(
+ TCancelDelegationTokenResp success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public CancelDelegationToken_result(CancelDelegationToken_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TCancelDelegationTokenResp(other.success);
+ }
+ }
+
+ public CancelDelegationToken_result deepCopy() {
+ return new CancelDelegationToken_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ public TCancelDelegationTokenResp getSuccess() {
+ return this.success;
+ }
+
+ public void setSuccess(TCancelDelegationTokenResp success) {
+ this.success = success;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TCancelDelegationTokenResp)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ 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();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof CancelDelegationToken_result)
+ return this.equals((CancelDelegationToken_result)that);
+ return false;
+ }
+
+ public boolean equals(CancelDelegationToken_result that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_success = true && (isSetSuccess());
+ builder.append(present_success);
+ if (present_success)
+ builder.append(success);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(CancelDelegationToken_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ CancelDelegationToken_result typedOther = (CancelDelegationToken_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;
+ }
+ }
+ 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("CancelDelegationToken_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ 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 (success != null) {
+ success.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 {
+ 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 CancelDelegationToken_resultStandardSchemeFactory implements SchemeFactory {
+ public CancelDelegationToken_resultStandardScheme getScheme() {
+ return new CancelDelegationToken_resultStandardScheme();
+ }
+ }
+
+ private static class CancelDelegationToken_resultStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, CancelDelegationToken_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.STRUCT) {
+ struct.success = new TCancelDelegationTokenResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, CancelDelegationToken_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class CancelDelegationToken_resultTupleSchemeFactory implements SchemeFactory {
+ public CancelDelegationToken_resultTupleScheme getScheme() {
+ return new CancelDelegationToken_resultTupleScheme();
+ }
+ }
+
+ private static class CancelDelegationToken_resultTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, CancelDelegationToken_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, CancelDelegationToken_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = new TCancelDelegationTokenResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ }
+
+ public static class RenewDelegationToken_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("RenewDelegationToken_args");
+
+ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new RenewDelegationToken_argsStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new RenewDelegationToken_argsTupleSchemeFactory());
+ }
+
+ private TRenewDelegationTokenReq req; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REQ((short)1, "req");
+
+ 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 1: // REQ
+ return REQ;
+ 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
+ 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.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRenewDelegationTokenReq.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RenewDelegationToken_args.class, metaDataMap);
+ }
+
+ public RenewDelegationToken_args() {
+ }
+
+ public RenewDelegationToken_args(
+ TRenewDelegationTokenReq req)
+ {
+ this();
+ this.req = req;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public RenewDelegationToken_args(RenewDelegationToken_args other) {
+ if (other.isSetReq()) {
+ this.req = new TRenewDelegationTokenReq(other.req);
+ }
+ }
+
+ public RenewDelegationToken_args deepCopy() {
+ return new RenewDelegationToken_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.req = null;
+ }
+
+ public TRenewDelegationTokenReq getReq() {
+ return this.req;
+ }
+
+ public void setReq(TRenewDelegationTokenReq req) {
+ this.req = req;
+ }
+
+ public void unsetReq() {
+ this.req = null;
+ }
+
+ /** Returns true if field req is set (has been assigned a value) and false otherwise */
+ public boolean isSetReq() {
+ return this.req != null;
+ }
+
+ public void setReqIsSet(boolean value) {
+ if (!value) {
+ this.req = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case REQ:
+ if (value == null) {
+ unsetReq();
+ } else {
+ setReq((TRenewDelegationTokenReq)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REQ:
+ return getReq();
+
+ }
+ 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 REQ:
+ return isSetReq();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof RenewDelegationToken_args)
+ return this.equals((RenewDelegationToken_args)that);
+ return false;
+ }
+
+ public boolean equals(RenewDelegationToken_args that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_req = true && this.isSetReq();
+ boolean that_present_req = true && that.isSetReq();
+ if (this_present_req || that_present_req) {
+ if (!(this_present_req && that_present_req))
+ return false;
+ if (!this.req.equals(that.req))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_req = true && (isSetReq());
+ builder.append(present_req);
+ if (present_req)
+ builder.append(req);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(RenewDelegationToken_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ RenewDelegationToken_args typedOther = (RenewDelegationToken_args)other;
+
+ lastComparison = Boolean.valueOf(isSetReq()).compareTo(typedOther.isSetReq());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReq()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, typedOther.req);
+ 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("RenewDelegationToken_args(");
+ boolean first = true;
+
+ sb.append("req:");
+ if (this.req == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.req);
+ }
+ 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 (req != null) {
+ req.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 {
+ 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 RenewDelegationToken_argsStandardSchemeFactory implements SchemeFactory {
+ public RenewDelegationToken_argsStandardScheme getScheme() {
+ return new RenewDelegationToken_argsStandardScheme();
+ }
+ }
+
+ private static class RenewDelegationToken_argsStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, RenewDelegationToken_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: // REQ
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.req = new TRenewDelegationTokenReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, RenewDelegationToken_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.req != null) {
+ oprot.writeFieldBegin(REQ_FIELD_DESC);
+ struct.req.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class RenewDelegationToken_argsTupleSchemeFactory implements SchemeFactory {
+ public RenewDelegationToken_argsTupleScheme getScheme() {
+ return new RenewDelegationToken_argsTupleScheme();
+ }
+ }
+
+ private static class RenewDelegationToken_argsTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, RenewDelegationToken_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetReq()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReq()) {
+ struct.req.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, RenewDelegationToken_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.req = new TRenewDelegationTokenReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ }
+ }
+ }
+
+ }
+
+ public static class RenewDelegationToken_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("RenewDelegationToken_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new RenewDelegationToken_resultStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new RenewDelegationToken_resultTupleSchemeFactory());
+ }
+
+ private TRenewDelegationTokenResp success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ 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;
+ 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
+ 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TRenewDelegationTokenResp.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(RenewDelegationToken_result.class, metaDataMap);
+ }
+
+ public RenewDelegationToken_result() {
+ }
+
+ public RenewDelegationToken_result(
+ TRenewDelegationTokenResp success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public RenewDelegationToken_result(RenewDelegationToken_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TRenewDelegationTokenResp(other.success);
+ }
+ }
+
+ public RenewDelegationToken_result deepCopy() {
+ return new RenewDelegationToken_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ public TRenewDelegationTokenResp getSuccess() {
+ return this.success;
+ }
+
+ public void setSuccess(TRenewDelegationTokenResp success) {
+ this.success = success;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TRenewDelegationTokenResp)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ 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();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof RenewDelegationToken_result)
+ return this.equals((RenewDelegationToken_result)that);
+ return false;
+ }
+
+ public boolean equals(RenewDelegationToken_result that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_success = true && (isSetSuccess());
+ builder.append(present_success);
+ if (present_success)
+ builder.append(success);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(RenewDelegationToken_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ RenewDelegationToken_result typedOther = (RenewDelegationToken_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;
+ }
+ }
+ 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("RenewDelegationToken_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ 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 (success != null) {
+ success.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 {
+ 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 RenewDelegationToken_resultStandardSchemeFactory implements SchemeFactory {
+ public RenewDelegationToken_resultStandardScheme getScheme() {
+ return new RenewDelegationToken_resultStandardScheme();
+ }
+ }
+
+ private static class RenewDelegationToken_resultStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, RenewDelegationToken_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.STRUCT) {
+ struct.success = new TRenewDelegationTokenResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, RenewDelegationToken_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class RenewDelegationToken_resultTupleSchemeFactory implements SchemeFactory {
+ public RenewDelegationToken_resultTupleScheme getScheme() {
+ return new RenewDelegationToken_resultTupleScheme();
+ }
+ }
+
+ private static class RenewDelegationToken_resultTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, RenewDelegationToken_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, RenewDelegationToken_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = new TRenewDelegationTokenResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ }
+
}
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCancelDelegationTokenReq.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCancelDelegationTokenReq.java
new file mode 100644
index 0000000..e23fcdd
--- /dev/null
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCancelDelegationTokenReq.java
@@ -0,0 +1,491 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.cli.thrift;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TCancelDelegationTokenReq 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("TCancelDelegationTokenReq");
+
+ private static final org.apache.thrift.protocol.TField SESSION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("sessionHandle", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField DELEGATION_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("delegationToken", org.apache.thrift.protocol.TType.STRING, (short)2);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TCancelDelegationTokenReqStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TCancelDelegationTokenReqTupleSchemeFactory());
+ }
+
+ private TSessionHandle sessionHandle; // required
+ private String delegationToken; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SESSION_HANDLE((short)1, "sessionHandle"),
+ DELEGATION_TOKEN((short)2, "delegationToken");
+
+ 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 1: // SESSION_HANDLE
+ return SESSION_HANDLE;
+ case 2: // DELEGATION_TOKEN
+ return DELEGATION_TOKEN;
+ 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
+ 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.SESSION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("sessionHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSessionHandle.class)));
+ tmpMap.put(_Fields.DELEGATION_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("delegationToken", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TCancelDelegationTokenReq.class, metaDataMap);
+ }
+
+ public TCancelDelegationTokenReq() {
+ }
+
+ public TCancelDelegationTokenReq(
+ TSessionHandle sessionHandle,
+ String delegationToken)
+ {
+ this();
+ this.sessionHandle = sessionHandle;
+ this.delegationToken = delegationToken;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public TCancelDelegationTokenReq(TCancelDelegationTokenReq other) {
+ if (other.isSetSessionHandle()) {
+ this.sessionHandle = new TSessionHandle(other.sessionHandle);
+ }
+ if (other.isSetDelegationToken()) {
+ this.delegationToken = other.delegationToken;
+ }
+ }
+
+ public TCancelDelegationTokenReq deepCopy() {
+ return new TCancelDelegationTokenReq(this);
+ }
+
+ @Override
+ public void clear() {
+ this.sessionHandle = null;
+ this.delegationToken = null;
+ }
+
+ public TSessionHandle getSessionHandle() {
+ return this.sessionHandle;
+ }
+
+ public void setSessionHandle(TSessionHandle sessionHandle) {
+ this.sessionHandle = sessionHandle;
+ }
+
+ public void unsetSessionHandle() {
+ this.sessionHandle = null;
+ }
+
+ /** Returns true if field sessionHandle is set (has been assigned a value) and false otherwise */
+ public boolean isSetSessionHandle() {
+ return this.sessionHandle != null;
+ }
+
+ public void setSessionHandleIsSet(boolean value) {
+ if (!value) {
+ this.sessionHandle = null;
+ }
+ }
+
+ public String getDelegationToken() {
+ return this.delegationToken;
+ }
+
+ public void setDelegationToken(String delegationToken) {
+ this.delegationToken = delegationToken;
+ }
+
+ public void unsetDelegationToken() {
+ this.delegationToken = null;
+ }
+
+ /** Returns true if field delegationToken is set (has been assigned a value) and false otherwise */
+ public boolean isSetDelegationToken() {
+ return this.delegationToken != null;
+ }
+
+ public void setDelegationTokenIsSet(boolean value) {
+ if (!value) {
+ this.delegationToken = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SESSION_HANDLE:
+ if (value == null) {
+ unsetSessionHandle();
+ } else {
+ setSessionHandle((TSessionHandle)value);
+ }
+ break;
+
+ case DELEGATION_TOKEN:
+ if (value == null) {
+ unsetDelegationToken();
+ } else {
+ setDelegationToken((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SESSION_HANDLE:
+ return getSessionHandle();
+
+ case DELEGATION_TOKEN:
+ return getDelegationToken();
+
+ }
+ 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 SESSION_HANDLE:
+ return isSetSessionHandle();
+ case DELEGATION_TOKEN:
+ return isSetDelegationToken();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TCancelDelegationTokenReq)
+ return this.equals((TCancelDelegationTokenReq)that);
+ return false;
+ }
+
+ public boolean equals(TCancelDelegationTokenReq that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_sessionHandle = true && this.isSetSessionHandle();
+ boolean that_present_sessionHandle = true && that.isSetSessionHandle();
+ if (this_present_sessionHandle || that_present_sessionHandle) {
+ if (!(this_present_sessionHandle && that_present_sessionHandle))
+ return false;
+ if (!this.sessionHandle.equals(that.sessionHandle))
+ return false;
+ }
+
+ boolean this_present_delegationToken = true && this.isSetDelegationToken();
+ boolean that_present_delegationToken = true && that.isSetDelegationToken();
+ if (this_present_delegationToken || that_present_delegationToken) {
+ if (!(this_present_delegationToken && that_present_delegationToken))
+ return false;
+ if (!this.delegationToken.equals(that.delegationToken))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_sessionHandle = true && (isSetSessionHandle());
+ builder.append(present_sessionHandle);
+ if (present_sessionHandle)
+ builder.append(sessionHandle);
+
+ boolean present_delegationToken = true && (isSetDelegationToken());
+ builder.append(present_delegationToken);
+ if (present_delegationToken)
+ builder.append(delegationToken);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(TCancelDelegationTokenReq other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ TCancelDelegationTokenReq typedOther = (TCancelDelegationTokenReq)other;
+
+ lastComparison = Boolean.valueOf(isSetSessionHandle()).compareTo(typedOther.isSetSessionHandle());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSessionHandle()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sessionHandle, typedOther.sessionHandle);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetDelegationToken()).compareTo(typedOther.isSetDelegationToken());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDelegationToken()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.delegationToken, typedOther.delegationToken);
+ 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("TCancelDelegationTokenReq(");
+ boolean first = true;
+
+ sb.append("sessionHandle:");
+ if (this.sessionHandle == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.sessionHandle);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("delegationToken:");
+ if (this.delegationToken == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.delegationToken);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetSessionHandle()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'sessionHandle' is unset! Struct:" + toString());
+ }
+
+ if (!isSetDelegationToken()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'delegationToken' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (sessionHandle != null) {
+ sessionHandle.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 {
+ 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 TCancelDelegationTokenReqStandardSchemeFactory implements SchemeFactory {
+ public TCancelDelegationTokenReqStandardScheme getScheme() {
+ return new TCancelDelegationTokenReqStandardScheme();
+ }
+ }
+
+ private static class TCancelDelegationTokenReqStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TCancelDelegationTokenReq 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: // SESSION_HANDLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.sessionHandle = new TSessionHandle();
+ struct.sessionHandle.read(iprot);
+ struct.setSessionHandleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // DELEGATION_TOKEN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.delegationToken = iprot.readString();
+ struct.setDelegationTokenIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TCancelDelegationTokenReq struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.sessionHandle != null) {
+ oprot.writeFieldBegin(SESSION_HANDLE_FIELD_DESC);
+ struct.sessionHandle.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.delegationToken != null) {
+ oprot.writeFieldBegin(DELEGATION_TOKEN_FIELD_DESC);
+ oprot.writeString(struct.delegationToken);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TCancelDelegationTokenReqTupleSchemeFactory implements SchemeFactory {
+ public TCancelDelegationTokenReqTupleScheme getScheme() {
+ return new TCancelDelegationTokenReqTupleScheme();
+ }
+ }
+
+ private static class TCancelDelegationTokenReqTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TCancelDelegationTokenReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.sessionHandle.write(oprot);
+ oprot.writeString(struct.delegationToken);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TCancelDelegationTokenReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.sessionHandle = new TSessionHandle();
+ struct.sessionHandle.read(iprot);
+ struct.setSessionHandleIsSet(true);
+ struct.delegationToken = iprot.readString();
+ struct.setDelegationTokenIsSet(true);
+ }
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCancelDelegationTokenResp.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCancelDelegationTokenResp.java
new file mode 100644
index 0000000..77c9ee7
--- /dev/null
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TCancelDelegationTokenResp.java
@@ -0,0 +1,390 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.cli.thrift;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TCancelDelegationTokenResp 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("TCancelDelegationTokenResp");
+
+ private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TCancelDelegationTokenRespStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TCancelDelegationTokenRespTupleSchemeFactory());
+ }
+
+ private TStatus status; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ STATUS((short)1, "status");
+
+ 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 1: // STATUS
+ return STATUS;
+ 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
+ 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.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TStatus.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TCancelDelegationTokenResp.class, metaDataMap);
+ }
+
+ public TCancelDelegationTokenResp() {
+ }
+
+ public TCancelDelegationTokenResp(
+ TStatus status)
+ {
+ this();
+ this.status = status;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public TCancelDelegationTokenResp(TCancelDelegationTokenResp other) {
+ if (other.isSetStatus()) {
+ this.status = new TStatus(other.status);
+ }
+ }
+
+ public TCancelDelegationTokenResp deepCopy() {
+ return new TCancelDelegationTokenResp(this);
+ }
+
+ @Override
+ public void clear() {
+ this.status = null;
+ }
+
+ public TStatus getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(TStatus status) {
+ this.status = status;
+ }
+
+ public void unsetStatus() {
+ this.status = null;
+ }
+
+ /** Returns true if field status is set (has been assigned a value) and false otherwise */
+ public boolean isSetStatus() {
+ return this.status != null;
+ }
+
+ public void setStatusIsSet(boolean value) {
+ if (!value) {
+ this.status = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case STATUS:
+ if (value == null) {
+ unsetStatus();
+ } else {
+ setStatus((TStatus)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case STATUS:
+ return getStatus();
+
+ }
+ 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 STATUS:
+ return isSetStatus();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TCancelDelegationTokenResp)
+ return this.equals((TCancelDelegationTokenResp)that);
+ return false;
+ }
+
+ public boolean equals(TCancelDelegationTokenResp that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_status = true && this.isSetStatus();
+ boolean that_present_status = true && that.isSetStatus();
+ if (this_present_status || that_present_status) {
+ if (!(this_present_status && that_present_status))
+ return false;
+ if (!this.status.equals(that.status))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_status = true && (isSetStatus());
+ builder.append(present_status);
+ if (present_status)
+ builder.append(status);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(TCancelDelegationTokenResp other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ TCancelDelegationTokenResp typedOther = (TCancelDelegationTokenResp)other;
+
+ lastComparison = Boolean.valueOf(isSetStatus()).compareTo(typedOther.isSetStatus());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStatus()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, typedOther.status);
+ 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("TCancelDelegationTokenResp(");
+ boolean first = true;
+
+ sb.append("status:");
+ if (this.status == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.status);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetStatus()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'status' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (status != null) {
+ status.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 {
+ 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 TCancelDelegationTokenRespStandardSchemeFactory implements SchemeFactory {
+ public TCancelDelegationTokenRespStandardScheme getScheme() {
+ return new TCancelDelegationTokenRespStandardScheme();
+ }
+ }
+
+ private static class TCancelDelegationTokenRespStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TCancelDelegationTokenResp 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: // STATUS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TCancelDelegationTokenResp struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.status != null) {
+ oprot.writeFieldBegin(STATUS_FIELD_DESC);
+ struct.status.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TCancelDelegationTokenRespTupleSchemeFactory implements SchemeFactory {
+ public TCancelDelegationTokenRespTupleScheme getScheme() {
+ return new TCancelDelegationTokenRespTupleScheme();
+ }
+ }
+
+ private static class TCancelDelegationTokenRespTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TCancelDelegationTokenResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.status.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TCancelDelegationTokenResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ }
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetDelegationTokenReq.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetDelegationTokenReq.java
new file mode 100644
index 0000000..6c6bb00
--- /dev/null
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetDelegationTokenReq.java
@@ -0,0 +1,592 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.cli.thrift;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TGetDelegationTokenReq 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("TGetDelegationTokenReq");
+
+ private static final org.apache.thrift.protocol.TField SESSION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("sessionHandle", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField OWNER_FIELD_DESC = new org.apache.thrift.protocol.TField("owner", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField RENEWER_FIELD_DESC = new org.apache.thrift.protocol.TField("renewer", org.apache.thrift.protocol.TType.STRING, (short)3);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TGetDelegationTokenReqStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TGetDelegationTokenReqTupleSchemeFactory());
+ }
+
+ private TSessionHandle sessionHandle; // required
+ private String owner; // required
+ private String renewer; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SESSION_HANDLE((short)1, "sessionHandle"),
+ OWNER((short)2, "owner"),
+ RENEWER((short)3, "renewer");
+
+ 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 1: // SESSION_HANDLE
+ return SESSION_HANDLE;
+ case 2: // OWNER
+ return OWNER;
+ case 3: // RENEWER
+ return RENEWER;
+ 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
+ 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.SESSION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("sessionHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSessionHandle.class)));
+ tmpMap.put(_Fields.OWNER, new org.apache.thrift.meta_data.FieldMetaData("owner", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.RENEWER, new org.apache.thrift.meta_data.FieldMetaData("renewer", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGetDelegationTokenReq.class, metaDataMap);
+ }
+
+ public TGetDelegationTokenReq() {
+ }
+
+ public TGetDelegationTokenReq(
+ TSessionHandle sessionHandle,
+ String owner,
+ String renewer)
+ {
+ this();
+ this.sessionHandle = sessionHandle;
+ this.owner = owner;
+ this.renewer = renewer;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public TGetDelegationTokenReq(TGetDelegationTokenReq other) {
+ if (other.isSetSessionHandle()) {
+ this.sessionHandle = new TSessionHandle(other.sessionHandle);
+ }
+ if (other.isSetOwner()) {
+ this.owner = other.owner;
+ }
+ if (other.isSetRenewer()) {
+ this.renewer = other.renewer;
+ }
+ }
+
+ public TGetDelegationTokenReq deepCopy() {
+ return new TGetDelegationTokenReq(this);
+ }
+
+ @Override
+ public void clear() {
+ this.sessionHandle = null;
+ this.owner = null;
+ this.renewer = null;
+ }
+
+ public TSessionHandle getSessionHandle() {
+ return this.sessionHandle;
+ }
+
+ public void setSessionHandle(TSessionHandle sessionHandle) {
+ this.sessionHandle = sessionHandle;
+ }
+
+ public void unsetSessionHandle() {
+ this.sessionHandle = null;
+ }
+
+ /** Returns true if field sessionHandle is set (has been assigned a value) and false otherwise */
+ public boolean isSetSessionHandle() {
+ return this.sessionHandle != null;
+ }
+
+ public void setSessionHandleIsSet(boolean value) {
+ if (!value) {
+ this.sessionHandle = null;
+ }
+ }
+
+ public String getOwner() {
+ return this.owner;
+ }
+
+ public void setOwner(String owner) {
+ this.owner = owner;
+ }
+
+ public void unsetOwner() {
+ this.owner = null;
+ }
+
+ /** Returns true if field owner is set (has been assigned a value) and false otherwise */
+ public boolean isSetOwner() {
+ return this.owner != null;
+ }
+
+ public void setOwnerIsSet(boolean value) {
+ if (!value) {
+ this.owner = null;
+ }
+ }
+
+ public String getRenewer() {
+ return this.renewer;
+ }
+
+ public void setRenewer(String renewer) {
+ this.renewer = renewer;
+ }
+
+ public void unsetRenewer() {
+ this.renewer = null;
+ }
+
+ /** Returns true if field renewer is set (has been assigned a value) and false otherwise */
+ public boolean isSetRenewer() {
+ return this.renewer != null;
+ }
+
+ public void setRenewerIsSet(boolean value) {
+ if (!value) {
+ this.renewer = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SESSION_HANDLE:
+ if (value == null) {
+ unsetSessionHandle();
+ } else {
+ setSessionHandle((TSessionHandle)value);
+ }
+ break;
+
+ case OWNER:
+ if (value == null) {
+ unsetOwner();
+ } else {
+ setOwner((String)value);
+ }
+ break;
+
+ case RENEWER:
+ if (value == null) {
+ unsetRenewer();
+ } else {
+ setRenewer((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SESSION_HANDLE:
+ return getSessionHandle();
+
+ case OWNER:
+ return getOwner();
+
+ case RENEWER:
+ return getRenewer();
+
+ }
+ 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 SESSION_HANDLE:
+ return isSetSessionHandle();
+ case OWNER:
+ return isSetOwner();
+ case RENEWER:
+ return isSetRenewer();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TGetDelegationTokenReq)
+ return this.equals((TGetDelegationTokenReq)that);
+ return false;
+ }
+
+ public boolean equals(TGetDelegationTokenReq that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_sessionHandle = true && this.isSetSessionHandle();
+ boolean that_present_sessionHandle = true && that.isSetSessionHandle();
+ if (this_present_sessionHandle || that_present_sessionHandle) {
+ if (!(this_present_sessionHandle && that_present_sessionHandle))
+ return false;
+ if (!this.sessionHandle.equals(that.sessionHandle))
+ return false;
+ }
+
+ boolean this_present_owner = true && this.isSetOwner();
+ boolean that_present_owner = true && that.isSetOwner();
+ if (this_present_owner || that_present_owner) {
+ if (!(this_present_owner && that_present_owner))
+ return false;
+ if (!this.owner.equals(that.owner))
+ return false;
+ }
+
+ boolean this_present_renewer = true && this.isSetRenewer();
+ boolean that_present_renewer = true && that.isSetRenewer();
+ if (this_present_renewer || that_present_renewer) {
+ if (!(this_present_renewer && that_present_renewer))
+ return false;
+ if (!this.renewer.equals(that.renewer))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_sessionHandle = true && (isSetSessionHandle());
+ builder.append(present_sessionHandle);
+ if (present_sessionHandle)
+ builder.append(sessionHandle);
+
+ boolean present_owner = true && (isSetOwner());
+ builder.append(present_owner);
+ if (present_owner)
+ builder.append(owner);
+
+ boolean present_renewer = true && (isSetRenewer());
+ builder.append(present_renewer);
+ if (present_renewer)
+ builder.append(renewer);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(TGetDelegationTokenReq other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ TGetDelegationTokenReq typedOther = (TGetDelegationTokenReq)other;
+
+ lastComparison = Boolean.valueOf(isSetSessionHandle()).compareTo(typedOther.isSetSessionHandle());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSessionHandle()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sessionHandle, typedOther.sessionHandle);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetOwner()).compareTo(typedOther.isSetOwner());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetOwner()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.owner, typedOther.owner);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetRenewer()).compareTo(typedOther.isSetRenewer());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetRenewer()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.renewer, typedOther.renewer);
+ 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("TGetDelegationTokenReq(");
+ boolean first = true;
+
+ sb.append("sessionHandle:");
+ if (this.sessionHandle == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.sessionHandle);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("owner:");
+ if (this.owner == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.owner);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("renewer:");
+ if (this.renewer == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.renewer);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetSessionHandle()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'sessionHandle' is unset! Struct:" + toString());
+ }
+
+ if (!isSetOwner()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'owner' is unset! Struct:" + toString());
+ }
+
+ if (!isSetRenewer()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'renewer' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (sessionHandle != null) {
+ sessionHandle.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 {
+ 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 TGetDelegationTokenReqStandardSchemeFactory implements SchemeFactory {
+ public TGetDelegationTokenReqStandardScheme getScheme() {
+ return new TGetDelegationTokenReqStandardScheme();
+ }
+ }
+
+ private static class TGetDelegationTokenReqStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TGetDelegationTokenReq 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: // SESSION_HANDLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.sessionHandle = new TSessionHandle();
+ struct.sessionHandle.read(iprot);
+ struct.setSessionHandleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // OWNER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.owner = iprot.readString();
+ struct.setOwnerIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // RENEWER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.renewer = iprot.readString();
+ struct.setRenewerIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TGetDelegationTokenReq struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.sessionHandle != null) {
+ oprot.writeFieldBegin(SESSION_HANDLE_FIELD_DESC);
+ struct.sessionHandle.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.owner != null) {
+ oprot.writeFieldBegin(OWNER_FIELD_DESC);
+ oprot.writeString(struct.owner);
+ oprot.writeFieldEnd();
+ }
+ if (struct.renewer != null) {
+ oprot.writeFieldBegin(RENEWER_FIELD_DESC);
+ oprot.writeString(struct.renewer);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TGetDelegationTokenReqTupleSchemeFactory implements SchemeFactory {
+ public TGetDelegationTokenReqTupleScheme getScheme() {
+ return new TGetDelegationTokenReqTupleScheme();
+ }
+ }
+
+ private static class TGetDelegationTokenReqTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TGetDelegationTokenReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.sessionHandle.write(oprot);
+ oprot.writeString(struct.owner);
+ oprot.writeString(struct.renewer);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TGetDelegationTokenReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.sessionHandle = new TSessionHandle();
+ struct.sessionHandle.read(iprot);
+ struct.setSessionHandleIsSet(true);
+ struct.owner = iprot.readString();
+ struct.setOwnerIsSet(true);
+ struct.renewer = iprot.readString();
+ struct.setRenewerIsSet(true);
+ }
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetDelegationTokenResp.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetDelegationTokenResp.java
new file mode 100644
index 0000000..d14c5e0
--- /dev/null
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TGetDelegationTokenResp.java
@@ -0,0 +1,500 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.cli.thrift;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TGetDelegationTokenResp 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("TGetDelegationTokenResp");
+
+ private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField DELEGATION_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("delegationToken", org.apache.thrift.protocol.TType.STRING, (short)2);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TGetDelegationTokenRespStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TGetDelegationTokenRespTupleSchemeFactory());
+ }
+
+ private TStatus status; // required
+ private String delegationToken; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ STATUS((short)1, "status"),
+ DELEGATION_TOKEN((short)2, "delegationToken");
+
+ 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 1: // STATUS
+ return STATUS;
+ case 2: // DELEGATION_TOKEN
+ return DELEGATION_TOKEN;
+ 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 _Fields optionals[] = {_Fields.DELEGATION_TOKEN};
+ 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.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TStatus.class)));
+ tmpMap.put(_Fields.DELEGATION_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("delegationToken", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGetDelegationTokenResp.class, metaDataMap);
+ }
+
+ public TGetDelegationTokenResp() {
+ }
+
+ public TGetDelegationTokenResp(
+ TStatus status)
+ {
+ this();
+ this.status = status;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public TGetDelegationTokenResp(TGetDelegationTokenResp other) {
+ if (other.isSetStatus()) {
+ this.status = new TStatus(other.status);
+ }
+ if (other.isSetDelegationToken()) {
+ this.delegationToken = other.delegationToken;
+ }
+ }
+
+ public TGetDelegationTokenResp deepCopy() {
+ return new TGetDelegationTokenResp(this);
+ }
+
+ @Override
+ public void clear() {
+ this.status = null;
+ this.delegationToken = null;
+ }
+
+ public TStatus getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(TStatus status) {
+ this.status = status;
+ }
+
+ public void unsetStatus() {
+ this.status = null;
+ }
+
+ /** Returns true if field status is set (has been assigned a value) and false otherwise */
+ public boolean isSetStatus() {
+ return this.status != null;
+ }
+
+ public void setStatusIsSet(boolean value) {
+ if (!value) {
+ this.status = null;
+ }
+ }
+
+ public String getDelegationToken() {
+ return this.delegationToken;
+ }
+
+ public void setDelegationToken(String delegationToken) {
+ this.delegationToken = delegationToken;
+ }
+
+ public void unsetDelegationToken() {
+ this.delegationToken = null;
+ }
+
+ /** Returns true if field delegationToken is set (has been assigned a value) and false otherwise */
+ public boolean isSetDelegationToken() {
+ return this.delegationToken != null;
+ }
+
+ public void setDelegationTokenIsSet(boolean value) {
+ if (!value) {
+ this.delegationToken = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case STATUS:
+ if (value == null) {
+ unsetStatus();
+ } else {
+ setStatus((TStatus)value);
+ }
+ break;
+
+ case DELEGATION_TOKEN:
+ if (value == null) {
+ unsetDelegationToken();
+ } else {
+ setDelegationToken((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case STATUS:
+ return getStatus();
+
+ case DELEGATION_TOKEN:
+ return getDelegationToken();
+
+ }
+ 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 STATUS:
+ return isSetStatus();
+ case DELEGATION_TOKEN:
+ return isSetDelegationToken();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TGetDelegationTokenResp)
+ return this.equals((TGetDelegationTokenResp)that);
+ return false;
+ }
+
+ public boolean equals(TGetDelegationTokenResp that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_status = true && this.isSetStatus();
+ boolean that_present_status = true && that.isSetStatus();
+ if (this_present_status || that_present_status) {
+ if (!(this_present_status && that_present_status))
+ return false;
+ if (!this.status.equals(that.status))
+ return false;
+ }
+
+ boolean this_present_delegationToken = true && this.isSetDelegationToken();
+ boolean that_present_delegationToken = true && that.isSetDelegationToken();
+ if (this_present_delegationToken || that_present_delegationToken) {
+ if (!(this_present_delegationToken && that_present_delegationToken))
+ return false;
+ if (!this.delegationToken.equals(that.delegationToken))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_status = true && (isSetStatus());
+ builder.append(present_status);
+ if (present_status)
+ builder.append(status);
+
+ boolean present_delegationToken = true && (isSetDelegationToken());
+ builder.append(present_delegationToken);
+ if (present_delegationToken)
+ builder.append(delegationToken);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(TGetDelegationTokenResp other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ TGetDelegationTokenResp typedOther = (TGetDelegationTokenResp)other;
+
+ lastComparison = Boolean.valueOf(isSetStatus()).compareTo(typedOther.isSetStatus());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStatus()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, typedOther.status);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetDelegationToken()).compareTo(typedOther.isSetDelegationToken());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDelegationToken()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.delegationToken, typedOther.delegationToken);
+ 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("TGetDelegationTokenResp(");
+ boolean first = true;
+
+ sb.append("status:");
+ if (this.status == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.status);
+ }
+ first = false;
+ if (isSetDelegationToken()) {
+ if (!first) sb.append(", ");
+ sb.append("delegationToken:");
+ if (this.delegationToken == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.delegationToken);
+ }
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetStatus()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'status' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (status != null) {
+ status.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 {
+ 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 TGetDelegationTokenRespStandardSchemeFactory implements SchemeFactory {
+ public TGetDelegationTokenRespStandardScheme getScheme() {
+ return new TGetDelegationTokenRespStandardScheme();
+ }
+ }
+
+ private static class TGetDelegationTokenRespStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TGetDelegationTokenResp 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: // STATUS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // DELEGATION_TOKEN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.delegationToken = iprot.readString();
+ struct.setDelegationTokenIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TGetDelegationTokenResp struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.status != null) {
+ oprot.writeFieldBegin(STATUS_FIELD_DESC);
+ struct.status.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.delegationToken != null) {
+ if (struct.isSetDelegationToken()) {
+ oprot.writeFieldBegin(DELEGATION_TOKEN_FIELD_DESC);
+ oprot.writeString(struct.delegationToken);
+ oprot.writeFieldEnd();
+ }
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TGetDelegationTokenRespTupleSchemeFactory implements SchemeFactory {
+ public TGetDelegationTokenRespTupleScheme getScheme() {
+ return new TGetDelegationTokenRespTupleScheme();
+ }
+ }
+
+ private static class TGetDelegationTokenRespTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TGetDelegationTokenResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.status.write(oprot);
+ BitSet optionals = new BitSet();
+ if (struct.isSetDelegationToken()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetDelegationToken()) {
+ oprot.writeString(struct.delegationToken);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TGetDelegationTokenResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.delegationToken = iprot.readString();
+ struct.setDelegationTokenIsSet(true);
+ }
+ }
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRenewDelegationTokenReq.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRenewDelegationTokenReq.java
new file mode 100644
index 0000000..a3e39c8
--- /dev/null
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRenewDelegationTokenReq.java
@@ -0,0 +1,491 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.cli.thrift;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TRenewDelegationTokenReq 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("TRenewDelegationTokenReq");
+
+ private static final org.apache.thrift.protocol.TField SESSION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("sessionHandle", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField DELEGATION_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("delegationToken", org.apache.thrift.protocol.TType.STRING, (short)2);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TRenewDelegationTokenReqStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TRenewDelegationTokenReqTupleSchemeFactory());
+ }
+
+ private TSessionHandle sessionHandle; // required
+ private String delegationToken; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SESSION_HANDLE((short)1, "sessionHandle"),
+ DELEGATION_TOKEN((short)2, "delegationToken");
+
+ 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 1: // SESSION_HANDLE
+ return SESSION_HANDLE;
+ case 2: // DELEGATION_TOKEN
+ return DELEGATION_TOKEN;
+ 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
+ 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.SESSION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("sessionHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSessionHandle.class)));
+ tmpMap.put(_Fields.DELEGATION_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("delegationToken", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TRenewDelegationTokenReq.class, metaDataMap);
+ }
+
+ public TRenewDelegationTokenReq() {
+ }
+
+ public TRenewDelegationTokenReq(
+ TSessionHandle sessionHandle,
+ String delegationToken)
+ {
+ this();
+ this.sessionHandle = sessionHandle;
+ this.delegationToken = delegationToken;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public TRenewDelegationTokenReq(TRenewDelegationTokenReq other) {
+ if (other.isSetSessionHandle()) {
+ this.sessionHandle = new TSessionHandle(other.sessionHandle);
+ }
+ if (other.isSetDelegationToken()) {
+ this.delegationToken = other.delegationToken;
+ }
+ }
+
+ public TRenewDelegationTokenReq deepCopy() {
+ return new TRenewDelegationTokenReq(this);
+ }
+
+ @Override
+ public void clear() {
+ this.sessionHandle = null;
+ this.delegationToken = null;
+ }
+
+ public TSessionHandle getSessionHandle() {
+ return this.sessionHandle;
+ }
+
+ public void setSessionHandle(TSessionHandle sessionHandle) {
+ this.sessionHandle = sessionHandle;
+ }
+
+ public void unsetSessionHandle() {
+ this.sessionHandle = null;
+ }
+
+ /** Returns true if field sessionHandle is set (has been assigned a value) and false otherwise */
+ public boolean isSetSessionHandle() {
+ return this.sessionHandle != null;
+ }
+
+ public void setSessionHandleIsSet(boolean value) {
+ if (!value) {
+ this.sessionHandle = null;
+ }
+ }
+
+ public String getDelegationToken() {
+ return this.delegationToken;
+ }
+
+ public void setDelegationToken(String delegationToken) {
+ this.delegationToken = delegationToken;
+ }
+
+ public void unsetDelegationToken() {
+ this.delegationToken = null;
+ }
+
+ /** Returns true if field delegationToken is set (has been assigned a value) and false otherwise */
+ public boolean isSetDelegationToken() {
+ return this.delegationToken != null;
+ }
+
+ public void setDelegationTokenIsSet(boolean value) {
+ if (!value) {
+ this.delegationToken = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SESSION_HANDLE:
+ if (value == null) {
+ unsetSessionHandle();
+ } else {
+ setSessionHandle((TSessionHandle)value);
+ }
+ break;
+
+ case DELEGATION_TOKEN:
+ if (value == null) {
+ unsetDelegationToken();
+ } else {
+ setDelegationToken((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SESSION_HANDLE:
+ return getSessionHandle();
+
+ case DELEGATION_TOKEN:
+ return getDelegationToken();
+
+ }
+ 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 SESSION_HANDLE:
+ return isSetSessionHandle();
+ case DELEGATION_TOKEN:
+ return isSetDelegationToken();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TRenewDelegationTokenReq)
+ return this.equals((TRenewDelegationTokenReq)that);
+ return false;
+ }
+
+ public boolean equals(TRenewDelegationTokenReq that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_sessionHandle = true && this.isSetSessionHandle();
+ boolean that_present_sessionHandle = true && that.isSetSessionHandle();
+ if (this_present_sessionHandle || that_present_sessionHandle) {
+ if (!(this_present_sessionHandle && that_present_sessionHandle))
+ return false;
+ if (!this.sessionHandle.equals(that.sessionHandle))
+ return false;
+ }
+
+ boolean this_present_delegationToken = true && this.isSetDelegationToken();
+ boolean that_present_delegationToken = true && that.isSetDelegationToken();
+ if (this_present_delegationToken || that_present_delegationToken) {
+ if (!(this_present_delegationToken && that_present_delegationToken))
+ return false;
+ if (!this.delegationToken.equals(that.delegationToken))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_sessionHandle = true && (isSetSessionHandle());
+ builder.append(present_sessionHandle);
+ if (present_sessionHandle)
+ builder.append(sessionHandle);
+
+ boolean present_delegationToken = true && (isSetDelegationToken());
+ builder.append(present_delegationToken);
+ if (present_delegationToken)
+ builder.append(delegationToken);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(TRenewDelegationTokenReq other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ TRenewDelegationTokenReq typedOther = (TRenewDelegationTokenReq)other;
+
+ lastComparison = Boolean.valueOf(isSetSessionHandle()).compareTo(typedOther.isSetSessionHandle());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSessionHandle()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sessionHandle, typedOther.sessionHandle);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetDelegationToken()).compareTo(typedOther.isSetDelegationToken());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDelegationToken()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.delegationToken, typedOther.delegationToken);
+ 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("TRenewDelegationTokenReq(");
+ boolean first = true;
+
+ sb.append("sessionHandle:");
+ if (this.sessionHandle == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.sessionHandle);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("delegationToken:");
+ if (this.delegationToken == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.delegationToken);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetSessionHandle()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'sessionHandle' is unset! Struct:" + toString());
+ }
+
+ if (!isSetDelegationToken()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'delegationToken' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (sessionHandle != null) {
+ sessionHandle.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 {
+ 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 TRenewDelegationTokenReqStandardSchemeFactory implements SchemeFactory {
+ public TRenewDelegationTokenReqStandardScheme getScheme() {
+ return new TRenewDelegationTokenReqStandardScheme();
+ }
+ }
+
+ private static class TRenewDelegationTokenReqStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TRenewDelegationTokenReq 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: // SESSION_HANDLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.sessionHandle = new TSessionHandle();
+ struct.sessionHandle.read(iprot);
+ struct.setSessionHandleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // DELEGATION_TOKEN
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.delegationToken = iprot.readString();
+ struct.setDelegationTokenIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TRenewDelegationTokenReq struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.sessionHandle != null) {
+ oprot.writeFieldBegin(SESSION_HANDLE_FIELD_DESC);
+ struct.sessionHandle.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.delegationToken != null) {
+ oprot.writeFieldBegin(DELEGATION_TOKEN_FIELD_DESC);
+ oprot.writeString(struct.delegationToken);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TRenewDelegationTokenReqTupleSchemeFactory implements SchemeFactory {
+ public TRenewDelegationTokenReqTupleScheme getScheme() {
+ return new TRenewDelegationTokenReqTupleScheme();
+ }
+ }
+
+ private static class TRenewDelegationTokenReqTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TRenewDelegationTokenReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.sessionHandle.write(oprot);
+ oprot.writeString(struct.delegationToken);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TRenewDelegationTokenReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.sessionHandle = new TSessionHandle();
+ struct.sessionHandle.read(iprot);
+ struct.setSessionHandleIsSet(true);
+ struct.delegationToken = iprot.readString();
+ struct.setDelegationTokenIsSet(true);
+ }
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRenewDelegationTokenResp.java service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRenewDelegationTokenResp.java
new file mode 100644
index 0000000..5f3eb6c
--- /dev/null
+++ service/src/gen/thrift/gen-javabean/org/apache/hive/service/cli/thrift/TRenewDelegationTokenResp.java
@@ -0,0 +1,390 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.cli.thrift;
+
+import org.apache.commons.lang.builder.HashCodeBuilder;
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TRenewDelegationTokenResp 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("TRenewDelegationTokenResp");
+
+ private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TRenewDelegationTokenRespStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TRenewDelegationTokenRespTupleSchemeFactory());
+ }
+
+ private TStatus status; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ STATUS((short)1, "status");
+
+ 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 1: // STATUS
+ return STATUS;
+ 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
+ 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.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TStatus.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TRenewDelegationTokenResp.class, metaDataMap);
+ }
+
+ public TRenewDelegationTokenResp() {
+ }
+
+ public TRenewDelegationTokenResp(
+ TStatus status)
+ {
+ this();
+ this.status = status;
+ }
+
+ /**
+ * Performs a deep copy on other.
+ */
+ public TRenewDelegationTokenResp(TRenewDelegationTokenResp other) {
+ if (other.isSetStatus()) {
+ this.status = new TStatus(other.status);
+ }
+ }
+
+ public TRenewDelegationTokenResp deepCopy() {
+ return new TRenewDelegationTokenResp(this);
+ }
+
+ @Override
+ public void clear() {
+ this.status = null;
+ }
+
+ public TStatus getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(TStatus status) {
+ this.status = status;
+ }
+
+ public void unsetStatus() {
+ this.status = null;
+ }
+
+ /** Returns true if field status is set (has been assigned a value) and false otherwise */
+ public boolean isSetStatus() {
+ return this.status != null;
+ }
+
+ public void setStatusIsSet(boolean value) {
+ if (!value) {
+ this.status = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case STATUS:
+ if (value == null) {
+ unsetStatus();
+ } else {
+ setStatus((TStatus)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case STATUS:
+ return getStatus();
+
+ }
+ 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 STATUS:
+ return isSetStatus();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TRenewDelegationTokenResp)
+ return this.equals((TRenewDelegationTokenResp)that);
+ return false;
+ }
+
+ public boolean equals(TRenewDelegationTokenResp that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_status = true && this.isSetStatus();
+ boolean that_present_status = true && that.isSetStatus();
+ if (this_present_status || that_present_status) {
+ if (!(this_present_status && that_present_status))
+ return false;
+ if (!this.status.equals(that.status))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_status = true && (isSetStatus());
+ builder.append(present_status);
+ if (present_status)
+ builder.append(status);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(TRenewDelegationTokenResp other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ TRenewDelegationTokenResp typedOther = (TRenewDelegationTokenResp)other;
+
+ lastComparison = Boolean.valueOf(isSetStatus()).compareTo(typedOther.isSetStatus());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStatus()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, typedOther.status);
+ 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("TRenewDelegationTokenResp(");
+ boolean first = true;
+
+ sb.append("status:");
+ if (this.status == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.status);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetStatus()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'status' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (status != null) {
+ status.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 {
+ 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 TRenewDelegationTokenRespStandardSchemeFactory implements SchemeFactory {
+ public TRenewDelegationTokenRespStandardScheme getScheme() {
+ return new TRenewDelegationTokenRespStandardScheme();
+ }
+ }
+
+ private static class TRenewDelegationTokenRespStandardScheme extends StandardScheme {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TRenewDelegationTokenResp 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: // STATUS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(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();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TRenewDelegationTokenResp struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.status != null) {
+ oprot.writeFieldBegin(STATUS_FIELD_DESC);
+ struct.status.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TRenewDelegationTokenRespTupleSchemeFactory implements SchemeFactory {
+ public TRenewDelegationTokenRespTupleScheme getScheme() {
+ return new TRenewDelegationTokenRespTupleScheme();
+ }
+ }
+
+ private static class TRenewDelegationTokenRespTupleScheme extends TupleScheme {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TRenewDelegationTokenResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.status.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TRenewDelegationTokenResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ }
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-php/TCLIService.php service/src/gen/thrift/gen-php/TCLIService.php
index bbb6b0f..d246296 100644
--- service/src/gen/thrift/gen-php/TCLIService.php
+++ service/src/gen/thrift/gen-php/TCLIService.php
@@ -32,6 +32,9 @@ interface TCLIServiceIf {
public function CloseOperation(\TCloseOperationReq $req);
public function GetResultSetMetadata(\TGetResultSetMetadataReq $req);
public function FetchResults(\TFetchResultsReq $req);
+ public function GetDelegationToken(\TGetDelegationTokenReq $req);
+ public function CancelDelegationToken(\TCancelDelegationTokenReq $req);
+ public function RenewDelegationToken(\TRenewDelegationTokenReq $req);
}
class TCLIServiceClient implements \TCLIServiceIf {
@@ -861,6 +864,159 @@ class TCLIServiceClient implements \TCLIServiceIf {
throw new \Exception("FetchResults failed: unknown result");
}
+ public function GetDelegationToken(\TGetDelegationTokenReq $req)
+ {
+ $this->send_GetDelegationToken($req);
+ return $this->recv_GetDelegationToken();
+ }
+
+ public function send_GetDelegationToken(\TGetDelegationTokenReq $req)
+ {
+ $args = new \TCLIService_GetDelegationToken_args();
+ $args->req = $req;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'GetDelegationToken', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('GetDelegationToken', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_GetDelegationToken()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetDelegationToken_result', $this->input_->isStrictRead());
+ else
+ {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \TCLIService_GetDelegationToken_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ throw new \Exception("GetDelegationToken failed: unknown result");
+ }
+
+ public function CancelDelegationToken(\TCancelDelegationTokenReq $req)
+ {
+ $this->send_CancelDelegationToken($req);
+ return $this->recv_CancelDelegationToken();
+ }
+
+ public function send_CancelDelegationToken(\TCancelDelegationTokenReq $req)
+ {
+ $args = new \TCLIService_CancelDelegationToken_args();
+ $args->req = $req;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'CancelDelegationToken', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('CancelDelegationToken', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_CancelDelegationToken()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_CancelDelegationToken_result', $this->input_->isStrictRead());
+ else
+ {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \TCLIService_CancelDelegationToken_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ throw new \Exception("CancelDelegationToken failed: unknown result");
+ }
+
+ public function RenewDelegationToken(\TRenewDelegationTokenReq $req)
+ {
+ $this->send_RenewDelegationToken($req);
+ return $this->recv_RenewDelegationToken();
+ }
+
+ public function send_RenewDelegationToken(\TRenewDelegationTokenReq $req)
+ {
+ $args = new \TCLIService_RenewDelegationToken_args();
+ $args->req = $req;
+ $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'RenewDelegationToken', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('RenewDelegationToken', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_RenewDelegationToken()
+ {
+ $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_RenewDelegationToken_result', $this->input_->isStrictRead());
+ else
+ {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \TCLIService_RenewDelegationToken_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ throw new \Exception("RenewDelegationToken failed: unknown result");
+ }
+
}
// HELPER FUNCTIONS AND STRUCTURES
@@ -3329,4 +3485,466 @@ class TCLIService_FetchResults_result {
}
+class TCLIService_GetDelegationToken_args {
+ static $_TSPEC;
+
+ public $req = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'req',
+ 'type' => TType::STRUCT,
+ 'class' => '\TGetDelegationTokenReq',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['req'])) {
+ $this->req = $vals['req'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_GetDelegationToken_args';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->req = new \TGetDelegationTokenReq();
+ $xfer += $this->req->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_GetDelegationToken_args');
+ if ($this->req !== null) {
+ if (!is_object($this->req)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
+ $xfer += $this->req->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TCLIService_GetDelegationToken_result {
+ static $_TSPEC;
+
+ public $success = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::STRUCT,
+ 'class' => '\TGetDelegationTokenResp',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_GetDelegationToken_result';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 0:
+ if ($ftype == TType::STRUCT) {
+ $this->success = new \TGetDelegationTokenResp();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_GetDelegationToken_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TCLIService_CancelDelegationToken_args {
+ static $_TSPEC;
+
+ public $req = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'req',
+ 'type' => TType::STRUCT,
+ 'class' => '\TCancelDelegationTokenReq',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['req'])) {
+ $this->req = $vals['req'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_CancelDelegationToken_args';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->req = new \TCancelDelegationTokenReq();
+ $xfer += $this->req->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_CancelDelegationToken_args');
+ if ($this->req !== null) {
+ if (!is_object($this->req)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
+ $xfer += $this->req->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TCLIService_CancelDelegationToken_result {
+ static $_TSPEC;
+
+ public $success = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::STRUCT,
+ 'class' => '\TCancelDelegationTokenResp',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_CancelDelegationToken_result';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 0:
+ if ($ftype == TType::STRUCT) {
+ $this->success = new \TCancelDelegationTokenResp();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_CancelDelegationToken_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TCLIService_RenewDelegationToken_args {
+ static $_TSPEC;
+
+ public $req = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'req',
+ 'type' => TType::STRUCT,
+ 'class' => '\TRenewDelegationTokenReq',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['req'])) {
+ $this->req = $vals['req'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_RenewDelegationToken_args';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->req = new \TRenewDelegationTokenReq();
+ $xfer += $this->req->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_RenewDelegationToken_args');
+ if ($this->req !== null) {
+ if (!is_object($this->req)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
+ $xfer += $this->req->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TCLIService_RenewDelegationToken_result {
+ static $_TSPEC;
+
+ public $success = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::STRUCT,
+ 'class' => '\TRenewDelegationTokenResp',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_RenewDelegationToken_result';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 0:
+ if ($ftype == TType::STRUCT) {
+ $this->success = new \TRenewDelegationTokenResp();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_RenewDelegationToken_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
diff --git service/src/gen/thrift/gen-py/TCLIService/TCLIService-remote service/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
old mode 100644
new mode 100755
index ab0d501..f6ff43f
--- service/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
+++ service/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
@@ -39,6 +39,9 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help':
print ' TCloseOperationResp CloseOperation(TCloseOperationReq req)'
print ' TGetResultSetMetadataResp GetResultSetMetadata(TGetResultSetMetadataReq req)'
print ' TFetchResultsResp FetchResults(TFetchResultsReq req)'
+ print ' TGetDelegationTokenResp GetDelegationToken(TGetDelegationTokenReq req)'
+ print ' TCancelDelegationTokenResp CancelDelegationToken(TCancelDelegationTokenReq req)'
+ print ' TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req)'
print ''
sys.exit(0)
@@ -186,6 +189,24 @@ elif cmd == 'FetchResults':
sys.exit(1)
pp.pprint(client.FetchResults(eval(args[0]),))
+elif cmd == 'GetDelegationToken':
+ if len(args) != 1:
+ print 'GetDelegationToken requires 1 args'
+ sys.exit(1)
+ pp.pprint(client.GetDelegationToken(eval(args[0]),))
+
+elif cmd == 'CancelDelegationToken':
+ if len(args) != 1:
+ print 'CancelDelegationToken requires 1 args'
+ sys.exit(1)
+ pp.pprint(client.CancelDelegationToken(eval(args[0]),))
+
+elif cmd == 'RenewDelegationToken':
+ if len(args) != 1:
+ print 'RenewDelegationToken requires 1 args'
+ sys.exit(1)
+ pp.pprint(client.RenewDelegationToken(eval(args[0]),))
+
else:
print 'Unrecognized method %s' % cmd
sys.exit(1)
diff --git service/src/gen/thrift/gen-py/TCLIService/TCLIService.py service/src/gen/thrift/gen-py/TCLIService/TCLIService.py
index 6d2255b..ebc6574 100644
--- service/src/gen/thrift/gen-py/TCLIService/TCLIService.py
+++ service/src/gen/thrift/gen-py/TCLIService/TCLIService.py
@@ -130,6 +130,27 @@ def FetchResults(self, req):
"""
pass
+ def GetDelegationToken(self, req):
+ """
+ Parameters:
+ - req
+ """
+ pass
+
+ def CancelDelegationToken(self, req):
+ """
+ Parameters:
+ - req
+ """
+ pass
+
+ def RenewDelegationToken(self, req):
+ """
+ Parameters:
+ - req
+ """
+ pass
+
class Client(Iface):
def __init__(self, iprot, oprot=None):
@@ -618,6 +639,96 @@ def recv_FetchResults(self, ):
return result.success
raise TApplicationException(TApplicationException.MISSING_RESULT, "FetchResults failed: unknown result");
+ def GetDelegationToken(self, req):
+ """
+ Parameters:
+ - req
+ """
+ self.send_GetDelegationToken(req)
+ return self.recv_GetDelegationToken()
+
+ def send_GetDelegationToken(self, req):
+ self._oprot.writeMessageBegin('GetDelegationToken', TMessageType.CALL, self._seqid)
+ args = GetDelegationToken_args()
+ args.req = req
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_GetDelegationToken(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = GetDelegationToken_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "GetDelegationToken failed: unknown result");
+
+ def CancelDelegationToken(self, req):
+ """
+ Parameters:
+ - req
+ """
+ self.send_CancelDelegationToken(req)
+ return self.recv_CancelDelegationToken()
+
+ def send_CancelDelegationToken(self, req):
+ self._oprot.writeMessageBegin('CancelDelegationToken', TMessageType.CALL, self._seqid)
+ args = CancelDelegationToken_args()
+ args.req = req
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_CancelDelegationToken(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = CancelDelegationToken_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "CancelDelegationToken failed: unknown result");
+
+ def RenewDelegationToken(self, req):
+ """
+ Parameters:
+ - req
+ """
+ self.send_RenewDelegationToken(req)
+ return self.recv_RenewDelegationToken()
+
+ def send_RenewDelegationToken(self, req):
+ self._oprot.writeMessageBegin('RenewDelegationToken', TMessageType.CALL, self._seqid)
+ args = RenewDelegationToken_args()
+ args.req = req
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_RenewDelegationToken(self, ):
+ (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(self._iprot)
+ self._iprot.readMessageEnd()
+ raise x
+ result = RenewDelegationToken_result()
+ result.read(self._iprot)
+ self._iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "RenewDelegationToken failed: unknown result");
+
class Processor(Iface, TProcessor):
def __init__(self, handler):
@@ -639,6 +750,9 @@ def __init__(self, handler):
self._processMap["CloseOperation"] = Processor.process_CloseOperation
self._processMap["GetResultSetMetadata"] = Processor.process_GetResultSetMetadata
self._processMap["FetchResults"] = Processor.process_FetchResults
+ self._processMap["GetDelegationToken"] = Processor.process_GetDelegationToken
+ self._processMap["CancelDelegationToken"] = Processor.process_CancelDelegationToken
+ self._processMap["RenewDelegationToken"] = Processor.process_RenewDelegationToken
def process(self, iprot, oprot):
(name, type, seqid) = iprot.readMessageBegin()
@@ -831,6 +945,39 @@ def process_FetchResults(self, seqid, iprot, oprot):
oprot.writeMessageEnd()
oprot.trans.flush()
+ def process_GetDelegationToken(self, seqid, iprot, oprot):
+ args = GetDelegationToken_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = GetDelegationToken_result()
+ result.success = self._handler.GetDelegationToken(args.req)
+ oprot.writeMessageBegin("GetDelegationToken", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_CancelDelegationToken(self, seqid, iprot, oprot):
+ args = CancelDelegationToken_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = CancelDelegationToken_result()
+ result.success = self._handler.CancelDelegationToken(args.req)
+ oprot.writeMessageBegin("CancelDelegationToken", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_RenewDelegationToken(self, seqid, iprot, oprot):
+ args = RenewDelegationToken_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = RenewDelegationToken_result()
+ result.success = self._handler.RenewDelegationToken(args.req)
+ oprot.writeMessageBegin("RenewDelegationToken", TMessageType.REPLY, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
# HELPER FUNCTIONS AND STRUCTURES
@@ -2769,3 +2916,366 @@ def __eq__(self, other):
def __ne__(self, other):
return not (self == other)
+
+class GetDelegationToken_args:
+ """
+ Attributes:
+ - req
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'req', (TGetDelegationTokenReq, TGetDelegationTokenReq.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, req=None,):
+ self.req = req
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.req = TGetDelegationTokenReq()
+ self.req.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('GetDelegationToken_args')
+ if self.req is not None:
+ oprot.writeFieldBegin('req', TType.STRUCT, 1)
+ self.req.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class GetDelegationToken_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.STRUCT, 'success', (TGetDelegationTokenResp, TGetDelegationTokenResp.thrift_spec), None, ), # 0
+ )
+
+ def __init__(self, success=None,):
+ self.success = success
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = TGetDelegationTokenResp()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('GetDelegationToken_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class CancelDelegationToken_args:
+ """
+ Attributes:
+ - req
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'req', (TCancelDelegationTokenReq, TCancelDelegationTokenReq.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, req=None,):
+ self.req = req
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.req = TCancelDelegationTokenReq()
+ self.req.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('CancelDelegationToken_args')
+ if self.req is not None:
+ oprot.writeFieldBegin('req', TType.STRUCT, 1)
+ self.req.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class CancelDelegationToken_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.STRUCT, 'success', (TCancelDelegationTokenResp, TCancelDelegationTokenResp.thrift_spec), None, ), # 0
+ )
+
+ def __init__(self, success=None,):
+ self.success = success
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = TCancelDelegationTokenResp()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('CancelDelegationToken_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class RenewDelegationToken_args:
+ """
+ Attributes:
+ - req
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'req', (TRenewDelegationTokenReq, TRenewDelegationTokenReq.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, req=None,):
+ self.req = req
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.req = TRenewDelegationTokenReq()
+ self.req.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('RenewDelegationToken_args')
+ if self.req is not None:
+ oprot.writeFieldBegin('req', TType.STRUCT, 1)
+ self.req.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class RenewDelegationToken_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.STRUCT, 'success', (TRenewDelegationTokenResp, TRenewDelegationTokenResp.thrift_spec), None, ), # 0
+ )
+
+ def __init__(self, success=None,):
+ self.success = success
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = TRenewDelegationTokenResp()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('RenewDelegationToken_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
diff --git service/src/gen/thrift/gen-py/TCLIService/ttypes.py service/src/gen/thrift/gen-py/TCLIService/ttypes.py
index aa9c3e8..8d4cd6e 100644
--- service/src/gen/thrift/gen-py/TCLIService/ttypes.py
+++ service/src/gen/thrift/gen-py/TCLIService/ttypes.py
@@ -5921,3 +5921,449 @@ def __eq__(self, other):
def __ne__(self, other):
return not (self == other)
+
+class TGetDelegationTokenReq:
+ """
+ Attributes:
+ - sessionHandle
+ - owner
+ - renewer
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'sessionHandle', (TSessionHandle, TSessionHandle.thrift_spec), None, ), # 1
+ (2, TType.STRING, 'owner', None, None, ), # 2
+ (3, TType.STRING, 'renewer', None, None, ), # 3
+ )
+
+ def __init__(self, sessionHandle=None, owner=None, renewer=None,):
+ self.sessionHandle = sessionHandle
+ self.owner = owner
+ self.renewer = renewer
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.sessionHandle = TSessionHandle()
+ self.sessionHandle.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.owner = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRING:
+ self.renewer = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('TGetDelegationTokenReq')
+ if self.sessionHandle is not None:
+ oprot.writeFieldBegin('sessionHandle', TType.STRUCT, 1)
+ self.sessionHandle.write(oprot)
+ oprot.writeFieldEnd()
+ if self.owner is not None:
+ oprot.writeFieldBegin('owner', TType.STRING, 2)
+ oprot.writeString(self.owner)
+ oprot.writeFieldEnd()
+ if self.renewer is not None:
+ oprot.writeFieldBegin('renewer', TType.STRING, 3)
+ oprot.writeString(self.renewer)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.sessionHandle is None:
+ raise TProtocol.TProtocolException(message='Required field sessionHandle is unset!')
+ if self.owner is None:
+ raise TProtocol.TProtocolException(message='Required field owner is unset!')
+ if self.renewer is None:
+ raise TProtocol.TProtocolException(message='Required field renewer is unset!')
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class TGetDelegationTokenResp:
+ """
+ Attributes:
+ - status
+ - delegationToken
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'status', (TStatus, TStatus.thrift_spec), None, ), # 1
+ (2, TType.STRING, 'delegationToken', None, None, ), # 2
+ )
+
+ def __init__(self, status=None, delegationToken=None,):
+ self.status = status
+ self.delegationToken = delegationToken
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.status = TStatus()
+ self.status.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.delegationToken = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('TGetDelegationTokenResp')
+ if self.status is not None:
+ oprot.writeFieldBegin('status', TType.STRUCT, 1)
+ self.status.write(oprot)
+ oprot.writeFieldEnd()
+ if self.delegationToken is not None:
+ oprot.writeFieldBegin('delegationToken', TType.STRING, 2)
+ oprot.writeString(self.delegationToken)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.status is None:
+ raise TProtocol.TProtocolException(message='Required field status is unset!')
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class TCancelDelegationTokenReq:
+ """
+ Attributes:
+ - sessionHandle
+ - delegationToken
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'sessionHandle', (TSessionHandle, TSessionHandle.thrift_spec), None, ), # 1
+ (2, TType.STRING, 'delegationToken', None, None, ), # 2
+ )
+
+ def __init__(self, sessionHandle=None, delegationToken=None,):
+ self.sessionHandle = sessionHandle
+ self.delegationToken = delegationToken
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.sessionHandle = TSessionHandle()
+ self.sessionHandle.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.delegationToken = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('TCancelDelegationTokenReq')
+ if self.sessionHandle is not None:
+ oprot.writeFieldBegin('sessionHandle', TType.STRUCT, 1)
+ self.sessionHandle.write(oprot)
+ oprot.writeFieldEnd()
+ if self.delegationToken is not None:
+ oprot.writeFieldBegin('delegationToken', TType.STRING, 2)
+ oprot.writeString(self.delegationToken)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.sessionHandle is None:
+ raise TProtocol.TProtocolException(message='Required field sessionHandle is unset!')
+ if self.delegationToken is None:
+ raise TProtocol.TProtocolException(message='Required field delegationToken is unset!')
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class TCancelDelegationTokenResp:
+ """
+ Attributes:
+ - status
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'status', (TStatus, TStatus.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, status=None,):
+ self.status = status
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.status = TStatus()
+ self.status.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('TCancelDelegationTokenResp')
+ if self.status is not None:
+ oprot.writeFieldBegin('status', TType.STRUCT, 1)
+ self.status.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.status is None:
+ raise TProtocol.TProtocolException(message='Required field status is unset!')
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class TRenewDelegationTokenReq:
+ """
+ Attributes:
+ - sessionHandle
+ - delegationToken
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'sessionHandle', (TSessionHandle, TSessionHandle.thrift_spec), None, ), # 1
+ (2, TType.STRING, 'delegationToken', None, None, ), # 2
+ )
+
+ def __init__(self, sessionHandle=None, delegationToken=None,):
+ self.sessionHandle = sessionHandle
+ self.delegationToken = delegationToken
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.sessionHandle = TSessionHandle()
+ self.sessionHandle.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.delegationToken = iprot.readString();
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('TRenewDelegationTokenReq')
+ if self.sessionHandle is not None:
+ oprot.writeFieldBegin('sessionHandle', TType.STRUCT, 1)
+ self.sessionHandle.write(oprot)
+ oprot.writeFieldEnd()
+ if self.delegationToken is not None:
+ oprot.writeFieldBegin('delegationToken', TType.STRING, 2)
+ oprot.writeString(self.delegationToken)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.sessionHandle is None:
+ raise TProtocol.TProtocolException(message='Required field sessionHandle is unset!')
+ if self.delegationToken is None:
+ raise TProtocol.TProtocolException(message='Required field delegationToken is unset!')
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class TRenewDelegationTokenResp:
+ """
+ Attributes:
+ - status
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'status', (TStatus, TStatus.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, status=None,):
+ self.status = status
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.status = TStatus()
+ self.status.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('TRenewDelegationTokenResp')
+ if self.status is not None:
+ oprot.writeFieldBegin('status', TType.STRUCT, 1)
+ self.status.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.status is None:
+ raise TProtocol.TProtocolException(message='Required field status is unset!')
+ return
+
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
diff --git service/src/gen/thrift/gen-py/hive_service/ThriftHive-remote service/src/gen/thrift/gen-py/hive_service/ThriftHive-remote
old mode 100644
new mode 100755
diff --git service/src/gen/thrift/gen-rb/t_c_l_i_service.rb service/src/gen/thrift/gen-rb/t_c_l_i_service.rb
index 2455e3b..fd1ca9a 100644
--- service/src/gen/thrift/gen-rb/t_c_l_i_service.rb
+++ service/src/gen/thrift/gen-rb/t_c_l_i_service.rb
@@ -251,6 +251,51 @@ module TCLIService
raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'FetchResults failed: unknown result')
end
+ def GetDelegationToken(req)
+ send_GetDelegationToken(req)
+ return recv_GetDelegationToken()
+ end
+
+ def send_GetDelegationToken(req)
+ send_message('GetDelegationToken', GetDelegationToken_args, :req => req)
+ end
+
+ def recv_GetDelegationToken()
+ result = receive_message(GetDelegationToken_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'GetDelegationToken failed: unknown result')
+ end
+
+ def CancelDelegationToken(req)
+ send_CancelDelegationToken(req)
+ return recv_CancelDelegationToken()
+ end
+
+ def send_CancelDelegationToken(req)
+ send_message('CancelDelegationToken', CancelDelegationToken_args, :req => req)
+ end
+
+ def recv_CancelDelegationToken()
+ result = receive_message(CancelDelegationToken_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'CancelDelegationToken failed: unknown result')
+ end
+
+ def RenewDelegationToken(req)
+ send_RenewDelegationToken(req)
+ return recv_RenewDelegationToken()
+ end
+
+ def send_RenewDelegationToken(req)
+ send_message('RenewDelegationToken', RenewDelegationToken_args, :req => req)
+ end
+
+ def recv_RenewDelegationToken()
+ result = receive_message(RenewDelegationToken_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'RenewDelegationToken failed: unknown result')
+ end
+
end
class Processor
@@ -368,6 +413,27 @@ module TCLIService
write_result(result, oprot, 'FetchResults', seqid)
end
+ def process_GetDelegationToken(seqid, iprot, oprot)
+ args = read_args(iprot, GetDelegationToken_args)
+ result = GetDelegationToken_result.new()
+ result.success = @handler.GetDelegationToken(args.req)
+ write_result(result, oprot, 'GetDelegationToken', seqid)
+ end
+
+ def process_CancelDelegationToken(seqid, iprot, oprot)
+ args = read_args(iprot, CancelDelegationToken_args)
+ result = CancelDelegationToken_result.new()
+ result.success = @handler.CancelDelegationToken(args.req)
+ write_result(result, oprot, 'CancelDelegationToken', seqid)
+ end
+
+ def process_RenewDelegationToken(seqid, iprot, oprot)
+ args = read_args(iprot, RenewDelegationToken_args)
+ result = RenewDelegationToken_result.new()
+ result.success = @handler.RenewDelegationToken(args.req)
+ write_result(result, oprot, 'RenewDelegationToken', seqid)
+ end
+
end
# HELPER FUNCTIONS AND STRUCTURES
@@ -884,5 +950,101 @@ module TCLIService
::Thrift::Struct.generate_accessors self
end
+ class GetDelegationToken_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ REQ = 1
+
+ FIELDS = {
+ REQ => {:type => ::Thrift::Types::STRUCT, :name => 'req', :class => ::TGetDelegationTokenReq}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class GetDelegationToken_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::TGetDelegationTokenResp}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class CancelDelegationToken_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ REQ = 1
+
+ FIELDS = {
+ REQ => {:type => ::Thrift::Types::STRUCT, :name => 'req', :class => ::TCancelDelegationTokenReq}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class CancelDelegationToken_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::TCancelDelegationTokenResp}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class RenewDelegationToken_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ REQ = 1
+
+ FIELDS = {
+ REQ => {:type => ::Thrift::Types::STRUCT, :name => 'req', :class => ::TRenewDelegationTokenReq}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class RenewDelegationToken_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::TRenewDelegationTokenResp}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
end
diff --git service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb
index e32e10b..a918600 100644
--- service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb
+++ service/src/gen/thrift/gen-rb/t_c_l_i_service_types.rb
@@ -1639,3 +1639,119 @@ class TFetchResultsResp
::Thrift::Struct.generate_accessors self
end
+class TGetDelegationTokenReq
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SESSIONHANDLE = 1
+ OWNER = 2
+ RENEWER = 3
+
+ FIELDS = {
+ SESSIONHANDLE => {:type => ::Thrift::Types::STRUCT, :name => 'sessionHandle', :class => ::TSessionHandle},
+ OWNER => {:type => ::Thrift::Types::STRING, :name => 'owner'},
+ RENEWER => {:type => ::Thrift::Types::STRING, :name => 'renewer'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field sessionHandle is unset!') unless @sessionHandle
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field owner is unset!') unless @owner
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field renewer is unset!') unless @renewer
+ end
+
+ ::Thrift::Struct.generate_accessors self
+end
+
+class TGetDelegationTokenResp
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ STATUS = 1
+ DELEGATIONTOKEN = 2
+
+ FIELDS = {
+ STATUS => {:type => ::Thrift::Types::STRUCT, :name => 'status', :class => ::TStatus},
+ DELEGATIONTOKEN => {:type => ::Thrift::Types::STRING, :name => 'delegationToken', :optional => true}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field status is unset!') unless @status
+ end
+
+ ::Thrift::Struct.generate_accessors self
+end
+
+class TCancelDelegationTokenReq
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SESSIONHANDLE = 1
+ DELEGATIONTOKEN = 2
+
+ FIELDS = {
+ SESSIONHANDLE => {:type => ::Thrift::Types::STRUCT, :name => 'sessionHandle', :class => ::TSessionHandle},
+ DELEGATIONTOKEN => {:type => ::Thrift::Types::STRING, :name => 'delegationToken'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field sessionHandle is unset!') unless @sessionHandle
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field delegationToken is unset!') unless @delegationToken
+ end
+
+ ::Thrift::Struct.generate_accessors self
+end
+
+class TCancelDelegationTokenResp
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ STATUS = 1
+
+ FIELDS = {
+ STATUS => {:type => ::Thrift::Types::STRUCT, :name => 'status', :class => ::TStatus}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field status is unset!') unless @status
+ end
+
+ ::Thrift::Struct.generate_accessors self
+end
+
+class TRenewDelegationTokenReq
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SESSIONHANDLE = 1
+ DELEGATIONTOKEN = 2
+
+ FIELDS = {
+ SESSIONHANDLE => {:type => ::Thrift::Types::STRUCT, :name => 'sessionHandle', :class => ::TSessionHandle},
+ DELEGATIONTOKEN => {:type => ::Thrift::Types::STRING, :name => 'delegationToken'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field sessionHandle is unset!') unless @sessionHandle
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field delegationToken is unset!') unless @delegationToken
+ end
+
+ ::Thrift::Struct.generate_accessors self
+end
+
+class TRenewDelegationTokenResp
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ STATUS = 1
+
+ FIELDS = {
+ STATUS => {:type => ::Thrift::Types::STRUCT, :name => 'status', :class => ::TStatus}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field status is unset!') unless @status
+ end
+
+ ::Thrift::Struct.generate_accessors self
+end
+
diff --git service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
index d8ba3aa..6759903 100644
--- service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
+++ service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
@@ -32,7 +32,9 @@
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
import org.apache.hadoop.hive.shims.ShimLoader;
import org.apache.hadoop.hive.thrift.HadoopThriftAuthBridge;
+import org.apache.hive.service.cli.HiveSQLException;
import org.apache.hive.service.cli.thrift.ThriftCLIService;
+import org.apache.hadoop.security.UserGroupInformation;
import org.apache.thrift.TProcessorFactory;
import org.apache.thrift.transport.TSSLTransportFactory;
import org.apache.thrift.transport.TServerSocket;
@@ -67,7 +69,10 @@ public String getAuthName() {
private HadoopThriftAuthBridge.Server saslServer = null;
private String authTypeStr;
- HiveConf conf;
+ private final HiveConf conf;
+
+ public static final String HS2_PROXY_USER = "hive.server2.proxy.user";
+ public static final String HS2_CLIENT_TOKEN = "hiveserver2ClientToken";
public HiveAuthFactory() throws TTransportException {
conf = new HiveConf();
@@ -82,6 +87,13 @@ public HiveAuthFactory() throws TTransportException {
conf.getVar(ConfVars.HIVE_SERVER2_KERBEROS_KEYTAB),
conf.getVar(ConfVars.HIVE_SERVER2_KERBEROS_PRINCIPAL)
);
+ // start delegation token manager
+ try {
+ saslServer.startDelegationTokenSecretManager(conf, null);
+ } catch (IOException e) {
+ throw new TTransportException("Failed to start token manager", e);
+ }
+
}
}
@@ -145,6 +157,10 @@ public String getRemoteUser() {
}
}
+ public String getIpAddress() {
+ return saslServer != null ? saslServer.getRemoteAddress().toString() : null;
+ }
+
/* perform kerberos login using the hadoop shim API if the configuration is available */
public static void loginFromKeytab(HiveConf hiveConf) throws IOException {
String principal = hiveConf.getVar(ConfVars.HIVE_SERVER2_KERBEROS_PRINCIPAL);
@@ -204,4 +220,81 @@ public static TServerSocket getServerSSLSocket(String hiveHost, int portNum,
return TSSLTransportFactory.getServerSocket(portNum, 10000, serverAddress, params);
}
+ // retrieve delegation token for the given user
+ public String getDelegationToken(String owner, String renewer) throws HiveSQLException {
+ if (saslServer == null) {
+ throw new HiveSQLException(
+ "Delegation token only supported over kerberos authentication");
+ }
+
+ try {
+ String tokenStr = saslServer.getDelegationTokenWithService(owner, renewer, HS2_CLIENT_TOKEN);
+ if (tokenStr == null || tokenStr.isEmpty()) {
+ throw new HiveSQLException("Received empty retrieving delegation token for user " + owner);
+ }
+ return tokenStr;
+ } catch (IOException e) {
+ throw new HiveSQLException("Error retrieving delegation token for user " + owner, e);
+ } catch (InterruptedException e) {
+ throw new HiveSQLException("delegation token retrieval interrupted", e);
+ }
+ }
+
+ // cancel given delegation token
+ public void cancelDelegationToken(String delegationToken) throws HiveSQLException {
+ if (saslServer == null) {
+ throw new HiveSQLException(
+ "Delegation token only supported over kerberos authentication");
+ }
+ try {
+ saslServer.cancelDelegationToken(delegationToken);
+ } catch (IOException e) {
+ throw new HiveSQLException("Error canceling delegation token " + delegationToken, e);
+ }
+ }
+
+ public void renewDelegationToken(String delegationToken) throws HiveSQLException {
+ if (saslServer == null) {
+ throw new HiveSQLException(
+ "Delegation token only supported over kerberos authentication");
+ }
+ try {
+ saslServer.renewDelegationToken(delegationToken);
+ } catch (IOException e) {
+ throw new HiveSQLException("Error renewing delegation token " + delegationToken, e);
+ }
+ }
+
+ public String getUserFromToken(String delegationToken) throws HiveSQLException {
+ if (saslServer == null) {
+ throw new HiveSQLException(
+ "Delegation token only supported over kerberos authentication");
+ }
+ try {
+ return saslServer.getUserFromToken(delegationToken);
+ } catch (IOException e) {
+ throw new HiveSQLException("Error extracting user from delegation token " + delegationToken, e);
+ }
+ }
+
+ public static void verifyProxyAccess(String realUser, String proxyUser, String ipAddress,
+ HiveConf hiveConf) throws HiveSQLException {
+ UserGroupInformation sessionUgi;
+
+ try {
+ if (ShimLoader.getHadoopShims().isSecurityEnabled()) {
+ sessionUgi = ShimLoader.getHadoopShims().createProxyUser(realUser);
+ } else {
+ sessionUgi = ShimLoader.getHadoopShims().createRemoteUser(realUser, null);
+ }
+ if (!proxyUser.equalsIgnoreCase(realUser)) {
+ ShimLoader.getHadoopShims().
+ authorizeProxyAccess(proxyUser, sessionUgi, ipAddress, hiveConf);
+ }
+ } catch (IOException e) {
+ throw new HiveSQLException("Failed to validate proxy privilage of " + realUser +
+ " for " + proxyUser, e);
+ }
+ }
+
}
diff --git service/src/java/org/apache/hive/service/auth/KerberosSaslHelper.java service/src/java/org/apache/hive/service/auth/KerberosSaslHelper.java
index 519556c..93ec545 100644
--- service/src/java/org/apache/hive/service/auth/KerberosSaslHelper.java
+++ service/src/java/org/apache/hive/service/auth/KerberosSaslHelper.java
@@ -74,5 +74,17 @@ public static TTransport getKerberosTransport(String principal, String host,
}
}
+ public static TTransport getTokenTransport(String tokenStr, String host,
+ final TTransport underlyingTransport, Map saslProps) throws SaslException {
+ HadoopThriftAuthBridge.Client authBridge =
+ ShimLoader.getHadoopThriftAuthBridge().createClientWithConf("kerberos");
+
+ try {
+ return authBridge.createClientTransport(null, host,
+ "DIGEST", tokenStr, underlyingTransport, saslProps);
+ } catch (IOException e) {
+ throw new SaslException("Failed to open client transport", e);
+ }
+ }
}
diff --git service/src/java/org/apache/hive/service/auth/PlainSaslHelper.java service/src/java/org/apache/hive/service/auth/PlainSaslHelper.java
index 15b1675..5a4519f 100644
--- service/src/java/org/apache/hive/service/auth/PlainSaslHelper.java
+++ service/src/java/org/apache/hive/service/auth/PlainSaslHelper.java
@@ -97,20 +97,16 @@ public void handle(Callback[] callbacks)
private static class SQLPlainProcessorFactory extends TProcessorFactory {
private final ThriftCLIService service;
private final HiveConf conf;
- private final boolean doAsEnabled;
public SQLPlainProcessorFactory(ThriftCLIService service) {
super(null);
this.service = service;
this.conf = service.getHiveConf();
- this.doAsEnabled = conf.getBoolVar(HiveConf.ConfVars.HIVE_SERVER2_ENABLE_DOAS);
}
@Override
public TProcessor getProcessor(TTransport trans) {
- TProcessor baseProcessor = new TCLIService.Processor(service);
- return doAsEnabled ? new TUGIContainingProcessor(baseProcessor, conf) :
- new TSetIpAddressProcessor(service);
+ return new TSetIpAddressProcessor(service);
}
}
diff --git service/src/java/org/apache/hive/service/cli/CLIService.java service/src/java/org/apache/hive/service/cli/CLIService.java
index 2b1e712..bdc943e 100644
--- service/src/java/org/apache/hive/service/cli/CLIService.java
+++ service/src/java/org/apache/hive/service/cli/CLIService.java
@@ -427,4 +427,28 @@ private void setupStagingDir(String dirPath, boolean isLocal) throws IOException
fs.setPermission(scratchDir, fsPermission);
}
}
+
+ @Override
+ public String getDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String owner, String renewer) throws HiveSQLException {
+ String delegationToken = sessionManager.getSession(sessionHandle).
+ getDelegationToken(authFactory, owner, renewer);
+ LOG.info(sessionHandle + ": getDelegationToken()");
+ return delegationToken;
+ }
+
+ @Override
+ public void cancelDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException {
+ sessionManager.getSession(sessionHandle).
+ cancelDelegationToken(authFactory, tokenStr);
+ LOG.info(sessionHandle + ": cancelDelegationToken()");
+ }
+
+ @Override
+ public void renewDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException {
+ sessionManager.getSession(sessionHandle).renewDelegationToken(authFactory, tokenStr);
+ LOG.info(sessionHandle + ": renewDelegationToken()");
+ }
}
diff --git service/src/java/org/apache/hive/service/cli/CLIServiceClient.java service/src/java/org/apache/hive/service/cli/CLIServiceClient.java
index b9d1489..87c10b9 100644
--- service/src/java/org/apache/hive/service/cli/CLIServiceClient.java
+++ service/src/java/org/apache/hive/service/cli/CLIServiceClient.java
@@ -20,6 +20,8 @@
import java.util.Collections;
+import org.apache.hive.service.auth.HiveAuthFactory;
+
/**
* CLIServiceClient.
@@ -41,4 +43,16 @@ public RowSet fetchResults(OperationHandle opHandle) throws HiveSQLException {
return fetchResults(opHandle, FetchOrientation.FETCH_NEXT, 1000);
}
+ @Override
+ public abstract String getDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String owner, String renewer) throws HiveSQLException;
+
+ @Override
+ public abstract void cancelDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException;
+
+ @Override
+ public abstract void renewDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException;
+
}
diff --git service/src/java/org/apache/hive/service/cli/EmbeddedCLIServiceClient.java service/src/java/org/apache/hive/service/cli/EmbeddedCLIServiceClient.java
index a31ea94..f665146 100644
--- service/src/java/org/apache/hive/service/cli/EmbeddedCLIServiceClient.java
+++ service/src/java/org/apache/hive/service/cli/EmbeddedCLIServiceClient.java
@@ -21,6 +21,8 @@
import java.util.List;
import java.util.Map;
+import org.apache.hive.service.auth.HiveAuthFactory;
+
/**
* EmbeddedCLIServiceClient.
@@ -188,4 +190,22 @@ public RowSet fetchResults(OperationHandle opHandle, FetchOrientation orientatio
return cliService.fetchResults(opHandle, orientation, maxRows);
}
+
+ @Override
+ public String getDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String owner, String renewer) throws HiveSQLException {
+ return cliService.getDelegationToken(sessionHandle, authFactory, owner, renewer);
+ }
+
+ @Override
+ public void cancelDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException {
+ cliService.cancelDelegationToken(sessionHandle, authFactory, tokenStr);
+ }
+
+ @Override
+ public void renewDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException {
+ cliService.renewDelegationToken(sessionHandle, authFactory, tokenStr);
+ }
}
diff --git service/src/java/org/apache/hive/service/cli/ICLIService.java service/src/java/org/apache/hive/service/cli/ICLIService.java
index 621d689..c569796 100644
--- service/src/java/org/apache/hive/service/cli/ICLIService.java
+++ service/src/java/org/apache/hive/service/cli/ICLIService.java
@@ -23,6 +23,8 @@
+import org.apache.hive.service.auth.HiveAuthFactory;
+
public interface ICLIService {
public abstract SessionHandle openSession(String username, String password,
@@ -91,4 +93,14 @@ public abstract RowSet fetchResults(OperationHandle opHandle, FetchOrientation o
public abstract RowSet fetchResults(OperationHandle opHandle)
throws HiveSQLException;
+ public abstract String getDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String owner, String renewer) throws HiveSQLException;
+
+ public abstract void cancelDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException;
+
+ public abstract void renewDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException;
+
+
}
diff --git service/src/java/org/apache/hive/service/cli/session/HiveSession.java service/src/java/org/apache/hive/service/cli/session/HiveSession.java
index c8fb8ec..b1bad47 100644
--- service/src/java/org/apache/hive/service/cli/session/HiveSession.java
+++ service/src/java/org/apache/hive/service/cli/session/HiveSession.java
@@ -24,6 +24,7 @@
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.metastore.IMetaStoreClient;
import org.apache.hadoop.hive.ql.session.SessionState;
+import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.cli.FetchOrientation;
import org.apache.hive.service.cli.GetInfoType;
import org.apache.hive.service.cli.GetInfoValue;
@@ -183,4 +184,17 @@ public RowSet fetchResults(OperationHandle opHandle, FetchOrientation orientatio
public String getUserName();
public void setUserName(String userName);
+
+ public String getIpAddress();
+
+ public void setIpAddress(String ipAddress);
+
+ public String getDelegationToken(HiveAuthFactory authFactory, String owner,
+ String renewer) throws HiveSQLException;
+
+ public void cancelDelegationToken(HiveAuthFactory authFactory, String tokenStr)
+ throws HiveSQLException;
+
+ public void renewDelegationToken(HiveAuthFactory authFactory, String tokenStr)
+ throws HiveSQLException;
}
diff --git service/src/java/org/apache/hive/service/cli/session/HiveSessionImpl.java service/src/java/org/apache/hive/service/cli/session/HiveSessionImpl.java
index d6d0d27..5b78e68 100644
--- service/src/java/org/apache/hive/service/cli/session/HiveSessionImpl.java
+++ service/src/java/org/apache/hive/service/cli/session/HiveSessionImpl.java
@@ -35,7 +35,9 @@
import org.apache.hadoop.hive.ql.exec.ListSinkOperator;
import org.apache.hadoop.hive.ql.history.HiveHistory;
import org.apache.hadoop.hive.ql.session.SessionState;
+import org.apache.hadoop.hive.shims.ShimLoader;
import org.apache.hive.common.util.HiveVersionInfo;
+import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.cli.FetchOrientation;
import org.apache.hive.service.cli.GetInfoType;
import org.apache.hive.service.cli.GetInfoValue;
@@ -67,6 +69,7 @@
private final String password;
private final HiveConf hiveConf;
private final SessionState sessionState;
+ private String ipAddress;
private static final String FETCH_WORK_SERDE_CLASS =
"org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe";
@@ -79,11 +82,12 @@
private final Set opHandleSet = new HashSet();
public HiveSessionImpl(TProtocolVersion protocol, String username, String password,
- HiveConf serverhiveConf, Map sessionConfMap) {
+ HiveConf serverhiveConf, Map sessionConfMap, String ipAddress) {
this.username = username;
this.password = password;
this.sessionHandle = new SessionHandle(protocol);
this.hiveConf = new HiveConf(serverhiveConf);
+ this.ipAddress = ipAddress;
//set conf properties specified by user from client side
if (sessionConfMap != null) {
@@ -418,6 +422,7 @@ public SessionState getSessionState() {
public String getUserName() {
return username;
}
+
@Override
public void setUserName(String userName) {
this.username = userName;
@@ -479,4 +484,42 @@ public RowSet fetchResults(OperationHandle opHandle) throws HiveSQLException {
protected HiveSession getSession() {
return this;
}
+
+ @Override
+ public String getIpAddress() {
+ return ipAddress;
+ }
+
+ @Override
+ public void setIpAddress(String ipAddress) {
+ this.ipAddress = ipAddress;
+ }
+
+ @Override
+ public String getDelegationToken(HiveAuthFactory authFactory, String owner, String renewer)
+ throws HiveSQLException {
+ HiveAuthFactory.verifyProxyAccess(getUsername(), owner, getIpAddress(), getHiveConf());
+ return authFactory.getDelegationToken(owner, renewer);
+ }
+
+ @Override
+ public void cancelDelegationToken(HiveAuthFactory authFactory, String tokenStr)
+ throws HiveSQLException {
+ HiveAuthFactory.verifyProxyAccess(getUsername(), getUserFromToken(authFactory, tokenStr),
+ getIpAddress(), getHiveConf());
+ authFactory.cancelDelegationToken(tokenStr);
+ }
+
+ @Override
+ public void renewDelegationToken(HiveAuthFactory authFactory, String tokenStr)
+ throws HiveSQLException {
+ HiveAuthFactory.verifyProxyAccess(getUsername(), getUserFromToken(authFactory, tokenStr),
+ getIpAddress(), getHiveConf());
+ authFactory.renewDelegationToken(tokenStr);
+ }
+
+ // extract the real user from the given token string
+ private String getUserFromToken(HiveAuthFactory authFactory, String tokenStr) throws HiveSQLException {
+ return authFactory.getUserFromToken(tokenStr);
+ }
}
diff --git service/src/java/org/apache/hive/service/cli/session/HiveSessionImplwithUGI.java service/src/java/org/apache/hive/service/cli/session/HiveSessionImplwithUGI.java
index b934ebe..e79b129 100644
--- service/src/java/org/apache/hive/service/cli/session/HiveSessionImplwithUGI.java
+++ service/src/java/org/apache/hive/service/cli/session/HiveSessionImplwithUGI.java
@@ -26,6 +26,7 @@
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.shims.ShimLoader;
import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.cli.HiveSQLException;
import org.apache.hive.service.cli.thrift.TProtocolVersion;
@@ -43,8 +44,9 @@
private HiveSession proxySession = null;
public HiveSessionImplwithUGI(TProtocolVersion protocol, String username, String password,
- HiveConf hiveConf, Map sessionConf, String delegationToken) throws HiveSQLException {
- super(protocol, username, password, hiveConf, sessionConf);
+ HiveConf hiveConf, Map sessionConf, String ipAddress,
+ String delegationToken) throws HiveSQLException {
+ super(protocol, username, password, hiveConf, sessionConf, ipAddress);
setSessionUGI(username);
setDelegationToken(delegationToken);
}
@@ -148,5 +150,22 @@ public void setProxySession(HiveSession proxySession) {
this.proxySession = proxySession;
}
+ @Override
+ public String getDelegationToken(HiveAuthFactory authFactory, String owner,
+ String renewer) throws HiveSQLException {
+ return authFactory.getDelegationToken(owner, renewer);
+ }
+
+ @Override
+ public void cancelDelegationToken(HiveAuthFactory authFactory, String tokenStr)
+ throws HiveSQLException {
+ authFactory.cancelDelegationToken(tokenStr);
+ }
+
+ @Override
+ public void renewDelegationToken(HiveAuthFactory authFactory, String tokenStr)
+ throws HiveSQLException {
+ authFactory.renewDelegationToken(tokenStr);
+ }
}
diff --git service/src/java/org/apache/hive/service/cli/session/SessionManager.java service/src/java/org/apache/hive/service/cli/session/SessionManager.java
index cec3b04..4545d2b 100644
--- service/src/java/org/apache/hive/service/cli/session/SessionManager.java
+++ service/src/java/org/apache/hive/service/cli/session/SessionManager.java
@@ -18,6 +18,7 @@
package org.apache.hive.service.cli.session;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@@ -31,6 +32,9 @@
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
import org.apache.hadoop.hive.ql.hooks.HookUtils;
+import org.apache.hadoop.hive.shims.ShimLoader;
+import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.CompositeService;
import org.apache.hive.service.cli.HiveSQLException;
import org.apache.hive.service.cli.SessionHandle;
@@ -101,17 +105,14 @@ public SessionHandle openSession(TProtocolVersion protocol, String username, Str
public SessionHandle openSession(TProtocolVersion protocol, String username, String password,
Map sessionConf, boolean withImpersonation, String delegationToken)
throws HiveSQLException {
- if (username == null) {
- username = threadLocalUserName.get();
- }
HiveSession session;
if (withImpersonation) {
HiveSessionImplwithUGI hiveSessionUgi = new HiveSessionImplwithUGI(protocol, username, password,
- hiveConf, sessionConf, delegationToken);
+ hiveConf, sessionConf, threadLocalIpAddress.get(), delegationToken);
session = HiveSessionProxy.getProxy(hiveSessionUgi, hiveSessionUgi.getSessionUgi());
hiveSessionUgi.setProxySession(session);
} else {
- session = new HiveSessionImpl(protocol, username, password, hiveConf, sessionConf);
+ session = new HiveSessionImpl(protocol, username, password, hiveConf, sessionConf, threadLocalIpAddress.get());
}
session.setSessionManager(this);
session.setOperationManager(operationManager);
@@ -161,6 +162,10 @@ private void clearIpAddress() {
threadLocalIpAddress.remove();
}
+ public static String getIpAddress() {
+ return threadLocalIpAddress.get();
+ }
+
private static ThreadLocal threadLocalUserName = new ThreadLocal(){
@Override
protected synchronized String initialValue() {
@@ -176,6 +181,10 @@ private void clearUserName() {
threadLocalUserName.remove();
}
+ public static String getUserName() {
+ return threadLocalUserName.get();
+ }
+
// execute session hooks
private void executeSessionHooks(HiveSession session) throws Exception {
List sessionHooks = HookUtils.getHooks(hiveConf,
@@ -190,3 +199,4 @@ private void executeSessionHooks(HiveSession session) throws Exception {
}
}
+
diff --git service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIService.java service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIService.java
index 26bda5a..0c9ac37 100644
--- service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIService.java
+++ service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIService.java
@@ -29,6 +29,8 @@
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
+import org.apache.hadoop.hive.shims.ShimLoader;
+import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hive.service.AbstractService;
import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.cli.CLIService;
@@ -41,6 +43,7 @@
import org.apache.hive.service.cli.RowSet;
import org.apache.hive.service.cli.SessionHandle;
import org.apache.hive.service.cli.TableSchema;
+import org.apache.hive.service.cli.session.SessionManager;
import org.apache.thrift.TException;
import org.apache.thrift.server.TServer;
@@ -111,6 +114,75 @@ public synchronized void stop() {
super.stop();
}
+ @Override
+ public TGetDelegationTokenResp GetDelegationToken(TGetDelegationTokenReq req)
+ throws TException {
+ TGetDelegationTokenResp resp = new TGetDelegationTokenResp();
+
+ if (hiveAuthFactory == null) {
+ resp.setStatus(unsecureTokenErrorStatus());
+ } else {
+ try {
+ String token = cliService.getDelegationToken(
+ new SessionHandle(req.getSessionHandle()),
+ hiveAuthFactory, req.getOwner(), req.getRenewer());
+ resp.setDelegationToken(token);
+ resp.setStatus(OK_STATUS);
+ } catch (HiveSQLException e) {
+ LOG.error("Error obtaining delegation token", e);
+ TStatus tokenErrorStatus = HiveSQLException.toTStatus(e);
+ tokenErrorStatus.setSqlState("42000");
+ resp.setStatus(tokenErrorStatus);
+ }
+ }
+ return resp;
+ }
+
+ @Override
+ public TCancelDelegationTokenResp CancelDelegationToken(TCancelDelegationTokenReq req)
+ throws TException {
+ TCancelDelegationTokenResp resp = new TCancelDelegationTokenResp();
+
+ if (hiveAuthFactory == null) {
+ resp.setStatus(unsecureTokenErrorStatus());
+ } else {
+ try {
+ cliService.cancelDelegationToken(new SessionHandle(req.getSessionHandle()),
+ hiveAuthFactory, req.getDelegationToken());
+ resp.setStatus(OK_STATUS);
+ } catch (HiveSQLException e) {
+ LOG.error("Error canceling delegation token", e);
+ resp.setStatus(HiveSQLException.toTStatus(e));
+ }
+ }
+ return resp;
+ }
+
+ @Override
+ public TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req)
+ throws TException {
+ TRenewDelegationTokenResp resp = new TRenewDelegationTokenResp();
+ if (hiveAuthFactory == null) {
+ resp.setStatus(unsecureTokenErrorStatus());
+ } else {
+ try {
+ cliService.renewDelegationToken(new SessionHandle(req.getSessionHandle()),
+ hiveAuthFactory, req.getDelegationToken());
+ resp.setStatus(OK_STATUS);
+ } catch (HiveSQLException e) {
+ LOG.error("Error obtaining renewing token", e);
+ resp.setStatus(HiveSQLException.toTStatus(e));
+ }
+ }
+ return resp;
+ }
+
+ private TStatus unsecureTokenErrorStatus() {
+ TStatus errorStatus = new TStatus(TStatusCode.ERROR_STATUS);
+ errorStatus.setErrorMessage("Delegation token only supported over remote " +
+ "client with kerberos authentication");
+ return errorStatus;
+ }
@Override
public TOpenSessionResp OpenSession(TOpenSessionReq req) throws TException {
@@ -129,13 +201,25 @@ public TOpenSessionResp OpenSession(TOpenSessionReq req) throws TException {
return resp;
}
- private String getUserName(TOpenSessionReq req) {
+ private String getIpAddress() {
+ if (hiveAuthFactory != null) {
+ return hiveAuthFactory.getIpAddress();
+ }
+ return SessionManager.getIpAddress();
+ }
+
+ private String getUserName(TOpenSessionReq req) throws HiveSQLException {
+ String userName;
if (hiveAuthFactory != null
&& hiveAuthFactory.getRemoteUser() != null) {
- return hiveAuthFactory.getRemoteUser();
+ userName = hiveAuthFactory.getRemoteUser();
} else {
- return req.getUsername();
+ userName = SessionManager.getUserName();
}
+ if (userName == null) {
+ userName = req.getUsername();
+ }
+ return getProxyUser(userName, req.getConfiguration(), getIpAddress());
}
SessionHandle getSessionHandle(TOpenSessionReq req, TOpenSessionResp res)
@@ -145,9 +229,8 @@ SessionHandle getSessionHandle(TOpenSessionReq req, TOpenSessionResp res)
TProtocolVersion protocol = getMinVersion(CLIService.SERVER_VERSION, req.getClient_protocol());
SessionHandle sessionHandle;
- if (cliService.getHiveConf().getVar(ConfVars.HIVE_SERVER2_AUTHENTICATION)
- .equals(HiveAuthFactory.AuthTypes.KERBEROS.toString()) &&
- cliService.getHiveConf().getBoolVar(ConfVars.HIVE_SERVER2_ENABLE_DOAS)) {
+ if (cliService.getHiveConf().getBoolVar(ConfVars.HIVE_SERVER2_ENABLE_DOAS) &&
+ (userName != null)) {
String delegationTokenStr = null;
try {
delegationTokenStr = cliService.getDelegationTokenFromMetaStore(userName);
@@ -420,4 +503,36 @@ public TFetchResultsResp FetchResults(TFetchResultsReq req) throws TException {
@Override
public abstract void run();
+
+ /**
+ * If the proxy user name is provided then check privileges to substitute the user.
+ * @param realUser
+ * @param sessionConf
+ * @param ipAddress
+ * @return
+ * @throws HiveSQLException
+ */
+ private String getProxyUser(String realUser, Map sessionConf,
+ String ipAddress) throws HiveSQLException {
+ if (sessionConf == null || !sessionConf.containsKey(HiveAuthFactory.HS2_PROXY_USER)) {
+ return realUser;
+ }
+
+ // Extract the proxy user name and check if we are allowed to do the substitution
+ String proxyUser = sessionConf.get(HiveAuthFactory.HS2_PROXY_USER);
+ if (!hiveConf.getBoolVar(HiveConf.ConfVars.HIVE_SERVER2_ALLOW_USER_SUBSTITUTION)) {
+ throw new HiveSQLException("Proxy user substitution is not allowed");
+ }
+
+ // If there's no authentication, then directly substitute the user
+ if (HiveAuthFactory.AuthTypes.NONE.toString().
+ equalsIgnoreCase(hiveConf.getVar(ConfVars.HIVE_SERVER2_AUTHENTICATION))) {
+ return proxyUser;
+ }
+
+ // Verify proxy user privilege of the realUser for the proxyUser
+ HiveAuthFactory.verifyProxyAccess(realUser, proxyUser, ipAddress, hiveConf);
+ return proxyUser;
+ }
}
+
diff --git service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIServiceClient.java service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIServiceClient.java
index 3675e86..e3384d3 100644
--- service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIServiceClient.java
+++ service/src/java/org/apache/hive/service/cli/thrift/ThriftCLIServiceClient.java
@@ -21,6 +21,7 @@
import java.util.List;
import java.util.Map;
+import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.cli.CLIServiceClient;
import org.apache.hive.service.cli.FetchOrientation;
import org.apache.hive.service.cli.GetInfoType;
@@ -33,6 +34,7 @@
import org.apache.hive.service.cli.RowSetFactory;
import org.apache.hive.service.cli.SessionHandle;
import org.apache.hive.service.cli.TableSchema;
+import org.apache.thrift.TException;
/**
* ThriftCLIServiceClient.
@@ -404,4 +406,48 @@ public RowSet fetchResults(OperationHandle opHandle) throws HiveSQLException {
// TODO: set the correct default fetch size
return fetchResults(opHandle, FetchOrientation.FETCH_NEXT, 10000);
}
+
+ @Override
+ public String getDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String owner, String renewer) throws HiveSQLException {
+ TGetDelegationTokenReq req = new TGetDelegationTokenReq(
+ sessionHandle.toTSessionHandle(), owner, renewer);
+ try {
+ TGetDelegationTokenResp tokenResp = cliService.GetDelegationToken(req);
+ checkStatus(tokenResp.getStatus());
+ return tokenResp.getDelegationToken();
+ } catch (Exception e) {
+ throw new HiveSQLException(e);
+ }
+ }
+
+ @Override
+ public void cancelDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException {
+ TCancelDelegationTokenReq cancelReq = new TCancelDelegationTokenReq(
+ sessionHandle.toTSessionHandle(), tokenStr);
+ try {
+ TCancelDelegationTokenResp cancelResp =
+ cliService.CancelDelegationToken(cancelReq);
+ checkStatus(cancelResp.getStatus());
+ return;
+ } catch (TException e) {
+ throw new HiveSQLException(e);
+ }
+ }
+
+ @Override
+ public void renewDelegationToken(SessionHandle sessionHandle, HiveAuthFactory authFactory,
+ String tokenStr) throws HiveSQLException {
+ TRenewDelegationTokenReq cancelReq = new TRenewDelegationTokenReq(
+ sessionHandle.toTSessionHandle(), tokenStr);
+ try {
+ TRenewDelegationTokenResp renewResp =
+ cliService.RenewDelegationToken(cancelReq);
+ checkStatus(renewResp.getStatus());
+ return;
+ } catch (Exception e) {
+ throw new HiveSQLException(e);
+ }
+ }
}
diff --git service/src/test/org/apache/hive/service/auth/TestPlainSaslHelper.java service/src/test/org/apache/hive/service/auth/TestPlainSaslHelper.java
index 8fa4afd..fb784aa 100644
--- service/src/test/org/apache/hive/service/auth/TestPlainSaslHelper.java
+++ service/src/test/org/apache/hive/service/auth/TestPlainSaslHelper.java
@@ -45,6 +45,6 @@ public void testDoAsSetting(){
tcliService.init(hconf);
TProcessorFactory procFactory = PlainSaslHelper.getPlainProcessorFactory(tcliService);
assertEquals("doAs enabled processor for unsecure mode",
- procFactory.getProcessor(null).getClass(), TUGIContainingProcessor.class);
+ procFactory.getProcessor(null).getClass(), TSetIpAddressProcessor.class);
}
}
diff --git service/src/test/org/apache/hive/service/cli/session/TestSessionHooks.java service/src/test/org/apache/hive/service/cli/session/TestSessionHooks.java
index 2fac800..49bc54b 100644
--- service/src/test/org/apache/hive/service/cli/session/TestSessionHooks.java
+++ service/src/test/org/apache/hive/service/cli/session/TestSessionHooks.java
@@ -19,12 +19,15 @@
package org.apache.hive.service.cli.session;
import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import junit.framework.Assert;
import junit.framework.TestCase;
import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
+import org.apache.hive.service.auth.HiveAuthFactory;
import org.apache.hive.service.cli.HiveSQLException;
import org.apache.hive.service.cli.SessionHandle;
import org.apache.hive.service.cli.thrift.EmbeddedThriftBinaryCLIService;
@@ -34,7 +37,7 @@
public class TestSessionHooks extends TestCase {
- public static final String SESSION_USER_NAME = "user1";
+ private static String sessionUserName = "user1";
private EmbeddedThriftBinaryCLIService service;
private ThriftCLIServiceClient client;
@@ -44,7 +47,7 @@
@Override
public void run(HiveSessionHookContext sessionHookContext) throws HiveSQLException {
- Assert.assertEquals(sessionHookContext.getSessionUser(), SESSION_USER_NAME);
+ Assert.assertEquals(sessionHookContext.getSessionUser(), sessionUserName);
String sessionHook = sessionHookContext.getSessionConf().
getVar(ConfVars.HIVE_SERVER2_SESSION_HOOK);
Assert.assertTrue(sessionHook.contains(this.getClass().getName()));
@@ -56,6 +59,7 @@ public void run(HiveSessionHookContext sessionHookContext) throws HiveSQLExcepti
@Before
public void setUp() throws Exception {
super.setUp();
+ SessionHookTest.runCount.set(0);
System.setProperty(ConfVars.HIVE_SERVER2_SESSION_HOOK.varname,
TestSessionHooks.SessionHookTest.class.getName());
service = new EmbeddedThriftBinaryCLIService();
@@ -65,9 +69,25 @@ public void setUp() throws Exception {
@Test
public void testSessionHook () throws Exception {
// create session, test if the hook got fired by checking the expected property
- SessionHandle sessionHandle = client.openSession(SESSION_USER_NAME, "foobar",
+ SessionHandle sessionHandle = client.openSession(sessionUserName, "foobar",
Collections.emptyMap());
Assert.assertEquals(1, SessionHookTest.runCount.get());
client.closeSession(sessionHandle);
}
+
+ /***
+ * Create session with proxy user property. Verify the effective session user
+ * @throws Exception
+ */
+ @Test
+ public void testProxyUser() throws Exception {
+ String connectingUser = "user1";
+ String proxyUser = System.getProperty("user.name");
+ MapsessConf = new HashMap();
+ sessConf.put(HiveAuthFactory.HS2_PROXY_USER, proxyUser);
+ sessionUserName = proxyUser;
+ SessionHandle sessionHandle = client.openSession(connectingUser, "foobar", sessConf);
+ Assert.assertEquals(1, SessionHookTest.runCount.get());
+ client.closeSession(sessionHandle);
+ }
}
diff --git shims/0.20/src/main/java/org/apache/hadoop/hive/shims/Hadoop20Shims.java shims/0.20/src/main/java/org/apache/hadoop/hive/shims/Hadoop20Shims.java
index 51c8051..b250963 100644
--- shims/0.20/src/main/java/org/apache/hadoop/hive/shims/Hadoop20Shims.java
+++ shims/0.20/src/main/java/org/apache/hadoop/hive/shims/Hadoop20Shims.java
@@ -556,6 +556,12 @@ public void setTokenStr(UserGroupInformation ugi, String tokenStr, String tokenS
}
@Override
+ public String addServiceToToken(String tokenStr, String tokenService) throws IOException {
+ throw new UnsupportedOperationException("Tokens are not supported in current hadoop version");
+ }
+
+
+ @Override
public T doAs(UserGroupInformation ugi, PrivilegedExceptionAction pvea) throws
IOException, InterruptedException {
try {
@@ -637,6 +643,11 @@ public void remove() {
}
@Override
+ public void authorizeProxyAccess(String proxyUser, UserGroupInformation realUserUgi,
+ String ipAddress, Configuration conf) throws IOException {
+ // This hadoop version doesn't have proxy verification
+ }
+
public boolean isSecurityEnabled() {
return false;
}
diff --git shims/common-secure/src/main/java/org/apache/hadoop/hive/shims/HadoopShimsSecure.java shims/common-secure/src/main/java/org/apache/hadoop/hive/shims/HadoopShimsSecure.java
index e205caa..d4cddda 100644
--- shims/common-secure/src/main/java/org/apache/hadoop/hive/shims/HadoopShimsSecure.java
+++ shims/common-secure/src/main/java/org/apache/hadoop/hive/shims/HadoopShimsSecure.java
@@ -64,6 +64,7 @@
import org.apache.hadoop.security.Credentials;
import org.apache.hadoop.security.SecurityUtil;
import org.apache.hadoop.security.UserGroupInformation;
+import org.apache.hadoop.security.authorize.ProxyUsers;
import org.apache.hadoop.security.token.Token;
import org.apache.hadoop.security.token.TokenIdentifier;
import org.apache.hadoop.security.token.TokenSelector;
@@ -459,12 +460,39 @@ public String getTokenStrForm(String tokenSignature) throws IOException {
return token != null ? token.encodeToUrlString() : null;
}
+ /**
+ * Create a delegation token object for the given token string and service.
+ * Add the token to given UGI
+ */
@Override
public void setTokenStr(UserGroupInformation ugi, String tokenStr, String tokenService) throws IOException {
+ Token delegationToken = createToken(tokenStr, tokenService);
+ ugi.addToken(delegationToken);
+ }
+
+ /**
+ * Add a given service to delegation token string.
+ */
+ @Override
+ public String addServiceToToken(String tokenStr, String tokenService)
+ throws IOException {
+ Token delegationToken = createToken(tokenStr, tokenService);
+ return delegationToken.encodeToUrlString();
+ }
+
+ /**
+ * Create a new token using the given string and service
+ * @param tokenStr
+ * @param tokenService
+ * @return
+ * @throws IOException
+ */
+ private Token createToken(String tokenStr, String tokenService)
+ throws IOException {
Token delegationToken = new Token();
delegationToken.decodeFromUrlString(tokenStr);
delegationToken.setService(new Text(tokenService));
- ugi.addToken(delegationToken);
+ return delegationToken;
}
@Override
@@ -498,6 +526,13 @@ public UserGroupInformation createProxyUser(String userName) throws IOException
}
@Override
+ public void authorizeProxyAccess(String proxyUser, UserGroupInformation realUserUgi,
+ String ipAddress, Configuration conf) throws IOException {
+ ProxyUsers.authorize(UserGroupInformation.createProxyUser(proxyUser, realUserUgi),
+ ipAddress, conf);
+ }
+
+ @Override
public boolean isSecurityEnabled() {
return UserGroupInformation.isSecurityEnabled();
}
diff --git shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/DelegationTokenSecretManager.java shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/DelegationTokenSecretManager.java
index 29114f0..19d1fbf 100644
--- shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/DelegationTokenSecretManager.java
+++ shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/DelegationTokenSecretManager.java
@@ -18,6 +18,8 @@
package org.apache.hadoop.hive.thrift;
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
import java.io.IOException;
import org.apache.hadoop.io.Text;
@@ -83,5 +85,16 @@ public synchronized String getDelegationToken(String renewer) throws IOException
ident, this);
return t.encodeToUrlString();
}
+
+ public String getUserFromToken(String tokenStr) throws IOException {
+ Token delegationToken = new Token();
+ delegationToken.decodeFromUrlString(tokenStr);
+
+ ByteArrayInputStream buf = new ByteArrayInputStream(delegationToken.getIdentifier());
+ DataInputStream in = new DataInputStream(buf);
+ DelegationTokenIdentifier id = createIdentifier();
+ id.readFields(in);
+ return id.getUser().getShortUserName();
+ }
}
diff --git shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge20S.java shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge20S.java
index dc89de1..e3f3e38 100644
--- shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge20S.java
+++ shims/common-secure/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge20S.java
@@ -43,6 +43,7 @@
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.hive.shims.ShimLoader;
import org.apache.hadoop.hive.thrift.client.TUGIAssumingTransport;
import org.apache.hadoop.security.SaslRpcServer;
import org.apache.hadoop.security.SaslRpcServer.AuthMethod;
@@ -401,6 +402,13 @@ public String run() throws IOException {
}
@Override
+ public String getDelegationTokenWithService(String owner, String renewer, String service)
+ throws IOException, InterruptedException {
+ String token = getDelegationToken(owner, renewer);
+ return ShimLoader.getHadoopShims().addServiceToToken(token, service);
+ }
+
+ @Override
public long renewDelegationToken(String tokenStrForm) throws IOException {
if (!authenticationMethod.get().equals(AuthenticationMethod.KERBEROS)) {
throw new AuthorizationException(
@@ -412,6 +420,11 @@ public long renewDelegationToken(String tokenStrForm) throws IOException {
}
@Override
+ public String getUserFromToken(String tokenStr) throws IOException {
+ return secretManager.getUserFromToken(tokenStr);
+ }
+
+ @Override
public void cancelDelegationToken(String tokenStrForm) throws IOException {
secretManager.cancelDelegationToken(tokenStrForm);
}
diff --git shims/common/src/main/java/org/apache/hadoop/hive/shims/HadoopShims.java shims/common/src/main/java/org/apache/hadoop/hive/shims/HadoopShims.java
index e15ab4e..1f24a94 100644
--- shims/common/src/main/java/org/apache/hadoop/hive/shims/HadoopShims.java
+++ shims/common/src/main/java/org/apache/hadoop/hive/shims/HadoopShims.java
@@ -230,7 +230,7 @@ public URI getHarUri(URI original, URI base, URI originalBase)
* @return the string form of the token found
* @throws IOException
*/
- String getTokenStrForm(String tokenSignature) throws IOException;
+ public String getTokenStrForm(String tokenSignature) throws IOException;
/**
* Add a delegation token to the given ugi
@@ -239,9 +239,18 @@ public URI getHarUri(URI original, URI base, URI originalBase)
* @param tokenService
* @throws IOException
*/
- void setTokenStr(UserGroupInformation ugi, String tokenStr, String tokenService)
+ public void setTokenStr(UserGroupInformation ugi, String tokenStr, String tokenService)
throws IOException;
+ /**
+ * Add given service to the string format token
+ * @param tokenStr
+ * @param tokenService
+ * @return
+ * @throws IOException
+ */
+ public String addServiceToToken(String tokenStr, String tokenService)
+ throws IOException;
enum JobTrackerState { INITIALIZING, RUNNING };
@@ -347,7 +356,14 @@ public boolean moveToAppropriateTrash(FileSystem fs, Path path, Configuration co
* @param userName
* @return
*/
- UserGroupInformation createProxyUser(String userName) throws IOException;
+ public UserGroupInformation createProxyUser(String userName) throws IOException;
+
+ /**
+ * Verify proxy access to given UGI for given user
+ * @param ugi
+ */
+ public void authorizeProxyAccess(String proxyUser, UserGroupInformation realUserUgi,
+ String ipAddress, Configuration conf) throws IOException;
/**
* The method sets to set the partition file has a different signature between
diff --git shims/common/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge.java shims/common/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge.java
index 03f4e51..e69373a 100644
--- shims/common/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge.java
+++ shims/common/src/main/java/org/apache/hadoop/hive/thrift/HadoopThriftAuthBridge.java
@@ -91,11 +91,14 @@ public abstract TTransport createClientTransport(
public abstract InetAddress getRemoteAddress();
public abstract void startDelegationTokenSecretManager(Configuration conf,
Object hmsHandler) throws IOException;
- public abstract String getRemoteUser();
public abstract String getDelegationToken(String owner, String renewer)
- throws IOException, InterruptedException;
+ throws IOException, InterruptedException;
+ public abstract String getDelegationTokenWithService(String owner, String renewer, String service)
+ throws IOException, InterruptedException;
+ public abstract String getRemoteUser();
public abstract long renewDelegationToken(String tokenStrForm) throws IOException;
public abstract void cancelDelegationToken(String tokenStrForm) throws IOException;
+ public abstract String getUserFromToken(String tokenStr) throws IOException;
}
}