FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
index 0da1acf..ac8d8a4 100644
--- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
+++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py
@@ -954,6 +954,56 @@ class Iface(fb303.FacebookService.Iface):
      """
      pass

+ def add_token(self, token_identifier, delegation_token):
+ """
+ Parameters:
+ - token_identifier
+ - delegation_token
+ """
+ pass
+
+ def remove_token(self, token_identifier):
+ """
+ Parameters:
+ - token_identifier
+ """
+ pass
+
+ def get_token(self, token_identifier):
+ """
+ Parameters:
+ - token_identifier
+ """
+ pass
+
+ def get_all_token_identifiers(self):
+ pass
+
+ def add_master_key(self, key):
+ """
+ Parameters:
+ - key
+ """
+ pass
+
+ def update_master_key(self, seq_number, key):
+ """
+ Parameters:
+ - seq_number
+ - key
+ """
+ pass
+
+ def remove_master_key(self, key_seq):
+ """
+ Parameters:
+ - key_seq
+ """
+ pass
+
+ def get_master_keys(self):
+ pass
+
    def get_open_txns(self):
      pass

@@ -5306,6 +5356,252 @@ class Client(fb303.FacebookService.Client, Iface):
        raise result.o1
      return

+ def add_token(self, token_identifier, delegation_token):
+ """
+ Parameters:
+ - token_identifier
+ - delegation_token
+ """
+ self.send_add_token(token_identifier, delegation_token)
+ return self.recv_add_token()
+
+ def send_add_token(self, token_identifier, delegation_token):
+ self._oprot.writeMessageBegin('add_token', TMessageType.CALL, self._seqid)
+ args = add_token_args()
+ args.token_identifier = token_identifier
+ args.delegation_token = delegation_token
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_add_token(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = add_token_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "add_token failed: unknown result")
+
+ def remove_token(self, token_identifier):
+ """
+ Parameters:
+ - token_identifier
+ """
+ self.send_remove_token(token_identifier)
+ return self.recv_remove_token()
+
+ def send_remove_token(self, token_identifier):
+ self._oprot.writeMessageBegin('remove_token', TMessageType.CALL, self._seqid)
+ args = remove_token_args()
+ args.token_identifier = token_identifier
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_remove_token(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = remove_token_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "remove_token failed: unknown result")
+
+ def get_token(self, token_identifier):
+ """
+ Parameters:
+ - token_identifier
+ """
+ self.send_get_token(token_identifier)
+ return self.recv_get_token()
+
+ def send_get_token(self, token_identifier):
+ self._oprot.writeMessageBegin('get_token', TMessageType.CALL, self._seqid)
+ args = get_token_args()
+ args.token_identifier = token_identifier
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_get_token(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = get_token_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "get_token failed: unknown result")
+
+ def get_all_token_identifiers(self):
+ self.send_get_all_token_identifiers()
+ return self.recv_get_all_token_identifiers()
+
+ def send_get_all_token_identifiers(self):
+ self._oprot.writeMessageBegin('get_all_token_identifiers', TMessageType.CALL, self._seqid)
+ args = get_all_token_identifiers_args()
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_get_all_token_identifiers(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = get_all_token_identifiers_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "get_all_token_identifiers failed: unknown result")
+
+ def add_master_key(self, key):
+ """
+ Parameters:
+ - key
+ """
+ self.send_add_master_key(key)
+ return self.recv_add_master_key()
+
+ def send_add_master_key(self, key):
+ self._oprot.writeMessageBegin('add_master_key', TMessageType.CALL, self._seqid)
+ args = add_master_key_args()
+ args.key = key
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_add_master_key(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = add_master_key_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ if result.o1 is not None:
+ raise result.o1
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "add_master_key failed: unknown result")
+
+ def update_master_key(self, seq_number, key):
+ """
+ Parameters:
+ - seq_number
+ - key
+ """
+ self.send_update_master_key(seq_number, key)
+ self.recv_update_master_key()
+
+ def send_update_master_key(self, seq_number, key):
+ self._oprot.writeMessageBegin('update_master_key', TMessageType.CALL, self._seqid)
+ args = update_master_key_args()
+ args.seq_number = seq_number
+ args.key = key
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_update_master_key(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = update_master_key_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.o1 is not None:
+ raise result.o1
+ if result.o2 is not None:
+ raise result.o2
+ return
+
+ def remove_master_key(self, key_seq):
+ """
+ Parameters:
+ - key_seq
+ """
+ self.send_remove_master_key(key_seq)
+ return self.recv_remove_master_key()
+
+ def send_remove_master_key(self, key_seq):
+ self._oprot.writeMessageBegin('remove_master_key', TMessageType.CALL, self._seqid)
+ args = remove_master_key_args()
+ args.key_seq = key_seq
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_remove_master_key(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = remove_master_key_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "remove_master_key failed: unknown result")
+
+ def get_master_keys(self):
+ self.send_get_master_keys()
+ return self.recv_get_master_keys()
+
+ def send_get_master_keys(self):
+ self._oprot.writeMessageBegin('get_master_keys', TMessageType.CALL, self._seqid)
+ args = get_master_keys_args()
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_get_master_keys(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = get_master_keys_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "get_master_keys failed: unknown result")
+
    def get_open_txns(self):
      self.send_get_open_txns()
      return self.recv_get_open_txns()
@@ -6161,6 +6457,14 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
      self._processMap["get_delegation_token"] = Processor.process_get_delegation_token
      self._processMap["renew_delegation_token"] = Processor.process_renew_delegation_token
      self._processMap["cancel_delegation_token"] = Processor.process_cancel_delegation_token
+ self._processMap["add_token"] = Processor.process_add_token
+ self._processMap["remove_token"] = Processor.process_remove_token
+ self._processMap["get_token"] = Processor.process_get_token
+ self._processMap["get_all_token_identifiers"] = Processor.process_get_all_token_identifiers
+ self._processMap["add_master_key"] = Processor.process_add_master_key
+ self._processMap["update_master_key"] = Processor.process_update_master_key
+ self._processMap["remove_master_key"] = Processor.process_remove_master_key
+ self._processMap["get_master_keys"] = Processor.process_get_master_keys
      self._processMap["get_open_txns"] = Processor.process_get_open_txns
      self._processMap["get_open_txns_info"] = Processor.process_get_open_txns_info
      self._processMap["open_txns"] = Processor.process_open_txns
@@ -9027,13 +9331,13 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_get_open_txns(self, seqid, iprot, oprot):
- args = get_open_txns_args()
+ def process_add_token(self, seqid, iprot, oprot):
+ args = add_token_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = get_open_txns_result()
+ result = add_token_result()
      try:
- result.success = self._handler.get_open_txns()
+ result.success = self._handler.add_token(args.token_identifier, args.delegation_token)
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
@@ -9041,18 +9345,18 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("get_open_txns", msg_type, seqid)
+ oprot.writeMessageBegin("add_token", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_get_open_txns_info(self, seqid, iprot, oprot):
- args = get_open_txns_info_args()
+ def process_remove_token(self, seqid, iprot, oprot):
+ args = remove_token_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = get_open_txns_info_result()
+ result = remove_token_result()
      try:
- result.success = self._handler.get_open_txns_info()
+ result.success = self._handler.remove_token(args.token_identifier)
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
@@ -9060,18 +9364,18 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("get_open_txns_info", msg_type, seqid)
+ oprot.writeMessageBegin("remove_token", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_open_txns(self, seqid, iprot, oprot):
- args = open_txns_args()
+ def process_get_token(self, seqid, iprot, oprot):
+ args = get_token_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = open_txns_result()
+ result = get_token_result()
      try:
- result.success = self._handler.open_txns(args.rqst)
+ result.success = self._handler.get_token(args.token_identifier)
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
@@ -9079,112 +9383,273 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor):
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("open_txns", msg_type, seqid)
+ oprot.writeMessageBegin("get_token", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_abort_txn(self, seqid, iprot, oprot):
- args = abort_txn_args()
+ def process_get_all_token_identifiers(self, seqid, iprot, oprot):
+ args = get_all_token_identifiers_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = abort_txn_result()
+ result = get_all_token_identifiers_result()
      try:
- self._handler.abort_txn(args.rqst)
+ result.success = self._handler.get_all_token_identifiers()
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
- except NoSuchTxnException as o1:
- msg_type = TMessageType.REPLY
- result.o1 = o1
      except Exception as ex:
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("abort_txn", msg_type, seqid)
+ oprot.writeMessageBegin("get_all_token_identifiers", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_commit_txn(self, seqid, iprot, oprot):
- args = commit_txn_args()
+ def process_add_master_key(self, seqid, iprot, oprot):
+ args = add_master_key_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = commit_txn_result()
+ result = add_master_key_result()
      try:
- self._handler.commit_txn(args.rqst)
+ result.success = self._handler.add_master_key(args.key)
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
- except NoSuchTxnException as o1:
+ except MetaException as o1:
        msg_type = TMessageType.REPLY
        result.o1 = o1
- except TxnAbortedException as o2:
- msg_type = TMessageType.REPLY
- result.o2 = o2
      except Exception as ex:
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("commit_txn", msg_type, seqid)
+ oprot.writeMessageBegin("add_master_key", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_lock(self, seqid, iprot, oprot):
- args = lock_args()
+ def process_update_master_key(self, seqid, iprot, oprot):
+ args = update_master_key_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = lock_result()
+ result = update_master_key_result()
      try:
- result.success = self._handler.lock(args.rqst)
+ self._handler.update_master_key(args.seq_number, args.key)
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
- except NoSuchTxnException as o1:
+ except NoSuchObjectException as o1:
        msg_type = TMessageType.REPLY
        result.o1 = o1
- except TxnAbortedException as o2:
+ except MetaException as o2:
        msg_type = TMessageType.REPLY
        result.o2 = o2
      except Exception as ex:
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("lock", msg_type, seqid)
+ oprot.writeMessageBegin("update_master_key", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_check_lock(self, seqid, iprot, oprot):
- args = check_lock_args()
+ def process_remove_master_key(self, seqid, iprot, oprot):
+ args = remove_master_key_args()
      args.read(iprot)
      iprot.readMessageEnd()
- result = check_lock_result()
+ result = remove_master_key_result()
      try:
- result.success = self._handler.check_lock(args.rqst)
+ result.success = self._handler.remove_master_key(args.key_seq)
        msg_type = TMessageType.REPLY
      except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
        raise
- except NoSuchTxnException as o1:
- msg_type = TMessageType.REPLY
- result.o1 = o1
- except TxnAbortedException as o2:
- msg_type = TMessageType.REPLY
- result.o2 = o2
- except NoSuchLockException as o3:
- msg_type = TMessageType.REPLY
- result.o3 = o3
      except Exception as ex:
        msg_type = TMessageType.EXCEPTION
        logging.exception(ex)
        result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
- oprot.writeMessageBegin("check_lock", msg_type, seqid)
+ oprot.writeMessageBegin("remove_master_key", msg_type, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()

- def process_unlock(self, seqid, iprot, oprot):
+ def process_get_master_keys(self, seqid, iprot, oprot):
+ args = get_master_keys_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = get_master_keys_result()
+ try:
+ result.success = self._handler.get_master_keys()
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("get_master_keys", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_get_open_txns(self, seqid, iprot, oprot):
+ args = get_open_txns_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = get_open_txns_result()
+ try:
+ result.success = self._handler.get_open_txns()
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("get_open_txns", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_get_open_txns_info(self, seqid, iprot, oprot):
+ args = get_open_txns_info_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = get_open_txns_info_result()
+ try:
+ result.success = self._handler.get_open_txns_info()
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("get_open_txns_info", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_open_txns(self, seqid, iprot, oprot):
+ args = open_txns_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = open_txns_result()
+ try:
+ result.success = self._handler.open_txns(args.rqst)
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("open_txns", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_abort_txn(self, seqid, iprot, oprot):
+ args = abort_txn_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = abort_txn_result()
+ try:
+ self._handler.abort_txn(args.rqst)
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except NoSuchTxnException as o1:
+ msg_type = TMessageType.REPLY
+ result.o1 = o1
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("abort_txn", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_commit_txn(self, seqid, iprot, oprot):
+ args = commit_txn_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = commit_txn_result()
+ try:
+ self._handler.commit_txn(args.rqst)
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except NoSuchTxnException as o1:
+ msg_type = TMessageType.REPLY
+ result.o1 = o1
+ except TxnAbortedException as o2:
+ msg_type = TMessageType.REPLY
+ result.o2 = o2
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("commit_txn", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_lock(self, seqid, iprot, oprot):
+ args = lock_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = lock_result()
+ try:
+ result.success = self._handler.lock(args.rqst)
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except NoSuchTxnException as o1:
+ msg_type = TMessageType.REPLY
+ result.o1 = o1
+ except TxnAbortedException as o2:
+ msg_type = TMessageType.REPLY
+ result.o2 = o2
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("lock", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_check_lock(self, seqid, iprot, oprot):
+ args = check_lock_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = check_lock_result()
+ try:
+ result.success = self._handler.check_lock(args.rqst)
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except NoSuchTxnException as o1:
+ msg_type = TMessageType.REPLY
+ result.o1 = o1
+ except TxnAbortedException as o2:
+ msg_type = TMessageType.REPLY
+ result.o2 = o2
+ except NoSuchLockException as o3:
+ msg_type = TMessageType.REPLY
+ result.o3 = o3
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("check_lock", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_unlock(self, seqid, iprot, oprot):
      args = unlock_args()
      args.read(iprot)
      iprot.readMessageEnd()
@@ -29618,6 +30083,1072 @@ class cancel_delegation_token_result:
    def __ne__(self, other):
      return not (self == other)

+class add_token_args:
+ """
+ Attributes:
+ - token_identifier
+ - delegation_token
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'token_identifier', None, None, ), # 1
+ (2, TType.STRING, 'delegation_token', None, None, ), # 2
+ )
+
+ def __init__(self, token_identifier=None, delegation_token=None,):
+ self.token_identifier = token_identifier
+ self.delegation_token = delegation_token
+
+ 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.STRING:
+ self.token_identifier = iprot.readString()
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.delegation_token = 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('add_token_args')
+ if self.token_identifier is not None:
+ oprot.writeFieldBegin('token_identifier', TType.STRING, 1)
+ oprot.writeString(self.token_identifier)
+ oprot.writeFieldEnd()
+ if self.delegation_token is not None:
+ oprot.writeFieldBegin('delegation_token', TType.STRING, 2)
+ oprot.writeString(self.delegation_token)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.token_identifier)
+ value = (value * 31) ^ hash(self.delegation_token)
+ return value
+
+ 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 add_token_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.BOOL, 'success', None, 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.BOOL:
+ self.success = iprot.readBool()
+ 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('add_token_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.BOOL, 0)
+ oprot.writeBool(self.success)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ 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 remove_token_args:
+ """
+ Attributes:
+ - token_identifier
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'token_identifier', None, None, ), # 1
+ )
+
+ def __init__(self, token_identifier=None,):
+ self.token_identifier = token_identifier
+
+ 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.STRING:
+ self.token_identifier = 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('remove_token_args')
+ if self.token_identifier is not None:
+ oprot.writeFieldBegin('token_identifier', TType.STRING, 1)
+ oprot.writeString(self.token_identifier)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.token_identifier)
+ return value
+
+ 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 remove_token_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.BOOL, 'success', None, 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.BOOL:
+ self.success = iprot.readBool()
+ 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('remove_token_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.BOOL, 0)
+ oprot.writeBool(self.success)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ 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 get_token_args:
+ """
+ Attributes:
+ - token_identifier
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'token_identifier', None, None, ), # 1
+ )
+
+ def __init__(self, token_identifier=None,):
+ self.token_identifier = token_identifier
+
+ 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.STRING:
+ self.token_identifier = 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('get_token_args')
+ if self.token_identifier is not None:
+ oprot.writeFieldBegin('token_identifier', TType.STRING, 1)
+ oprot.writeString(self.token_identifier)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.token_identifier)
+ return value
+
+ 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 get_token_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.STRING, 'success', None, 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.STRING:
+ self.success = 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('get_token_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRING, 0)
+ oprot.writeString(self.success)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ 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 get_all_token_identifiers_args:
+
+ thrift_spec = (
+ )
+
+ 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
+ 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('get_all_token_identifiers_args')
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ return value
+
+ 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 get_all_token_identifiers_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.LIST, 'success', (TType.STRING,None), 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.LIST:
+ self.success = []
+ (_etype950, _size947) = iprot.readListBegin()
+ for _i951 in xrange(_size947):
+ _elem952 = iprot.readString()
+ self.success.append(_elem952)
+ iprot.readListEnd()
+ 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('get_all_token_identifiers_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.LIST, 0)
+ oprot.writeListBegin(TType.STRING, len(self.success))
+ for iter953 in self.success:
+ oprot.writeString(iter953)
+ oprot.writeListEnd()
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ 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 add_master_key_args:
+ """
+ Attributes:
+ - key
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRING, 'key', None, None, ), # 1
+ )
+
+ def __init__(self, key=None,):
+ self.key = key
+
+ 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.STRING:
+ self.key = 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('add_master_key_args')
+ if self.key is not None:
+ oprot.writeFieldBegin('key', TType.STRING, 1)
+ oprot.writeString(self.key)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.key)
+ return value
+
+ 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 add_master_key_result:
+ """
+ Attributes:
+ - success
+ - o1
+ """
+
+ thrift_spec = (
+ (0, TType.I32, 'success', None, None, ), # 0
+ (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, success=None, o1=None,):
+ self.success = success
+ self.o1 = o1
+
+ 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.I32:
+ self.success = iprot.readI32()
+ else:
+ iprot.skip(ftype)
+ elif fid == 1:
+ if ftype == TType.STRUCT:
+ self.o1 = MetaException()
+ self.o1.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('add_master_key_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.I32, 0)
+ oprot.writeI32(self.success)
+ oprot.writeFieldEnd()
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ value = (value * 31) ^ hash(self.o1)
+ return value
+
+ 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 update_master_key_args:
+ """
+ Attributes:
+ - seq_number
+ - key
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.I32, 'seq_number', None, None, ), # 1
+ (2, TType.STRING, 'key', None, None, ), # 2
+ )
+
+ def __init__(self, seq_number=None, key=None,):
+ self.seq_number = seq_number
+ self.key = key
+
+ 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.I32:
+ self.seq_number = iprot.readI32()
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.key = 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('update_master_key_args')
+ if self.seq_number is not None:
+ oprot.writeFieldBegin('seq_number', TType.I32, 1)
+ oprot.writeI32(self.seq_number)
+ oprot.writeFieldEnd()
+ if self.key is not None:
+ oprot.writeFieldBegin('key', TType.STRING, 2)
+ oprot.writeString(self.key)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.seq_number)
+ value = (value * 31) ^ hash(self.key)
+ return value
+
+ 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 update_master_key_result:
+ """
+ Attributes:
+ - o1
+ - o2
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1
+ (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2
+ )
+
+ def __init__(self, o1=None, o2=None,):
+ self.o1 = o1
+ self.o2 = o2
+
+ 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.o1 = NoSuchObjectException()
+ self.o1.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRUCT:
+ self.o2 = MetaException()
+ self.o2.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('update_master_key_result')
+ if self.o1 is not None:
+ oprot.writeFieldBegin('o1', TType.STRUCT, 1)
+ self.o1.write(oprot)
+ oprot.writeFieldEnd()
+ if self.o2 is not None:
+ oprot.writeFieldBegin('o2', TType.STRUCT, 2)
+ self.o2.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.o1)
+ value = (value * 31) ^ hash(self.o2)
+ return value
+
+ 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 remove_master_key_args:
+ """
+ Attributes:
+ - key_seq
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.I32, 'key_seq', None, None, ), # 1
+ )
+
+ def __init__(self, key_seq=None,):
+ self.key_seq = key_seq
+
+ 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.I32:
+ self.key_seq = iprot.readI32()
+ 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('remove_master_key_args')
+ if self.key_seq is not None:
+ oprot.writeFieldBegin('key_seq', TType.I32, 1)
+ oprot.writeI32(self.key_seq)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.key_seq)
+ return value
+
+ 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 remove_master_key_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.BOOL, 'success', None, 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.BOOL:
+ self.success = iprot.readBool()
+ 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('remove_master_key_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.BOOL, 0)
+ oprot.writeBool(self.success)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ 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 get_master_keys_args:
+
+ thrift_spec = (
+ )
+
+ 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
+ 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('get_master_keys_args')
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ return value
+
+ 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 get_master_keys_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.LIST, 'success', (TType.STRING,None), 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.LIST:
+ self.success = []
+ (_etype957, _size954) = iprot.readListBegin()
+ for _i958 in xrange(_size954):
+ _elem959 = iprot.readString()
+ self.success.append(_elem959)
+ iprot.readListEnd()
+ 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('get_master_keys_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.LIST, 0)
+ oprot.writeListBegin(TType.STRING, len(self.success))
+ for iter960 in self.success:
+ oprot.writeString(iter960)
+ oprot.writeListEnd()
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ 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 get_open_txns_args:

    thrift_spec = (

http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb
index de316ae..e782bb5 100644
--- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb
+++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb
@@ -1894,6 +1894,128 @@ module ThriftHiveMetastore
        return
      end

+ def add_token(token_identifier, delegation_token)
+ send_add_token(token_identifier, delegation_token)
+ return recv_add_token()
+ end
+
+ def send_add_token(token_identifier, delegation_token)
+ send_message('add_token', Add_token_args, :token_identifier => token_identifier, :delegation_token => delegation_token)
+ end
+
+ def recv_add_token()
+ result = receive_message(Add_token_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'add_token failed: unknown result')
+ end
+
+ def remove_token(token_identifier)
+ send_remove_token(token_identifier)
+ return recv_remove_token()
+ end
+
+ def send_remove_token(token_identifier)
+ send_message('remove_token', Remove_token_args, :token_identifier => token_identifier)
+ end
+
+ def recv_remove_token()
+ result = receive_message(Remove_token_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'remove_token failed: unknown result')
+ end
+
+ def get_token(token_identifier)
+ send_get_token(token_identifier)
+ return recv_get_token()
+ end
+
+ def send_get_token(token_identifier)
+ send_message('get_token', Get_token_args, :token_identifier => token_identifier)
+ end
+
+ def recv_get_token()
+ result = receive_message(Get_token_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_token failed: unknown result')
+ end
+
+ def get_all_token_identifiers()
+ send_get_all_token_identifiers()
+ return recv_get_all_token_identifiers()
+ end
+
+ def send_get_all_token_identifiers()
+ send_message('get_all_token_identifiers', Get_all_token_identifiers_args)
+ end
+
+ def recv_get_all_token_identifiers()
+ result = receive_message(Get_all_token_identifiers_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_all_token_identifiers failed: unknown result')
+ end
+
+ def add_master_key(key)
+ send_add_master_key(key)
+ return recv_add_master_key()
+ end
+
+ def send_add_master_key(key)
+ send_message('add_master_key', Add_master_key_args, :key => key)
+ end
+
+ def recv_add_master_key()
+ result = receive_message(Add_master_key_result)
+ return result.success unless result.success.nil?
+ raise result.o1 unless result.o1.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'add_master_key failed: unknown result')
+ end
+
+ def update_master_key(seq_number, key)
+ send_update_master_key(seq_number, key)
+ recv_update_master_key()
+ end
+
+ def send_update_master_key(seq_number, key)
+ send_message('update_master_key', Update_master_key_args, :seq_number => seq_number, :key => key)
+ end
+
+ def recv_update_master_key()
+ result = receive_message(Update_master_key_result)
+ raise result.o1 unless result.o1.nil?
+ raise result.o2 unless result.o2.nil?
+ return
+ end
+
+ def remove_master_key(key_seq)
+ send_remove_master_key(key_seq)
+ return recv_remove_master_key()
+ end
+
+ def send_remove_master_key(key_seq)
+ send_message('remove_master_key', Remove_master_key_args, :key_seq => key_seq)
+ end
+
+ def recv_remove_master_key()
+ result = receive_message(Remove_master_key_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'remove_master_key failed: unknown result')
+ end
+
+ def get_master_keys()
+ send_get_master_keys()
+ return recv_get_master_keys()
+ end
+
+ def send_get_master_keys()
+ send_message('get_master_keys', Get_master_keys_args)
+ end
+
+ def recv_get_master_keys()
+ result = receive_message(Get_master_keys_result)
+ return result.success unless result.success.nil?
+ raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_master_keys failed: unknown result')
+ end
+
      def get_open_txns()
        send_get_open_txns()
        return recv_get_open_txns()
@@ -3744,6 +3866,72 @@ module ThriftHiveMetastore
        write_result(result, oprot, 'cancel_delegation_token', seqid)
      end

+ def process_add_token(seqid, iprot, oprot)
+ args = read_args(iprot, Add_token_args)
+ result = Add_token_result.new()
+ result.success = @handler.add_token(args.token_identifier, args.delegation_token)
+ write_result(result, oprot, 'add_token', seqid)
+ end
+
+ def process_remove_token(seqid, iprot, oprot)
+ args = read_args(iprot, Remove_token_args)
+ result = Remove_token_result.new()
+ result.success = @handler.remove_token(args.token_identifier)
+ write_result(result, oprot, 'remove_token', seqid)
+ end
+
+ def process_get_token(seqid, iprot, oprot)
+ args = read_args(iprot, Get_token_args)
+ result = Get_token_result.new()
+ result.success = @handler.get_token(args.token_identifier)
+ write_result(result, oprot, 'get_token', seqid)
+ end
+
+ def process_get_all_token_identifiers(seqid, iprot, oprot)
+ args = read_args(iprot, Get_all_token_identifiers_args)
+ result = Get_all_token_identifiers_result.new()
+ result.success = @handler.get_all_token_identifiers()
+ write_result(result, oprot, 'get_all_token_identifiers', seqid)
+ end
+
+ def process_add_master_key(seqid, iprot, oprot)
+ args = read_args(iprot, Add_master_key_args)
+ result = Add_master_key_result.new()
+ begin
+ result.success = @handler.add_master_key(args.key)
+ rescue ::MetaException => o1
+ result.o1 = o1
+ end
+ write_result(result, oprot, 'add_master_key', seqid)
+ end
+
+ def process_update_master_key(seqid, iprot, oprot)
+ args = read_args(iprot, Update_master_key_args)
+ result = Update_master_key_result.new()
+ begin
+ @handler.update_master_key(args.seq_number, args.key)
+ rescue ::NoSuchObjectException => o1
+ result.o1 = o1
+ rescue ::MetaException => o2
+ result.o2 = o2
+ end
+ write_result(result, oprot, 'update_master_key', seqid)
+ end
+
+ def process_remove_master_key(seqid, iprot, oprot)
+ args = read_args(iprot, Remove_master_key_args)
+ result = Remove_master_key_result.new()
+ result.success = @handler.remove_master_key(args.key_seq)
+ write_result(result, oprot, 'remove_master_key', seqid)
+ end
+
+ def process_get_master_keys(seqid, iprot, oprot)
+ args = read_args(iprot, Get_master_keys_args)
+ result = Get_master_keys_result.new()
+ result.success = @handler.get_master_keys()
+ write_result(result, oprot, 'get_master_keys', seqid)
+ end
+
      def process_get_open_txns(seqid, iprot, oprot)
        args = read_args(iprot, Get_open_txns_args)
        result = Get_open_txns_result.new()
@@ -8296,6 +8484,268 @@ module ThriftHiveMetastore
      ::Thrift::Struct.generate_accessors self
    end

+ class Add_token_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ TOKEN_IDENTIFIER = 1
+ DELEGATION_TOKEN = 2
+
+ FIELDS = {
+ TOKEN_IDENTIFIER => {:type => ::Thrift::Types::STRING, :name => 'token_identifier'},
+ DELEGATION_TOKEN => {:type => ::Thrift::Types::STRING, :name => 'delegation_token'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Add_token_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Remove_token_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ TOKEN_IDENTIFIER = 1
+
+ FIELDS = {
+ TOKEN_IDENTIFIER => {:type => ::Thrift::Types::STRING, :name => 'token_identifier'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Remove_token_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Get_token_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ TOKEN_IDENTIFIER = 1
+
+ FIELDS = {
+ TOKEN_IDENTIFIER => {:type => ::Thrift::Types::STRING, :name => 'token_identifier'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Get_token_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Get_all_token_identifiers_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+
+ FIELDS = {
+
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Get_all_token_identifiers_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRING}}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Add_master_key_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ KEY = 1
+
+ FIELDS = {
+ KEY => {:type => ::Thrift::Types::STRING, :name => 'key'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Add_master_key_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+ O1 = 1
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::I32, :name => 'success'},
+ O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Update_master_key_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SEQ_NUMBER = 1
+ KEY = 2
+
+ FIELDS = {
+ SEQ_NUMBER => {:type => ::Thrift::Types::I32, :name => 'seq_number'},
+ KEY => {:type => ::Thrift::Types::STRING, :name => 'key'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Update_master_key_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ O1 = 1
+ O2 = 2
+
+ FIELDS = {
+ O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException},
+ O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Remove_master_key_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ KEY_SEQ = 1
+
+ FIELDS = {
+ KEY_SEQ => {:type => ::Thrift::Types::I32, :name => 'key_seq'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Remove_master_key_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Get_master_keys_args
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+
+ FIELDS = {
+
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
+ class Get_master_keys_result
+ include ::Thrift::Struct, ::Thrift::Struct_Union
+ SUCCESS = 0
+
+ FIELDS = {
+ SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRING}}
+ }
+
+ def struct_fields; FIELDS; end
+
+ def validate
+ end
+
+ ::Thrift::Struct.generate_accessors self
+ end
+
    class Get_open_txns_args
      include ::Thrift::Struct, ::Thrift::Struct_Union


http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
----------------------------------------------------------------------
diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
index 50b38fa..0e8a157 100644
--- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
+++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
@@ -5271,6 +5271,165 @@ public class HiveMetaStore extends ThriftHiveMetastore {
      }

      @Override
+ public boolean add_token(String token_identifier, String delegation_token) throws TException {
+ startFunction("add_token", ": " + token_identifier);
+ boolean ret = false;
+ Exception ex = null;
+ try {
+ ret = getMS().addToken(token_identifier, delegation_token);
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("add_token", ret == true, ex);
+ }
+ return ret;
+ }
+
+ @Override
+ public boolean remove_token(String token_identifier) throws TException {
+ startFunction("remove_token", ": " + token_identifier);
+ boolean ret = false;
+ Exception ex = null;
+ try {
+ ret = getMS().removeToken(token_identifier);
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("remove_token", ret == true, ex);
+ }
+ return ret;
+ }
+
+ @Override
+ public String get_token(String token_identifier) throws TException {
+ startFunction("get_token for", ": " + token_identifier);
+ String ret = null;
+ Exception ex = null;
+ try {
+ ret = getMS().getToken(token_identifier);
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("get_token", ret != null, ex);
+ }
+ return ret;
+ }
+
+ @Override
+ public List<String> get_all_token_identifiers() throws TException {
+ startFunction("get_all_token_identifiers.");
+ List<String> ret = null;
+ Exception ex = null;
+ try {
+ ret = getMS().getAllTokenIdentifiers();
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("get_all_token_identifiers.", ex == null, ex);
+ }
+ return ret;
+ }
+
+ @Override
+ public int add_master_key(String key) throws MetaException, TException {
+ startFunction("add_master_key.");
+ int ret = -1;
+ Exception ex = null;
+ try {
+ ret = getMS().addMasterKey(key);
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("add_master_key.", ex == null, ex);
+ }
+ return ret;
+ }
+
+ @Override
+ public void update_master_key(int seq_number, String key) throws NoSuchObjectException,
+ MetaException, TException {
+ startFunction("update_master_key.");
+ Exception ex = null;
+ try {
+ getMS().updateMasterKey(seq_number, key);
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("update_master_key.", ex == null, ex);
+ }
+ }
+
+ @Override
+ public boolean remove_master_key(int key_seq) throws TException {
+ startFunction("remove_master_key.");
+ Exception ex = null;
+ boolean ret;
+ try {
+ ret = getMS().removeMasterKey(key_seq);
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("remove_master_key.", ex == null, ex);
+ }
+ return ret;
+ }
+
+ @Override
+ public List<String> get_master_keys() throws TException {
+ startFunction("get_master_keys.");
+ Exception ex = null;
+ String [] ret = null;
+ try {
+ ret = getMS().getMasterKeys();
+ } catch (Exception e) {
+ ex = e;
+ if (e instanceof MetaException) {
+ throw (MetaException) e;
+ } else {
+ throw newMetaException(e);
+ }
+ } finally {
+ endFunction("get_master_keys.", ret != null, ex);
+ }
+ return Arrays.asList(ret);
+ }
+
+ @Override
      public void markPartitionForEvent(final String db_name, final String tbl_name,
          final Map<String, String> partName, final PartitionEventType evtType) throws
          MetaException, TException, NoSuchObjectException, UnknownDBException,

http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
----------------------------------------------------------------------
diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
index b5c4d1d..9048d45 100644
--- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
+++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
@@ -1938,6 +1938,48 @@ public class HiveMetaStoreClient implements IMetaStoreClient {
    }

    @Override
+ public boolean addToken(String tokenIdentifier, String delegationToken) throws TException {
+ return client.add_token(tokenIdentifier, delegationToken);
+ }
+
+ @Override
+ public boolean removeToken(String tokenIdentifier) throws TException {
+ return client.remove_token(tokenIdentifier);
+ }
+
+ @Override
+ public String getToken(String tokenIdentifier) throws TException {
+ return client.get_token(tokenIdentifier);
+ }
+
+ @Override
+ public List<String> getAllTokenIdentifiers() throws TException {
+ return client.get_all_token_identifiers();
+ }
+
+ @Override
+ public int addMasterKey(String key) throws MetaException, TException {
+ return client.add_master_key(key);
+ }
+
+ @Override
+ public void updateMasterKey(Integer seqNo, String key)
+ throws NoSuchObjectException, MetaException, TException {
+ client.update_master_key(seqNo, key);
+ }
+
+ @Override
+ public boolean removeMasterKey(Integer keySeq) throws TException {
+ return client.remove_master_key(keySeq);
+ }
+
+ @Override
+ public String[] getMasterKeys() throws TException {
+ List<String> keyList = client.get_master_keys();
+ return keyList.toArray(new String[keyList.size()]);
+ }
+
+ @Override
    public ValidTxnList getValidTxns() throws TException {
      return TxnUtils.createValidReadTxnList(client.get_open_txns(), 0);
    }

http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
----------------------------------------------------------------------
diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
index cb092d1..62677d1 100644
--- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
+++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
@@ -1165,7 +1165,24 @@ public interface IMetaStoreClient {
     */
    void cancelDelegationToken(String tokenStrForm) throws MetaException, TException;

- public String getTokenStrForm() throws IOException;
+ String getTokenStrForm() throws IOException;
+
+ boolean addToken(String tokenIdentifier, String delegationToken) throws TException;
+
+ boolean removeToken(String tokenIdentifier) throws TException;
+
+ String getToken(String tokenIdentifier) throws TException;
+
+ List<String> getAllTokenIdentifiers() throws TException;
+
+ int addMasterKey(String key) throws MetaException, TException;
+
+ void updateMasterKey(Integer seqNo, String key)
+ throws NoSuchObjectException, MetaException, TException;
+
+ boolean removeMasterKey(Integer keySeq) throws TException;
+
+ String[] getMasterKeys() throws TException;

    void createFunction(Function func)
        throws InvalidObjectException, MetaException, TException;

http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
old mode 100644
new mode 100755

http://git-wip-us.apache.org/repos/asf/hive/blob/87131d0c/service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
----------------------------------------------------------------------
diff --git a/service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java b/service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
index 3d5e3a4..6992f62 100644
--- a/service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
+++ b/service/src/java/org/apache/hive/service/auth/HiveAuthFactory.java
@@ -36,9 +36,9 @@ import javax.security.sasl.Sasl;

  import org.apache.hadoop.hive.conf.HiveConf;
  import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
-import org.apache.hadoop.hive.metastore.HiveMetaStore;
-import org.apache.hadoop.hive.metastore.HiveMetaStore.HMSHandler;
+import org.apache.hadoop.hive.metastore.IMetaStoreClient;
  import org.apache.hadoop.hive.metastore.api.MetaException;
+import org.apache.hadoop.hive.ql.metadata.Hive;
  import org.apache.hadoop.hive.shims.HadoopShims.KerberosNameShim;
  import org.apache.hadoop.hive.shims.ShimLoader;
  import org.apache.hadoop.hive.thrift.DBTokenStore;
@@ -48,7 +48,6 @@ import org.apache.hadoop.hive.thrift.HadoopThriftAuthBridge.Server.ServerMode;
  import org.apache.hadoop.security.SecurityUtil;
  import org.apache.hadoop.security.UserGroupInformation;
  import org.apache.hadoop.security.authorize.ProxyUsers;
-import org.apache.hive.service.ServiceException;
  import org.apache.hive.service.cli.HiveSQLException;
  import org.apache.hive.service.cli.thrift.ThriftCLIService;
  import org.apache.thrift.TProcessorFactory;
@@ -105,7 +104,7 @@ public class HiveAuthFactory {
      transportMode = conf.getVar(HiveConf.ConfVars.HIVE_SERVER2_TRANSPORT_MODE);
      authTypeStr = conf.getVar(HiveConf.ConfVars.HIVE_SERVER2_AUTHENTICATION);

- // ShimLoader.getHadoopShims().isSecurityEnabled() will only check that·
+ // ShimLoader.getHadoopShims().isSecurityEnabled() will only check that
      // hadoopAuth is not simple, it does not guarantee it is kerberos
      hadoopAuth = conf.get(HADOOP_SECURITY_AUTHENTICATION, "simple");

@@ -127,18 +126,26 @@ public class HiveAuthFactory {
        // Start delegation token manager
        delegationTokenManager = new HiveDelegationTokenManager();
        try {
- // baseHandler is only necessary for DBTokenStore
- HMSHandler baseHandler = null;
- String tokenStoreClass =
- conf.getVar(HiveConf.ConfVars.METASTORE_CLUSTER_DELEGATION_TOKEN_STORE_CLS);
+ Object baseHandler = null;
+ String tokenStoreClass = conf.getVar(HiveConf.ConfVars.METASTORE_CLUSTER_DELEGATION_TOKEN_STORE_CLS);
+
          if (tokenStoreClass.equals(DBTokenStore.class.getName())) {
- baseHandler = new HiveMetaStore.HMSHandler("New db based metastore server", conf, true);
+ // IMetaStoreClient is needed to access token store if DBTokenStore is to be used. It
+ // will be got via Hive.get(conf).getMSC in a thread where the DelegationTokenStore
+ // is called. To avoid the cyclic reference, we pass the Hive class to DBTokenStore where
+ // it is used to get a threadLocal Hive object with a synchronized MetaStoreClient using
+ // Java reflection.
+ // Note: there will be two HS2 life-long opened MSCs, one is stored in HS2 thread local
+ // Hive object, the other is in a daemon thread spawned in DelegationTokenSecretManager
+ // to remove expired tokens.
+ baseHandler = Hive.class;
          }
- delegationTokenManager.startDelegationTokenSecretManager(conf, baseHandler,
- ServerMode.HIVESERVER2);
+
+ delegationTokenManager.startDelegationTokenSecretManager(conf, baseHandler, ServerMode.HIVESERVER2);
          saslServer.setSecretManager(delegationTokenManager.getSecretManager());
- } catch (MetaException | IOException e) {
- throw new ServiceException("Failed to start token manager", e);
+ }
+ catch (IOException e) {
+ throw new TTransportException("Failed to start token manager", e);
        }
      }
    }

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 2 of 7 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedMar 8, '16 at 8:06p
activeMar 8, '16 at 8:06p
posts7
users1
websitehive.apache.org

1 user in discussion

Ctang: 7 posts

People

Translate

site design / logo © 2021 Grokbase