Return-Path: X-Original-To: apmail-accumulo-commits-archive@www.apache.org Delivered-To: apmail-accumulo-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 89471103F7 for ; Tue, 4 Feb 2014 22:19:59 +0000 (UTC) Received: (qmail 47493 invoked by uid 500); 4 Feb 2014 22:19:50 -0000 Delivered-To: apmail-accumulo-commits-archive@accumulo.apache.org Received: (qmail 47153 invoked by uid 500); 4 Feb 2014 22:19:41 -0000 Mailing-List: contact commits-help@accumulo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@accumulo.apache.org Delivered-To: mailing list commits@accumulo.apache.org Received: (qmail 47063 invoked by uid 99); 4 Feb 2014 22:19:39 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 04 Feb 2014 22:19:39 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id 0C4E4824B9D; Tue, 4 Feb 2014 22:19:39 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: vines@apache.org To: commits@accumulo.apache.org Date: Tue, 04 Feb 2014 22:19:42 -0000 Message-Id: <03709aea243e4e828a1cffe76f5a439d@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [05/17] ACCUMULO-2197 provide generated proxy libraries, with modified generate-thrift script which tacks on headers http://git-wip-us.apache.org/repos/asf/accumulo/blob/3d436e7b/proxy/src/main/cpp/proxy_types.h ---------------------------------------------------------------------- diff --git a/proxy/src/main/cpp/proxy_types.h b/proxy/src/main/cpp/proxy_types.h new file mode 100644 index 0000000..5b0c554 --- /dev/null +++ b/proxy/src/main/cpp/proxy_types.h @@ -0,0 +1,1600 @@ +/* + * 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. + */ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef proxy_TYPES_H +#define proxy_TYPES_H + +#include +#include +#include +#include + + + +namespace accumulo { + +struct PartialKey { + enum type { + ROW = 0, + ROW_COLFAM = 1, + ROW_COLFAM_COLQUAL = 2, + ROW_COLFAM_COLQUAL_COLVIS = 3, + ROW_COLFAM_COLQUAL_COLVIS_TIME = 4, + ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL = 5 + }; +}; + +extern const std::map _PartialKey_VALUES_TO_NAMES; + +struct TablePermission { + enum type { + READ = 2, + WRITE = 3, + BULK_IMPORT = 4, + ALTER_TABLE = 5, + GRANT = 6, + DROP_TABLE = 7 + }; +}; + +extern const std::map _TablePermission_VALUES_TO_NAMES; + +struct SystemPermission { + enum type { + GRANT = 0, + CREATE_TABLE = 1, + DROP_TABLE = 2, + ALTER_TABLE = 3, + CREATE_USER = 4, + DROP_USER = 5, + ALTER_USER = 6, + SYSTEM = 7 + }; +}; + +extern const std::map _SystemPermission_VALUES_TO_NAMES; + +struct ScanType { + enum type { + SINGLE = 0, + BATCH = 1 + }; +}; + +extern const std::map _ScanType_VALUES_TO_NAMES; + +struct ScanState { + enum type { + IDLE = 0, + RUNNING = 1, + QUEUED = 2 + }; +}; + +extern const std::map _ScanState_VALUES_TO_NAMES; + +struct CompactionType { + enum type { + MINOR = 0, + MERGE = 1, + MAJOR = 2, + FULL = 3 + }; +}; + +extern const std::map _CompactionType_VALUES_TO_NAMES; + +struct CompactionReason { + enum type { + USER = 0, + SYSTEM = 1, + CHOP = 2, + IDLE = 3, + CLOSE = 4 + }; +}; + +extern const std::map _CompactionReason_VALUES_TO_NAMES; + +struct IteratorScope { + enum type { + MINC = 0, + MAJC = 1, + SCAN = 2 + }; +}; + +extern const std::map _IteratorScope_VALUES_TO_NAMES; + +struct TimeType { + enum type { + LOGICAL = 0, + MILLIS = 1 + }; +}; + +extern const std::map _TimeType_VALUES_TO_NAMES; + +typedef struct _Key__isset { + _Key__isset() : row(false), colFamily(false), colQualifier(false), colVisibility(false), timestamp(true) {} + bool row; + bool colFamily; + bool colQualifier; + bool colVisibility; + bool timestamp; +} _Key__isset; + +class Key { + public: + + static const char* ascii_fingerprint; // = "91151A432E03F5E8564877B5194B48E2"; + static const uint8_t binary_fingerprint[16]; // = {0x91,0x15,0x1A,0x43,0x2E,0x03,0xF5,0xE8,0x56,0x48,0x77,0xB5,0x19,0x4B,0x48,0xE2}; + + Key() : row(), colFamily(), colQualifier(), colVisibility(), timestamp(9223372036854775807LL) { + } + + virtual ~Key() throw() {} + + std::string row; + std::string colFamily; + std::string colQualifier; + std::string colVisibility; + int64_t timestamp; + + _Key__isset __isset; + + void __set_row(const std::string& val) { + row = val; + } + + void __set_colFamily(const std::string& val) { + colFamily = val; + } + + void __set_colQualifier(const std::string& val) { + colQualifier = val; + } + + void __set_colVisibility(const std::string& val) { + colVisibility = val; + } + + void __set_timestamp(const int64_t val) { + timestamp = val; + __isset.timestamp = true; + } + + bool operator == (const Key & rhs) const + { + if (!(row == rhs.row)) + return false; + if (!(colFamily == rhs.colFamily)) + return false; + if (!(colQualifier == rhs.colQualifier)) + return false; + if (!(colVisibility == rhs.colVisibility)) + return false; + if (__isset.timestamp != rhs.__isset.timestamp) + return false; + else if (__isset.timestamp && !(timestamp == rhs.timestamp)) + return false; + return true; + } + bool operator != (const Key &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Key & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(Key &a, Key &b); + +typedef struct _ColumnUpdate__isset { + _ColumnUpdate__isset() : colFamily(false), colQualifier(false), colVisibility(false), timestamp(false), value(false), deleteCell(false) {} + bool colFamily; + bool colQualifier; + bool colVisibility; + bool timestamp; + bool value; + bool deleteCell; +} _ColumnUpdate__isset; + +class ColumnUpdate { + public: + + static const char* ascii_fingerprint; // = "65CC1863F7DDC1DE75B9EAF9E2DC0D1F"; + static const uint8_t binary_fingerprint[16]; // = {0x65,0xCC,0x18,0x63,0xF7,0xDD,0xC1,0xDE,0x75,0xB9,0xEA,0xF9,0xE2,0xDC,0x0D,0x1F}; + + ColumnUpdate() : colFamily(), colQualifier(), colVisibility(), timestamp(0), value(), deleteCell(0) { + } + + virtual ~ColumnUpdate() throw() {} + + std::string colFamily; + std::string colQualifier; + std::string colVisibility; + int64_t timestamp; + std::string value; + bool deleteCell; + + _ColumnUpdate__isset __isset; + + void __set_colFamily(const std::string& val) { + colFamily = val; + } + + void __set_colQualifier(const std::string& val) { + colQualifier = val; + } + + void __set_colVisibility(const std::string& val) { + colVisibility = val; + __isset.colVisibility = true; + } + + void __set_timestamp(const int64_t val) { + timestamp = val; + __isset.timestamp = true; + } + + void __set_value(const std::string& val) { + value = val; + __isset.value = true; + } + + void __set_deleteCell(const bool val) { + deleteCell = val; + __isset.deleteCell = true; + } + + bool operator == (const ColumnUpdate & rhs) const + { + if (!(colFamily == rhs.colFamily)) + return false; + if (!(colQualifier == rhs.colQualifier)) + return false; + if (__isset.colVisibility != rhs.__isset.colVisibility) + return false; + else if (__isset.colVisibility && !(colVisibility == rhs.colVisibility)) + return false; + if (__isset.timestamp != rhs.__isset.timestamp) + return false; + else if (__isset.timestamp && !(timestamp == rhs.timestamp)) + return false; + if (__isset.value != rhs.__isset.value) + return false; + else if (__isset.value && !(value == rhs.value)) + return false; + if (__isset.deleteCell != rhs.__isset.deleteCell) + return false; + else if (__isset.deleteCell && !(deleteCell == rhs.deleteCell)) + return false; + return true; + } + bool operator != (const ColumnUpdate &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ColumnUpdate & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ColumnUpdate &a, ColumnUpdate &b); + +typedef struct _KeyValue__isset { + _KeyValue__isset() : key(false), value(false) {} + bool key; + bool value; +} _KeyValue__isset; + +class KeyValue { + public: + + static const char* ascii_fingerprint; // = "0D0CA44F233F983E00E94228C31ABBD4"; + static const uint8_t binary_fingerprint[16]; // = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4}; + + KeyValue() : value() { + } + + virtual ~KeyValue() throw() {} + + Key key; + std::string value; + + _KeyValue__isset __isset; + + void __set_key(const Key& val) { + key = val; + } + + void __set_value(const std::string& val) { + value = val; + } + + bool operator == (const KeyValue & rhs) const + { + if (!(key == rhs.key)) + return false; + if (!(value == rhs.value)) + return false; + return true; + } + bool operator != (const KeyValue &rhs) const { + return !(*this == rhs); + } + + bool operator < (const KeyValue & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(KeyValue &a, KeyValue &b); + +typedef struct _ScanResult__isset { + _ScanResult__isset() : results(false), more(false) {} + bool results; + bool more; +} _ScanResult__isset; + +class ScanResult { + public: + + static const char* ascii_fingerprint; // = "684A3FCA76EA202FE071A17F8B510E7A"; + static const uint8_t binary_fingerprint[16]; // = {0x68,0x4A,0x3F,0xCA,0x76,0xEA,0x20,0x2F,0xE0,0x71,0xA1,0x7F,0x8B,0x51,0x0E,0x7A}; + + ScanResult() : more(0) { + } + + virtual ~ScanResult() throw() {} + + std::vector results; + bool more; + + _ScanResult__isset __isset; + + void __set_results(const std::vector & val) { + results = val; + } + + void __set_more(const bool val) { + more = val; + } + + bool operator == (const ScanResult & rhs) const + { + if (!(results == rhs.results)) + return false; + if (!(more == rhs.more)) + return false; + return true; + } + bool operator != (const ScanResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScanResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ScanResult &a, ScanResult &b); + +typedef struct _Range__isset { + _Range__isset() : start(false), startInclusive(false), stop(false), stopInclusive(false) {} + bool start; + bool startInclusive; + bool stop; + bool stopInclusive; +} _Range__isset; + +class Range { + public: + + static const char* ascii_fingerprint; // = "84C5BA8DB718E60BFBF3F83867647B45"; + static const uint8_t binary_fingerprint[16]; // = {0x84,0xC5,0xBA,0x8D,0xB7,0x18,0xE6,0x0B,0xFB,0xF3,0xF8,0x38,0x67,0x64,0x7B,0x45}; + + Range() : startInclusive(0), stopInclusive(0) { + } + + virtual ~Range() throw() {} + + Key start; + bool startInclusive; + Key stop; + bool stopInclusive; + + _Range__isset __isset; + + void __set_start(const Key& val) { + start = val; + } + + void __set_startInclusive(const bool val) { + startInclusive = val; + } + + void __set_stop(const Key& val) { + stop = val; + } + + void __set_stopInclusive(const bool val) { + stopInclusive = val; + } + + bool operator == (const Range & rhs) const + { + if (!(start == rhs.start)) + return false; + if (!(startInclusive == rhs.startInclusive)) + return false; + if (!(stop == rhs.stop)) + return false; + if (!(stopInclusive == rhs.stopInclusive)) + return false; + return true; + } + bool operator != (const Range &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Range & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(Range &a, Range &b); + +typedef struct _ScanColumn__isset { + _ScanColumn__isset() : colFamily(false), colQualifier(false) {} + bool colFamily; + bool colQualifier; +} _ScanColumn__isset; + +class ScanColumn { + public: + + static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9"; + static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9}; + + ScanColumn() : colFamily(), colQualifier() { + } + + virtual ~ScanColumn() throw() {} + + std::string colFamily; + std::string colQualifier; + + _ScanColumn__isset __isset; + + void __set_colFamily(const std::string& val) { + colFamily = val; + } + + void __set_colQualifier(const std::string& val) { + colQualifier = val; + __isset.colQualifier = true; + } + + bool operator == (const ScanColumn & rhs) const + { + if (!(colFamily == rhs.colFamily)) + return false; + if (__isset.colQualifier != rhs.__isset.colQualifier) + return false; + else if (__isset.colQualifier && !(colQualifier == rhs.colQualifier)) + return false; + return true; + } + bool operator != (const ScanColumn &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScanColumn & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ScanColumn &a, ScanColumn &b); + +typedef struct _IteratorSetting__isset { + _IteratorSetting__isset() : priority(false), name(false), iteratorClass(false), properties(false) {} + bool priority; + bool name; + bool iteratorClass; + bool properties; +} _IteratorSetting__isset; + +class IteratorSetting { + public: + + static const char* ascii_fingerprint; // = "985C857916964E43205EAC92A157CB4E"; + static const uint8_t binary_fingerprint[16]; // = {0x98,0x5C,0x85,0x79,0x16,0x96,0x4E,0x43,0x20,0x5E,0xAC,0x92,0xA1,0x57,0xCB,0x4E}; + + IteratorSetting() : priority(0), name(), iteratorClass() { + } + + virtual ~IteratorSetting() throw() {} + + int32_t priority; + std::string name; + std::string iteratorClass; + std::map properties; + + _IteratorSetting__isset __isset; + + void __set_priority(const int32_t val) { + priority = val; + } + + void __set_name(const std::string& val) { + name = val; + } + + void __set_iteratorClass(const std::string& val) { + iteratorClass = val; + } + + void __set_properties(const std::map & val) { + properties = val; + } + + bool operator == (const IteratorSetting & rhs) const + { + if (!(priority == rhs.priority)) + return false; + if (!(name == rhs.name)) + return false; + if (!(iteratorClass == rhs.iteratorClass)) + return false; + if (!(properties == rhs.properties)) + return false; + return true; + } + bool operator != (const IteratorSetting &rhs) const { + return !(*this == rhs); + } + + bool operator < (const IteratorSetting & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(IteratorSetting &a, IteratorSetting &b); + +typedef struct _ScanOptions__isset { + _ScanOptions__isset() : authorizations(false), range(false), columns(false), iterators(false), bufferSize(false) {} + bool authorizations; + bool range; + bool columns; + bool iterators; + bool bufferSize; +} _ScanOptions__isset; + +class ScanOptions { + public: + + static const char* ascii_fingerprint; // = "3D87D0CD05FA62E15880C4D2C595907C"; + static const uint8_t binary_fingerprint[16]; // = {0x3D,0x87,0xD0,0xCD,0x05,0xFA,0x62,0xE1,0x58,0x80,0xC4,0xD2,0xC5,0x95,0x90,0x7C}; + + ScanOptions() : bufferSize(0) { + } + + virtual ~ScanOptions() throw() {} + + std::set authorizations; + Range range; + std::vector columns; + std::vector iterators; + int32_t bufferSize; + + _ScanOptions__isset __isset; + + void __set_authorizations(const std::set & val) { + authorizations = val; + __isset.authorizations = true; + } + + void __set_range(const Range& val) { + range = val; + __isset.range = true; + } + + void __set_columns(const std::vector & val) { + columns = val; + __isset.columns = true; + } + + void __set_iterators(const std::vector & val) { + iterators = val; + __isset.iterators = true; + } + + void __set_bufferSize(const int32_t val) { + bufferSize = val; + __isset.bufferSize = true; + } + + bool operator == (const ScanOptions & rhs) const + { + if (__isset.authorizations != rhs.__isset.authorizations) + return false; + else if (__isset.authorizations && !(authorizations == rhs.authorizations)) + return false; + if (__isset.range != rhs.__isset.range) + return false; + else if (__isset.range && !(range == rhs.range)) + return false; + if (__isset.columns != rhs.__isset.columns) + return false; + else if (__isset.columns && !(columns == rhs.columns)) + return false; + if (__isset.iterators != rhs.__isset.iterators) + return false; + else if (__isset.iterators && !(iterators == rhs.iterators)) + return false; + if (__isset.bufferSize != rhs.__isset.bufferSize) + return false; + else if (__isset.bufferSize && !(bufferSize == rhs.bufferSize)) + return false; + return true; + } + bool operator != (const ScanOptions &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ScanOptions & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ScanOptions &a, ScanOptions &b); + +typedef struct _BatchScanOptions__isset { + _BatchScanOptions__isset() : authorizations(false), ranges(false), columns(false), iterators(false), threads(false) {} + bool authorizations; + bool ranges; + bool columns; + bool iterators; + bool threads; +} _BatchScanOptions__isset; + +class BatchScanOptions { + public: + + static const char* ascii_fingerprint; // = "6ADFA1FBE31B1220D2C103284E002308"; + static const uint8_t binary_fingerprint[16]; // = {0x6A,0xDF,0xA1,0xFB,0xE3,0x1B,0x12,0x20,0xD2,0xC1,0x03,0x28,0x4E,0x00,0x23,0x08}; + + BatchScanOptions() : threads(0) { + } + + virtual ~BatchScanOptions() throw() {} + + std::set authorizations; + std::vector ranges; + std::vector columns; + std::vector iterators; + int32_t threads; + + _BatchScanOptions__isset __isset; + + void __set_authorizations(const std::set & val) { + authorizations = val; + __isset.authorizations = true; + } + + void __set_ranges(const std::vector & val) { + ranges = val; + __isset.ranges = true; + } + + void __set_columns(const std::vector & val) { + columns = val; + __isset.columns = true; + } + + void __set_iterators(const std::vector & val) { + iterators = val; + __isset.iterators = true; + } + + void __set_threads(const int32_t val) { + threads = val; + __isset.threads = true; + } + + bool operator == (const BatchScanOptions & rhs) const + { + if (__isset.authorizations != rhs.__isset.authorizations) + return false; + else if (__isset.authorizations && !(authorizations == rhs.authorizations)) + return false; + if (__isset.ranges != rhs.__isset.ranges) + return false; + else if (__isset.ranges && !(ranges == rhs.ranges)) + return false; + if (__isset.columns != rhs.__isset.columns) + return false; + else if (__isset.columns && !(columns == rhs.columns)) + return false; + if (__isset.iterators != rhs.__isset.iterators) + return false; + else if (__isset.iterators && !(iterators == rhs.iterators)) + return false; + if (__isset.threads != rhs.__isset.threads) + return false; + else if (__isset.threads && !(threads == rhs.threads)) + return false; + return true; + } + bool operator != (const BatchScanOptions &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BatchScanOptions & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(BatchScanOptions &a, BatchScanOptions &b); + +typedef struct _KeyValueAndPeek__isset { + _KeyValueAndPeek__isset() : keyValue(false), hasNext(false) {} + bool keyValue; + bool hasNext; +} _KeyValueAndPeek__isset; + +class KeyValueAndPeek { + public: + + static const char* ascii_fingerprint; // = "CBBC6AB9C7EA5E5E748C13F970862FAB"; + static const uint8_t binary_fingerprint[16]; // = {0xCB,0xBC,0x6A,0xB9,0xC7,0xEA,0x5E,0x5E,0x74,0x8C,0x13,0xF9,0x70,0x86,0x2F,0xAB}; + + KeyValueAndPeek() : hasNext(0) { + } + + virtual ~KeyValueAndPeek() throw() {} + + KeyValue keyValue; + bool hasNext; + + _KeyValueAndPeek__isset __isset; + + void __set_keyValue(const KeyValue& val) { + keyValue = val; + } + + void __set_hasNext(const bool val) { + hasNext = val; + } + + bool operator == (const KeyValueAndPeek & rhs) const + { + if (!(keyValue == rhs.keyValue)) + return false; + if (!(hasNext == rhs.hasNext)) + return false; + return true; + } + bool operator != (const KeyValueAndPeek &rhs) const { + return !(*this == rhs); + } + + bool operator < (const KeyValueAndPeek & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(KeyValueAndPeek &a, KeyValueAndPeek &b); + +typedef struct _KeyExtent__isset { + _KeyExtent__isset() : tableId(false), endRow(false), prevEndRow(false) {} + bool tableId; + bool endRow; + bool prevEndRow; +} _KeyExtent__isset; + +class KeyExtent { + public: + + static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271"; + static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; + + KeyExtent() : tableId(), endRow(), prevEndRow() { + } + + virtual ~KeyExtent() throw() {} + + std::string tableId; + std::string endRow; + std::string prevEndRow; + + _KeyExtent__isset __isset; + + void __set_tableId(const std::string& val) { + tableId = val; + } + + void __set_endRow(const std::string& val) { + endRow = val; + } + + void __set_prevEndRow(const std::string& val) { + prevEndRow = val; + } + + bool operator == (const KeyExtent & rhs) const + { + if (!(tableId == rhs.tableId)) + return false; + if (!(endRow == rhs.endRow)) + return false; + if (!(prevEndRow == rhs.prevEndRow)) + return false; + return true; + } + bool operator != (const KeyExtent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const KeyExtent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(KeyExtent &a, KeyExtent &b); + +typedef struct _Column__isset { + _Column__isset() : colFamily(false), colQualifier(false), colVisibility(false) {} + bool colFamily; + bool colQualifier; + bool colVisibility; +} _Column__isset; + +class Column { + public: + + static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271"; + static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; + + Column() : colFamily(), colQualifier(), colVisibility() { + } + + virtual ~Column() throw() {} + + std::string colFamily; + std::string colQualifier; + std::string colVisibility; + + _Column__isset __isset; + + void __set_colFamily(const std::string& val) { + colFamily = val; + } + + void __set_colQualifier(const std::string& val) { + colQualifier = val; + } + + void __set_colVisibility(const std::string& val) { + colVisibility = val; + } + + bool operator == (const Column & rhs) const + { + if (!(colFamily == rhs.colFamily)) + return false; + if (!(colQualifier == rhs.colQualifier)) + return false; + if (!(colVisibility == rhs.colVisibility)) + return false; + return true; + } + bool operator != (const Column &rhs) const { + return !(*this == rhs); + } + + bool operator < (const Column & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(Column &a, Column &b); + +typedef struct _ActiveScan__isset { + _ActiveScan__isset() : client(false), user(false), table(false), age(false), idleTime(false), type(false), state(false), extent(false), columns(false), iterators(false), authorizations(false) {} + bool client; + bool user; + bool table; + bool age; + bool idleTime; + bool type; + bool state; + bool extent; + bool columns; + bool iterators; + bool authorizations; +} _ActiveScan__isset; + +class ActiveScan { + public: + + static const char* ascii_fingerprint; // = "1B97541CB4E900A054266BBBEE61D004"; + static const uint8_t binary_fingerprint[16]; // = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04}; + + ActiveScan() : client(), user(), table(), age(0), idleTime(0), type((ScanType::type)0), state((ScanState::type)0) { + } + + virtual ~ActiveScan() throw() {} + + std::string client; + std::string user; + std::string table; + int64_t age; + int64_t idleTime; + ScanType::type type; + ScanState::type state; + KeyExtent extent; + std::vector columns; + std::vector iterators; + std::vector authorizations; + + _ActiveScan__isset __isset; + + void __set_client(const std::string& val) { + client = val; + } + + void __set_user(const std::string& val) { + user = val; + } + + void __set_table(const std::string& val) { + table = val; + } + + void __set_age(const int64_t val) { + age = val; + } + + void __set_idleTime(const int64_t val) { + idleTime = val; + } + + void __set_type(const ScanType::type val) { + type = val; + } + + void __set_state(const ScanState::type val) { + state = val; + } + + void __set_extent(const KeyExtent& val) { + extent = val; + } + + void __set_columns(const std::vector & val) { + columns = val; + } + + void __set_iterators(const std::vector & val) { + iterators = val; + } + + void __set_authorizations(const std::vector & val) { + authorizations = val; + } + + bool operator == (const ActiveScan & rhs) const + { + if (!(client == rhs.client)) + return false; + if (!(user == rhs.user)) + return false; + if (!(table == rhs.table)) + return false; + if (!(age == rhs.age)) + return false; + if (!(idleTime == rhs.idleTime)) + return false; + if (!(type == rhs.type)) + return false; + if (!(state == rhs.state)) + return false; + if (!(extent == rhs.extent)) + return false; + if (!(columns == rhs.columns)) + return false; + if (!(iterators == rhs.iterators)) + return false; + if (!(authorizations == rhs.authorizations)) + return false; + return true; + } + bool operator != (const ActiveScan &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ActiveScan & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ActiveScan &a, ActiveScan &b); + +typedef struct _ActiveCompaction__isset { + _ActiveCompaction__isset() : extent(false), age(false), inputFiles(false), outputFile(false), type(false), reason(false), localityGroup(false), entriesRead(false), entriesWritten(false), iterators(false) {} + bool extent; + bool age; + bool inputFiles; + bool outputFile; + bool type; + bool reason; + bool localityGroup; + bool entriesRead; + bool entriesWritten; + bool iterators; +} _ActiveCompaction__isset; + +class ActiveCompaction { + public: + + static const char* ascii_fingerprint; // = "2BB155CC901109464666B6C7E6A8C1A6"; + static const uint8_t binary_fingerprint[16]; // = {0x2B,0xB1,0x55,0xCC,0x90,0x11,0x09,0x46,0x46,0x66,0xB6,0xC7,0xE6,0xA8,0xC1,0xA6}; + + ActiveCompaction() : age(0), outputFile(), type((CompactionType::type)0), reason((CompactionReason::type)0), localityGroup(), entriesRead(0), entriesWritten(0) { + } + + virtual ~ActiveCompaction() throw() {} + + KeyExtent extent; + int64_t age; + std::vector inputFiles; + std::string outputFile; + CompactionType::type type; + CompactionReason::type reason; + std::string localityGroup; + int64_t entriesRead; + int64_t entriesWritten; + std::vector iterators; + + _ActiveCompaction__isset __isset; + + void __set_extent(const KeyExtent& val) { + extent = val; + } + + void __set_age(const int64_t val) { + age = val; + } + + void __set_inputFiles(const std::vector & val) { + inputFiles = val; + } + + void __set_outputFile(const std::string& val) { + outputFile = val; + } + + void __set_type(const CompactionType::type val) { + type = val; + } + + void __set_reason(const CompactionReason::type val) { + reason = val; + } + + void __set_localityGroup(const std::string& val) { + localityGroup = val; + } + + void __set_entriesRead(const int64_t val) { + entriesRead = val; + } + + void __set_entriesWritten(const int64_t val) { + entriesWritten = val; + } + + void __set_iterators(const std::vector & val) { + iterators = val; + } + + bool operator == (const ActiveCompaction & rhs) const + { + if (!(extent == rhs.extent)) + return false; + if (!(age == rhs.age)) + return false; + if (!(inputFiles == rhs.inputFiles)) + return false; + if (!(outputFile == rhs.outputFile)) + return false; + if (!(type == rhs.type)) + return false; + if (!(reason == rhs.reason)) + return false; + if (!(localityGroup == rhs.localityGroup)) + return false; + if (!(entriesRead == rhs.entriesRead)) + return false; + if (!(entriesWritten == rhs.entriesWritten)) + return false; + if (!(iterators == rhs.iterators)) + return false; + return true; + } + bool operator != (const ActiveCompaction &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ActiveCompaction & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ActiveCompaction &a, ActiveCompaction &b); + +typedef struct _WriterOptions__isset { + _WriterOptions__isset() : maxMemory(false), latencyMs(false), timeoutMs(false), threads(false) {} + bool maxMemory; + bool latencyMs; + bool timeoutMs; + bool threads; +} _WriterOptions__isset; + +class WriterOptions { + public: + + static const char* ascii_fingerprint; // = "D6FB71C9973666B9F6B5C20D5B7B19EF"; + static const uint8_t binary_fingerprint[16]; // = {0xD6,0xFB,0x71,0xC9,0x97,0x36,0x66,0xB9,0xF6,0xB5,0xC2,0x0D,0x5B,0x7B,0x19,0xEF}; + + WriterOptions() : maxMemory(0), latencyMs(0), timeoutMs(0), threads(0) { + } + + virtual ~WriterOptions() throw() {} + + int64_t maxMemory; + int64_t latencyMs; + int64_t timeoutMs; + int32_t threads; + + _WriterOptions__isset __isset; + + void __set_maxMemory(const int64_t val) { + maxMemory = val; + } + + void __set_latencyMs(const int64_t val) { + latencyMs = val; + } + + void __set_timeoutMs(const int64_t val) { + timeoutMs = val; + } + + void __set_threads(const int32_t val) { + threads = val; + } + + bool operator == (const WriterOptions & rhs) const + { + if (!(maxMemory == rhs.maxMemory)) + return false; + if (!(latencyMs == rhs.latencyMs)) + return false; + if (!(timeoutMs == rhs.timeoutMs)) + return false; + if (!(threads == rhs.threads)) + return false; + return true; + } + bool operator != (const WriterOptions &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WriterOptions & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(WriterOptions &a, WriterOptions &b); + +typedef struct _UnknownScanner__isset { + _UnknownScanner__isset() : msg(false) {} + bool msg; +} _UnknownScanner__isset; + +class UnknownScanner : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + UnknownScanner() : msg() { + } + + virtual ~UnknownScanner() throw() {} + + std::string msg; + + _UnknownScanner__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const UnknownScanner & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const UnknownScanner &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UnknownScanner & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(UnknownScanner &a, UnknownScanner &b); + +typedef struct _UnknownWriter__isset { + _UnknownWriter__isset() : msg(false) {} + bool msg; +} _UnknownWriter__isset; + +class UnknownWriter : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + UnknownWriter() : msg() { + } + + virtual ~UnknownWriter() throw() {} + + std::string msg; + + _UnknownWriter__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const UnknownWriter & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const UnknownWriter &rhs) const { + return !(*this == rhs); + } + + bool operator < (const UnknownWriter & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(UnknownWriter &a, UnknownWriter &b); + +typedef struct _NoMoreEntriesException__isset { + _NoMoreEntriesException__isset() : msg(false) {} + bool msg; +} _NoMoreEntriesException__isset; + +class NoMoreEntriesException : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + NoMoreEntriesException() : msg() { + } + + virtual ~NoMoreEntriesException() throw() {} + + std::string msg; + + _NoMoreEntriesException__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const NoMoreEntriesException & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const NoMoreEntriesException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NoMoreEntriesException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(NoMoreEntriesException &a, NoMoreEntriesException &b); + +typedef struct _AccumuloException__isset { + _AccumuloException__isset() : msg(false) {} + bool msg; +} _AccumuloException__isset; + +class AccumuloException : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + AccumuloException() : msg() { + } + + virtual ~AccumuloException() throw() {} + + std::string msg; + + _AccumuloException__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const AccumuloException & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const AccumuloException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(AccumuloException &a, AccumuloException &b); + +typedef struct _AccumuloSecurityException__isset { + _AccumuloSecurityException__isset() : msg(false) {} + bool msg; +} _AccumuloSecurityException__isset; + +class AccumuloSecurityException : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + AccumuloSecurityException() : msg() { + } + + virtual ~AccumuloSecurityException() throw() {} + + std::string msg; + + _AccumuloSecurityException__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const AccumuloSecurityException & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const AccumuloSecurityException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AccumuloSecurityException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(AccumuloSecurityException &a, AccumuloSecurityException &b); + +typedef struct _TableNotFoundException__isset { + _TableNotFoundException__isset() : msg(false) {} + bool msg; +} _TableNotFoundException__isset; + +class TableNotFoundException : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + TableNotFoundException() : msg() { + } + + virtual ~TableNotFoundException() throw() {} + + std::string msg; + + _TableNotFoundException__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const TableNotFoundException & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const TableNotFoundException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableNotFoundException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TableNotFoundException &a, TableNotFoundException &b); + +typedef struct _TableExistsException__isset { + _TableExistsException__isset() : msg(false) {} + bool msg; +} _TableExistsException__isset; + +class TableExistsException : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + TableExistsException() : msg() { + } + + virtual ~TableExistsException() throw() {} + + std::string msg; + + _TableExistsException__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const TableExistsException & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const TableExistsException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TableExistsException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TableExistsException &a, TableExistsException &b); + +typedef struct _MutationsRejectedException__isset { + _MutationsRejectedException__isset() : msg(false) {} + bool msg; +} _MutationsRejectedException__isset; + +class MutationsRejectedException : public ::apache::thrift::TException { + public: + + static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; + static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; + + MutationsRejectedException() : msg() { + } + + virtual ~MutationsRejectedException() throw() {} + + std::string msg; + + _MutationsRejectedException__isset __isset; + + void __set_msg(const std::string& val) { + msg = val; + } + + bool operator == (const MutationsRejectedException & rhs) const + { + if (!(msg == rhs.msg)) + return false; + return true; + } + bool operator != (const MutationsRejectedException &rhs) const { + return !(*this == rhs); + } + + bool operator < (const MutationsRejectedException & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(MutationsRejectedException &a, MutationsRejectedException &b); + +} // namespace + +#endif http://git-wip-us.apache.org/repos/asf/accumulo/blob/3d436e7b/proxy/src/main/python/AccumuloProxy-remote ---------------------------------------------------------------------- diff --git a/proxy/src/main/python/AccumuloProxy-remote b/proxy/src/main/python/AccumuloProxy-remote new file mode 100644 index 0000000..ac4d1e8 --- /dev/null +++ b/proxy/src/main/python/AccumuloProxy-remote @@ -0,0 +1,599 @@ +# 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. +#!/usr/bin/env python +# +# Autogenerated by Thrift Compiler (0.9.0) +# +# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING +# +# options string: py +# + +import sys +import pprint +from urlparse import urlparse +from thrift.transport import TTransport +from thrift.transport import TSocket +from thrift.transport import THttpClient +from thrift.protocol import TBinaryProtocol + +import AccumuloProxy +from ttypes import * + +if len(sys.argv) <= 1 or sys.argv[1] == '--help': + print '' + print 'Usage: ' + sys.argv[0] + ' [-h host[:port]] [-u url] [-f[ramed]] function [arg1 [arg2...]]' + print '' + print 'Functions:' + print ' string login(string principal, loginProperties)' + print ' i32 addConstraint(string login, string tableName, string constraintClassName)' + print ' void addSplits(string login, string tableName, splits)' + print ' void attachIterator(string login, string tableName, IteratorSetting setting, scopes)' + print ' void checkIteratorConflicts(string login, string tableName, IteratorSetting setting, scopes)' + print ' void clearLocatorCache(string login, string tableName)' + print ' void cloneTable(string login, string tableName, string newTableName, bool flush, propertiesToSet, propertiesToExclude)' + print ' void compactTable(string login, string tableName, string startRow, string endRow, iterators, bool flush, bool wait)' + print ' void cancelCompaction(string login, string tableName)' + print ' void createTable(string login, string tableName, bool versioningIter, TimeType type)' + print ' void deleteTable(string login, string tableName)' + print ' void deleteRows(string login, string tableName, string startRow, string endRow)' + print ' void exportTable(string login, string tableName, string exportDir)' + print ' void flushTable(string login, string tableName, string startRow, string endRow, bool wait)' + print ' getLocalityGroups(string login, string tableName)' + print ' IteratorSetting getIteratorSetting(string login, string tableName, string iteratorName, IteratorScope scope)' + print ' string getMaxRow(string login, string tableName, auths, string startRow, bool startInclusive, string endRow, bool endInclusive)' + print ' getTableProperties(string login, string tableName)' + print ' void importDirectory(string login, string tableName, string importDir, string failureDir, bool setTime)' + print ' void importTable(string login, string tableName, string importDir)' + print ' listSplits(string login, string tableName, i32 maxSplits)' + print ' listTables(string login)' + print ' listIterators(string login, string tableName)' + print ' listConstraints(string login, string tableName)' + print ' void mergeTablets(string login, string tableName, string startRow, string endRow)' + print ' void offlineTable(string login, string tableName)' + print ' void onlineTable(string login, string tableName)' + print ' void removeConstraint(string login, string tableName, i32 constraint)' + print ' void removeIterator(string login, string tableName, string iterName, scopes)' + print ' void removeTableProperty(string login, string tableName, string property)' + print ' void renameTable(string login, string oldTableName, string newTableName)' + print ' void setLocalityGroups(string login, string tableName, groups)' + print ' void setTableProperty(string login, string tableName, string property, string value)' + print ' splitRangeByTablets(string login, string tableName, Range range, i32 maxSplits)' + print ' bool tableExists(string login, string tableName)' + print ' tableIdMap(string login)' + print ' bool testTableClassLoad(string login, string tableName, string className, string asTypeName)' + print ' void pingTabletServer(string login, string tserver)' + print ' getActiveScans(string login, string tserver)' + print ' getActiveCompactions(string login, string tserver)' + print ' getSiteConfiguration(string login)' + print ' getSystemConfiguration(string login)' + print ' getTabletServers(string login)' + print ' void removeProperty(string login, string property)' + print ' void setProperty(string login, string property, string value)' + print ' bool testClassLoad(string login, string className, string asTypeName)' + print ' bool authenticateUser(string login, string user, properties)' + print ' void changeUserAuthorizations(string login, string user, authorizations)' + print ' void changeLocalUserPassword(string login, string user, string password)' + print ' void createLocalUser(string login, string user, string password)' + print ' void dropLocalUser(string login, string user)' + print ' getUserAuthorizations(string login, string user)' + print ' void grantSystemPermission(string login, string user, SystemPermission perm)' + print ' void grantTablePermission(string login, string user, string table, TablePermission perm)' + print ' bool hasSystemPermission(string login, string user, SystemPermission perm)' + print ' bool hasTablePermission(string login, string user, string table, TablePermission perm)' + print ' listLocalUsers(string login)' + print ' void revokeSystemPermission(string login, string user, SystemPermission perm)' + print ' void revokeTablePermission(string login, string user, string table, TablePermission perm)' + print ' string createBatchScanner(string login, string tableName, BatchScanOptions options)' + print ' string createScanner(string login, string tableName, ScanOptions options)' + print ' bool hasNext(string scanner)' + print ' KeyValueAndPeek nextEntry(string scanner)' + print ' ScanResult nextK(string scanner, i32 k)' + print ' void closeScanner(string scanner)' + print ' void updateAndFlush(string login, string tableName, cells)' + print ' string createWriter(string login, string tableName, WriterOptions opts)' + print ' void update(string writer, cells)' + print ' void flush(string writer)' + print ' void closeWriter(string writer)' + print ' Range getRowRange(string row)' + print ' Key getFollowing(Key key, PartialKey part)' + print '' + sys.exit(0) + +pp = pprint.PrettyPrinter(indent = 2) +host = 'localhost' +port = 9090 +uri = '' +framed = False +http = False +argi = 1 + +if sys.argv[argi] == '-h': + parts = sys.argv[argi+1].split(':') + host = parts[0] + if len(parts) > 1: + port = int(parts[1]) + argi += 2 + +if sys.argv[argi] == '-u': + url = urlparse(sys.argv[argi+1]) + parts = url[1].split(':') + host = parts[0] + if len(parts) > 1: + port = int(parts[1]) + else: + port = 80 + uri = url[2] + if url[4]: + uri += '?%s' % url[4] + http = True + argi += 2 + +if sys.argv[argi] == '-f' or sys.argv[argi] == '-framed': + framed = True + argi += 1 + +cmd = sys.argv[argi] +args = sys.argv[argi+1:] + +if http: + transport = THttpClient.THttpClient(host, port, uri) +else: + socket = TSocket.TSocket(host, port) + if framed: + transport = TTransport.TFramedTransport(socket) + else: + transport = TTransport.TBufferedTransport(socket) +protocol = TBinaryProtocol.TBinaryProtocol(transport) +client = AccumuloProxy.Client(protocol) +transport.open() + +if cmd == 'login': + if len(args) != 2: + print 'login requires 2 args' + sys.exit(1) + pp.pprint(client.login(args[0],eval(args[1]),)) + +elif cmd == 'addConstraint': + if len(args) != 3: + print 'addConstraint requires 3 args' + sys.exit(1) + pp.pprint(client.addConstraint(args[0],args[1],args[2],)) + +elif cmd == 'addSplits': + if len(args) != 3: + print 'addSplits requires 3 args' + sys.exit(1) + pp.pprint(client.addSplits(args[0],args[1],eval(args[2]),)) + +elif cmd == 'attachIterator': + if len(args) != 4: + print 'attachIterator requires 4 args' + sys.exit(1) + pp.pprint(client.attachIterator(args[0],args[1],eval(args[2]),eval(args[3]),)) + +elif cmd == 'checkIteratorConflicts': + if len(args) != 4: + print 'checkIteratorConflicts requires 4 args' + sys.exit(1) + pp.pprint(client.checkIteratorConflicts(args[0],args[1],eval(args[2]),eval(args[3]),)) + +elif cmd == 'clearLocatorCache': + if len(args) != 2: + print 'clearLocatorCache requires 2 args' + sys.exit(1) + pp.pprint(client.clearLocatorCache(args[0],args[1],)) + +elif cmd == 'cloneTable': + if len(args) != 6: + print 'cloneTable requires 6 args' + sys.exit(1) + pp.pprint(client.cloneTable(args[0],args[1],args[2],eval(args[3]),eval(args[4]),eval(args[5]),)) + +elif cmd == 'compactTable': + if len(args) != 7: + print 'compactTable requires 7 args' + sys.exit(1) + pp.pprint(client.compactTable(args[0],args[1],args[2],args[3],eval(args[4]),eval(args[5]),eval(args[6]),)) + +elif cmd == 'cancelCompaction': + if len(args) != 2: + print 'cancelCompaction requires 2 args' + sys.exit(1) + pp.pprint(client.cancelCompaction(args[0],args[1],)) + +elif cmd == 'createTable': + if len(args) != 4: + print 'createTable requires 4 args' + sys.exit(1) + pp.pprint(client.createTable(args[0],args[1],eval(args[2]),eval(args[3]),)) + +elif cmd == 'deleteTable': + if len(args) != 2: + print 'deleteTable requires 2 args' + sys.exit(1) + pp.pprint(client.deleteTable(args[0],args[1],)) + +elif cmd == 'deleteRows': + if len(args) != 4: + print 'deleteRows requires 4 args' + sys.exit(1) + pp.pprint(client.deleteRows(args[0],args[1],args[2],args[3],)) + +elif cmd == 'exportTable': + if len(args) != 3: + print 'exportTable requires 3 args' + sys.exit(1) + pp.pprint(client.exportTable(args[0],args[1],args[2],)) + +elif cmd == 'flushTable': + if len(args) != 5: + print 'flushTable requires 5 args' + sys.exit(1) + pp.pprint(client.flushTable(args[0],args[1],args[2],args[3],eval(args[4]),)) + +elif cmd == 'getLocalityGroups': + if len(args) != 2: + print 'getLocalityGroups requires 2 args' + sys.exit(1) + pp.pprint(client.getLocalityGroups(args[0],args[1],)) + +elif cmd == 'getIteratorSetting': + if len(args) != 4: + print 'getIteratorSetting requires 4 args' + sys.exit(1) + pp.pprint(client.getIteratorSetting(args[0],args[1],args[2],eval(args[3]),)) + +elif cmd == 'getMaxRow': + if len(args) != 7: + print 'getMaxRow requires 7 args' + sys.exit(1) + pp.pprint(client.getMaxRow(args[0],args[1],eval(args[2]),args[3],eval(args[4]),args[5],eval(args[6]),)) + +elif cmd == 'getTableProperties': + if len(args) != 2: + print 'getTableProperties requires 2 args' + sys.exit(1) + pp.pprint(client.getTableProperties(args[0],args[1],)) + +elif cmd == 'importDirectory': + if len(args) != 5: + print 'importDirectory requires 5 args' + sys.exit(1) + pp.pprint(client.importDirectory(args[0],args[1],args[2],args[3],eval(args[4]),)) + +elif cmd == 'importTable': + if len(args) != 3: + print 'importTable requires 3 args' + sys.exit(1) + pp.pprint(client.importTable(args[0],args[1],args[2],)) + +elif cmd == 'listSplits': + if len(args) != 3: + print 'listSplits requires 3 args' + sys.exit(1) + pp.pprint(client.listSplits(args[0],args[1],eval(args[2]),)) + +elif cmd == 'listTables': + if len(args) != 1: + print 'listTables requires 1 args' + sys.exit(1) + pp.pprint(client.listTables(args[0],)) + +elif cmd == 'listIterators': + if len(args) != 2: + print 'listIterators requires 2 args' + sys.exit(1) + pp.pprint(client.listIterators(args[0],args[1],)) + +elif cmd == 'listConstraints': + if len(args) != 2: + print 'listConstraints requires 2 args' + sys.exit(1) + pp.pprint(client.listConstraints(args[0],args[1],)) + +elif cmd == 'mergeTablets': + if len(args) != 4: + print 'mergeTablets requires 4 args' + sys.exit(1) + pp.pprint(client.mergeTablets(args[0],args[1],args[2],args[3],)) + +elif cmd == 'offlineTable': + if len(args) != 2: + print 'offlineTable requires 2 args' + sys.exit(1) + pp.pprint(client.offlineTable(args[0],args[1],)) + +elif cmd == 'onlineTable': + if len(args) != 2: + print 'onlineTable requires 2 args' + sys.exit(1) + pp.pprint(client.onlineTable(args[0],args[1],)) + +elif cmd == 'removeConstraint': + if len(args) != 3: + print 'removeConstraint requires 3 args' + sys.exit(1) + pp.pprint(client.removeConstraint(args[0],args[1],eval(args[2]),)) + +elif cmd == 'removeIterator': + if len(args) != 4: + print 'removeIterator requires 4 args' + sys.exit(1) + pp.pprint(client.removeIterator(args[0],args[1],args[2],eval(args[3]),)) + +elif cmd == 'removeTableProperty': + if len(args) != 3: + print 'removeTableProperty requires 3 args' + sys.exit(1) + pp.pprint(client.removeTableProperty(args[0],args[1],args[2],)) + +elif cmd == 'renameTable': + if len(args) != 3: + print 'renameTable requires 3 args' + sys.exit(1) + pp.pprint(client.renameTable(args[0],args[1],args[2],)) + +elif cmd == 'setLocalityGroups': + if len(args) != 3: + print 'setLocalityGroups requires 3 args' + sys.exit(1) + pp.pprint(client.setLocalityGroups(args[0],args[1],eval(args[2]),)) + +elif cmd == 'setTableProperty': + if len(args) != 4: + print 'setTableProperty requires 4 args' + sys.exit(1) + pp.pprint(client.setTableProperty(args[0],args[1],args[2],args[3],)) + +elif cmd == 'splitRangeByTablets': + if len(args) != 4: + print 'splitRangeByTablets requires 4 args' + sys.exit(1) + pp.pprint(client.splitRangeByTablets(args[0],args[1],eval(args[2]),eval(args[3]),)) + +elif cmd == 'tableExists': + if len(args) != 2: + print 'tableExists requires 2 args' + sys.exit(1) + pp.pprint(client.tableExists(args[0],args[1],)) + +elif cmd == 'tableIdMap': + if len(args) != 1: + print 'tableIdMap requires 1 args' + sys.exit(1) + pp.pprint(client.tableIdMap(args[0],)) + +elif cmd == 'testTableClassLoad': + if len(args) != 4: + print 'testTableClassLoad requires 4 args' + sys.exit(1) + pp.pprint(client.testTableClassLoad(args[0],args[1],args[2],args[3],)) + +elif cmd == 'pingTabletServer': + if len(args) != 2: + print 'pingTabletServer requires 2 args' + sys.exit(1) + pp.pprint(client.pingTabletServer(args[0],args[1],)) + +elif cmd == 'getActiveScans': + if len(args) != 2: + print 'getActiveScans requires 2 args' + sys.exit(1) + pp.pprint(client.getActiveScans(args[0],args[1],)) + +elif cmd == 'getActiveCompactions': + if len(args) != 2: + print 'getActiveCompactions requires 2 args' + sys.exit(1) + pp.pprint(client.getActiveCompactions(args[0],args[1],)) + +elif cmd == 'getSiteConfiguration': + if len(args) != 1: + print 'getSiteConfiguration requires 1 args' + sys.exit(1) + pp.pprint(client.getSiteConfiguration(args[0],)) + +elif cmd == 'getSystemConfiguration': + if len(args) != 1: + print 'getSystemConfiguration requires 1 args' + sys.exit(1) + pp.pprint(client.getSystemConfiguration(args[0],)) + +elif cmd == 'getTabletServers': + if len(args) != 1: + print 'getTabletServers requires 1 args' + sys.exit(1) + pp.pprint(client.getTabletServers(args[0],)) + +elif cmd == 'removeProperty': + if len(args) != 2: + print 'removeProperty requires 2 args' + sys.exit(1) + pp.pprint(client.removeProperty(args[0],args[1],)) + +elif cmd == 'setProperty': + if len(args) != 3: + print 'setProperty requires 3 args' + sys.exit(1) + pp.pprint(client.setProperty(args[0],args[1],args[2],)) + +elif cmd == 'testClassLoad': + if len(args) != 3: + print 'testClassLoad requires 3 args' + sys.exit(1) + pp.pprint(client.testClassLoad(args[0],args[1],args[2],)) + +elif cmd == 'authenticateUser': + if len(args) != 3: + print 'authenticateUser requires 3 args' + sys.exit(1) + pp.pprint(client.authenticateUser(args[0],args[1],eval(args[2]),)) + +elif cmd == 'changeUserAuthorizations': + if len(args) != 3: + print 'changeUserAuthorizations requires 3 args' + sys.exit(1) + pp.pprint(client.changeUserAuthorizations(args[0],args[1],eval(args[2]),)) + +elif cmd == 'changeLocalUserPassword': + if len(args) != 3: + print 'changeLocalUserPassword requires 3 args' + sys.exit(1) + pp.pprint(client.changeLocalUserPassword(args[0],args[1],args[2],)) + +elif cmd == 'createLocalUser': + if len(args) != 3: + print 'createLocalUser requires 3 args' + sys.exit(1) + pp.pprint(client.createLocalUser(args[0],args[1],args[2],)) + +elif cmd == 'dropLocalUser': + if len(args) != 2: + print 'dropLocalUser requires 2 args' + sys.exit(1) + pp.pprint(client.dropLocalUser(args[0],args[1],)) + +elif cmd == 'getUserAuthorizations': + if len(args) != 2: + print 'getUserAuthorizations requires 2 args' + sys.exit(1) + pp.pprint(client.getUserAuthorizations(args[0],args[1],)) + +elif cmd == 'grantSystemPermission': + if len(args) != 3: + print 'grantSystemPermission requires 3 args' + sys.exit(1) + pp.pprint(client.grantSystemPermission(args[0],args[1],eval(args[2]),)) + +elif cmd == 'grantTablePermission': + if len(args) != 4: + print 'grantTablePermission requires 4 args' + sys.exit(1) + pp.pprint(client.grantTablePermission(args[0],args[1],args[2],eval(args[3]),)) + +elif cmd == 'hasSystemPermission': + if len(args) != 3: + print 'hasSystemPermission requires 3 args' + sys.exit(1) + pp.pprint(client.hasSystemPermission(args[0],args[1],eval(args[2]),)) + +elif cmd == 'hasTablePermission': + if len(args) != 4: + print 'hasTablePermission requires 4 args' + sys.exit(1) + pp.pprint(client.hasTablePermission(args[0],args[1],args[2],eval(args[3]),)) + +elif cmd == 'listLocalUsers': + if len(args) != 1: + print 'listLocalUsers requires 1 args' + sys.exit(1) + pp.pprint(client.listLocalUsers(args[0],)) + +elif cmd == 'revokeSystemPermission': + if len(args) != 3: + print 'revokeSystemPermission requires 3 args' + sys.exit(1) + pp.pprint(client.revokeSystemPermission(args[0],args[1],eval(args[2]),)) + +elif cmd == 'revokeTablePermission': + if len(args) != 4: + print 'revokeTablePermission requires 4 args' + sys.exit(1) + pp.pprint(client.revokeTablePermission(args[0],args[1],args[2],eval(args[3]),)) + +elif cmd == 'createBatchScanner': + if len(args) != 3: + print 'createBatchScanner requires 3 args' + sys.exit(1) + pp.pprint(client.createBatchScanner(args[0],args[1],eval(args[2]),)) + +elif cmd == 'createScanner': + if len(args) != 3: + print 'createScanner requires 3 args' + sys.exit(1) + pp.pprint(client.createScanner(args[0],args[1],eval(args[2]),)) + +elif cmd == 'hasNext': + if len(args) != 1: + print 'hasNext requires 1 args' + sys.exit(1) + pp.pprint(client.hasNext(args[0],)) + +elif cmd == 'nextEntry': + if len(args) != 1: + print 'nextEntry requires 1 args' + sys.exit(1) + pp.pprint(client.nextEntry(args[0],)) + +elif cmd == 'nextK': + if len(args) != 2: + print 'nextK requires 2 args' + sys.exit(1) + pp.pprint(client.nextK(args[0],eval(args[1]),)) + +elif cmd == 'closeScanner': + if len(args) != 1: + print 'closeScanner requires 1 args' + sys.exit(1) + pp.pprint(client.closeScanner(args[0],)) + +elif cmd == 'updateAndFlush': + if len(args) != 3: + print 'updateAndFlush requires 3 args' + sys.exit(1) + pp.pprint(client.updateAndFlush(args[0],args[1],eval(args[2]),)) + +elif cmd == 'createWriter': + if len(args) != 3: + print 'createWriter requires 3 args' + sys.exit(1) + pp.pprint(client.createWriter(args[0],args[1],eval(args[2]),)) + +elif cmd == 'update': + if len(args) != 2: + print 'update requires 2 args' + sys.exit(1) + pp.pprint(client.update(args[0],eval(args[1]),)) + +elif cmd == 'flush': + if len(args) != 1: + print 'flush requires 1 args' + sys.exit(1) + pp.pprint(client.flush(args[0],)) + +elif cmd == 'closeWriter': + if len(args) != 1: + print 'closeWriter requires 1 args' + sys.exit(1) + pp.pprint(client.closeWriter(args[0],)) + +elif cmd == 'getRowRange': + if len(args) != 1: + print 'getRowRange requires 1 args' + sys.exit(1) + pp.pprint(client.getRowRange(args[0],)) + +elif cmd == 'getFollowing': + if len(args) != 2: + print 'getFollowing requires 2 args' + sys.exit(1) + pp.pprint(client.getFollowing(eval(args[0]),eval(args[1]),)) + +else: + print 'Unrecognized method %s' % cmd + sys.exit(1) + +transport.close()