http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/python/ttypes.py ---------------------------------------------------------------------- diff --git a/proxy/src/main/python/ttypes.py b/proxy/src/main/python/ttypes.py index 41f684d..2ec3346 100644 --- a/proxy/src/main/python/ttypes.py +++ b/proxy/src/main/python/ttypes.py @@ -145,6 +145,29 @@ class ScanState: "QUEUED": 2, } +class ConditionalStatus: + ACCEPTED = 0 + REJECTED = 1 + VIOLATED = 2 + UNKNOWN = 3 + INVISIBLE_VISIBILITY = 4 + + _VALUES_TO_NAMES = { + 0: "ACCEPTED", + 1: "REJECTED", + 2: "VIOLATED", + 3: "UNKNOWN", + 4: "INVISIBLE_VISIBILITY", + } + + _NAMES_TO_VALUES = { + "ACCEPTED": 0, + "REJECTED": 1, + "VIOLATED": 2, + "UNKNOWN": 3, + "INVISIBLE_VISIBILITY": 4, + } + class CompactionType: MINOR = 0 MERGE = 1 @@ -448,6 +471,86 @@ class ColumnUpdate: def __ne__(self, other): return not (self == other) +class DiskUsage: + """ + Attributes: + - tables + - usage + """ + + thrift_spec = ( + None, # 0 + (1, TType.LIST, 'tables', (TType.STRING,None), None, ), # 1 + (2, TType.I64, 'usage', None, None, ), # 2 + ) + + def __init__(self, tables=None, usage=None,): + self.tables = tables + self.usage = usage + + 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.LIST: + self.tables = [] + (_etype3, _size0) = iprot.readListBegin() + for _i4 in xrange(_size0): + _elem5 = iprot.readString(); + self.tables.append(_elem5) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I64: + self.usage = iprot.readI64(); + 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('DiskUsage') + if self.tables is not None: + oprot.writeFieldBegin('tables', TType.LIST, 1) + oprot.writeListBegin(TType.STRING, len(self.tables)) + for iter6 in self.tables: + oprot.writeString(iter6) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.usage is not None: + oprot.writeFieldBegin('usage', TType.I64, 2) + oprot.writeI64(self.usage) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class KeyValue: """ Attributes: @@ -550,11 +653,11 @@ class ScanResult: if fid == 1: if ftype == TType.LIST: self.results = [] - (_etype3, _size0) = iprot.readListBegin() - for _i4 in xrange(_size0): - _elem5 = KeyValue() - _elem5.read(iprot) - self.results.append(_elem5) + (_etype10, _size7) = iprot.readListBegin() + for _i11 in xrange(_size7): + _elem12 = KeyValue() + _elem12.read(iprot) + self.results.append(_elem12) iprot.readListEnd() else: iprot.skip(ftype) @@ -576,8 +679,8 @@ class ScanResult: if self.results is not None: oprot.writeFieldBegin('results', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.results)) - for iter6 in self.results: - iter6.write(oprot) + for iter13 in self.results: + iter13.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.more is not None: @@ -822,11 +925,11 @@ class IteratorSetting: elif fid == 4: if ftype == TType.MAP: self.properties = {} - (_ktype8, _vtype9, _size7 ) = iprot.readMapBegin() - for _i11 in xrange(_size7): - _key12 = iprot.readString(); - _val13 = iprot.readString(); - self.properties[_key12] = _val13 + (_ktype15, _vtype16, _size14 ) = iprot.readMapBegin() + for _i18 in xrange(_size14): + _key19 = iprot.readString(); + _val20 = iprot.readString(); + self.properties[_key19] = _val20 iprot.readMapEnd() else: iprot.skip(ftype) @@ -855,9 +958,9 @@ class IteratorSetting: if self.properties is not None: oprot.writeFieldBegin('properties', TType.MAP, 4) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties)) - for kiter14,viter15 in self.properties.items(): - oprot.writeString(kiter14) - oprot.writeString(viter15) + for kiter21,viter22 in self.properties.items(): + oprot.writeString(kiter21) + oprot.writeString(viter22) oprot.writeMapEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -916,10 +1019,10 @@ class ScanOptions: if fid == 1: if ftype == TType.SET: self.authorizations = set() - (_etype19, _size16) = iprot.readSetBegin() - for _i20 in xrange(_size16): - _elem21 = iprot.readString(); - self.authorizations.add(_elem21) + (_etype26, _size23) = iprot.readSetBegin() + for _i27 in xrange(_size23): + _elem28 = iprot.readString(); + self.authorizations.add(_elem28) iprot.readSetEnd() else: iprot.skip(ftype) @@ -932,22 +1035,22 @@ class ScanOptions: elif fid == 3: if ftype == TType.LIST: self.columns = [] - (_etype25, _size22) = iprot.readListBegin() - for _i26 in xrange(_size22): - _elem27 = ScanColumn() - _elem27.read(iprot) - self.columns.append(_elem27) + (_etype32, _size29) = iprot.readListBegin() + for _i33 in xrange(_size29): + _elem34 = ScanColumn() + _elem34.read(iprot) + self.columns.append(_elem34) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.iterators = [] - (_etype31, _size28) = iprot.readListBegin() - for _i32 in xrange(_size28): - _elem33 = IteratorSetting() - _elem33.read(iprot) - self.iterators.append(_elem33) + (_etype38, _size35) = iprot.readListBegin() + for _i39 in xrange(_size35): + _elem40 = IteratorSetting() + _elem40.read(iprot) + self.iterators.append(_elem40) iprot.readListEnd() else: iprot.skip(ftype) @@ -969,8 +1072,8 @@ class ScanOptions: if self.authorizations is not None: oprot.writeFieldBegin('authorizations', TType.SET, 1) oprot.writeSetBegin(TType.STRING, len(self.authorizations)) - for iter34 in self.authorizations: - oprot.writeString(iter34) + for iter41 in self.authorizations: + oprot.writeString(iter41) oprot.writeSetEnd() oprot.writeFieldEnd() if self.range is not None: @@ -980,15 +1083,15 @@ class ScanOptions: if self.columns is not None: oprot.writeFieldBegin('columns', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.columns)) - for iter35 in self.columns: - iter35.write(oprot) + for iter42 in self.columns: + iter42.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.iterators is not None: oprot.writeFieldBegin('iterators', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.iterators)) - for iter36 in self.iterators: - iter36.write(oprot) + for iter43 in self.iterators: + iter43.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.bufferSize is not None: @@ -1051,43 +1154,43 @@ class BatchScanOptions: if fid == 1: if ftype == TType.SET: self.authorizations = set() - (_etype40, _size37) = iprot.readSetBegin() - for _i41 in xrange(_size37): - _elem42 = iprot.readString(); - self.authorizations.add(_elem42) + (_etype47, _size44) = iprot.readSetBegin() + for _i48 in xrange(_size44): + _elem49 = iprot.readString(); + self.authorizations.add(_elem49) iprot.readSetEnd() else: iprot.skip(ftype) elif fid == 2: if ftype == TType.LIST: self.ranges = [] - (_etype46, _size43) = iprot.readListBegin() - for _i47 in xrange(_size43): - _elem48 = Range() - _elem48.read(iprot) - self.ranges.append(_elem48) + (_etype53, _size50) = iprot.readListBegin() + for _i54 in xrange(_size50): + _elem55 = Range() + _elem55.read(iprot) + self.ranges.append(_elem55) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.columns = [] - (_etype52, _size49) = iprot.readListBegin() - for _i53 in xrange(_size49): - _elem54 = ScanColumn() - _elem54.read(iprot) - self.columns.append(_elem54) + (_etype59, _size56) = iprot.readListBegin() + for _i60 in xrange(_size56): + _elem61 = ScanColumn() + _elem61.read(iprot) + self.columns.append(_elem61) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.iterators = [] - (_etype58, _size55) = iprot.readListBegin() - for _i59 in xrange(_size55): - _elem60 = IteratorSetting() - _elem60.read(iprot) - self.iterators.append(_elem60) + (_etype65, _size62) = iprot.readListBegin() + for _i66 in xrange(_size62): + _elem67 = IteratorSetting() + _elem67.read(iprot) + self.iterators.append(_elem67) iprot.readListEnd() else: iprot.skip(ftype) @@ -1109,29 +1212,29 @@ class BatchScanOptions: if self.authorizations is not None: oprot.writeFieldBegin('authorizations', TType.SET, 1) oprot.writeSetBegin(TType.STRING, len(self.authorizations)) - for iter61 in self.authorizations: - oprot.writeString(iter61) + for iter68 in self.authorizations: + oprot.writeString(iter68) oprot.writeSetEnd() oprot.writeFieldEnd() if self.ranges is not None: oprot.writeFieldBegin('ranges', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.ranges)) - for iter62 in self.ranges: - iter62.write(oprot) + for iter69 in self.ranges: + iter69.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.columns is not None: oprot.writeFieldBegin('columns', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.columns)) - for iter63 in self.columns: - iter63.write(oprot) + for iter70 in self.columns: + iter70.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.iterators is not None: oprot.writeFieldBegin('iterators', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.iterators)) - for iter64 in self.iterators: - iter64.write(oprot) + for iter71 in self.iterators: + iter71.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.threads is not None: @@ -1397,6 +1500,307 @@ class Column: def __ne__(self, other): return not (self == other) +class Condition: + """ + Attributes: + - column + - timestamp + - value + - iterators + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'column', (Column, Column.thrift_spec), None, ), # 1 + (2, TType.I64, 'timestamp', None, None, ), # 2 + (3, TType.STRING, 'value', None, None, ), # 3 + (4, TType.LIST, 'iterators', (TType.STRUCT,(IteratorSetting, IteratorSetting.thrift_spec)), None, ), # 4 + ) + + def __init__(self, column=None, timestamp=None, value=None, iterators=None,): + self.column = column + self.timestamp = timestamp + self.value = value + self.iterators = iterators + + 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.column = Column() + self.column.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I64: + self.timestamp = iprot.readI64(); + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.value = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.LIST: + self.iterators = [] + (_etype75, _size72) = iprot.readListBegin() + for _i76 in xrange(_size72): + _elem77 = IteratorSetting() + _elem77.read(iprot) + self.iterators.append(_elem77) + 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('Condition') + if self.column is not None: + oprot.writeFieldBegin('column', TType.STRUCT, 1) + self.column.write(oprot) + oprot.writeFieldEnd() + if self.timestamp is not None: + oprot.writeFieldBegin('timestamp', TType.I64, 2) + oprot.writeI64(self.timestamp) + oprot.writeFieldEnd() + if self.value is not None: + oprot.writeFieldBegin('value', TType.STRING, 3) + oprot.writeString(self.value) + oprot.writeFieldEnd() + if self.iterators is not None: + oprot.writeFieldBegin('iterators', TType.LIST, 4) + oprot.writeListBegin(TType.STRUCT, len(self.iterators)) + for iter78 in self.iterators: + iter78.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class ConditionalUpdates: + """ + Attributes: + - conditions + - updates + """ + + thrift_spec = ( + None, # 0 + None, # 1 + (2, TType.LIST, 'conditions', (TType.STRUCT,(Condition, Condition.thrift_spec)), None, ), # 2 + (3, TType.LIST, 'updates', (TType.STRUCT,(ColumnUpdate, ColumnUpdate.thrift_spec)), None, ), # 3 + ) + + def __init__(self, conditions=None, updates=None,): + self.conditions = conditions + self.updates = updates + + 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 == 2: + if ftype == TType.LIST: + self.conditions = [] + (_etype82, _size79) = iprot.readListBegin() + for _i83 in xrange(_size79): + _elem84 = Condition() + _elem84.read(iprot) + self.conditions.append(_elem84) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.LIST: + self.updates = [] + (_etype88, _size85) = iprot.readListBegin() + for _i89 in xrange(_size85): + _elem90 = ColumnUpdate() + _elem90.read(iprot) + self.updates.append(_elem90) + 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('ConditionalUpdates') + if self.conditions is not None: + oprot.writeFieldBegin('conditions', TType.LIST, 2) + oprot.writeListBegin(TType.STRUCT, len(self.conditions)) + for iter91 in self.conditions: + iter91.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.updates is not None: + oprot.writeFieldBegin('updates', TType.LIST, 3) + oprot.writeListBegin(TType.STRUCT, len(self.updates)) + for iter92 in self.updates: + iter92.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class ConditionalWriterOptions: + """ + Attributes: + - maxMemory + - timeoutMs + - threads + - authorizations + """ + + thrift_spec = ( + None, # 0 + (1, TType.I64, 'maxMemory', None, None, ), # 1 + (2, TType.I64, 'timeoutMs', None, None, ), # 2 + (3, TType.I32, 'threads', None, None, ), # 3 + (4, TType.SET, 'authorizations', (TType.STRING,None), None, ), # 4 + ) + + def __init__(self, maxMemory=None, timeoutMs=None, threads=None, authorizations=None,): + self.maxMemory = maxMemory + self.timeoutMs = timeoutMs + self.threads = threads + self.authorizations = authorizations + + 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.I64: + self.maxMemory = iprot.readI64(); + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I64: + self.timeoutMs = iprot.readI64(); + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.I32: + self.threads = iprot.readI32(); + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.SET: + self.authorizations = set() + (_etype96, _size93) = iprot.readSetBegin() + for _i97 in xrange(_size93): + _elem98 = iprot.readString(); + self.authorizations.add(_elem98) + iprot.readSetEnd() + 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('ConditionalWriterOptions') + if self.maxMemory is not None: + oprot.writeFieldBegin('maxMemory', TType.I64, 1) + oprot.writeI64(self.maxMemory) + oprot.writeFieldEnd() + if self.timeoutMs is not None: + oprot.writeFieldBegin('timeoutMs', TType.I64, 2) + oprot.writeI64(self.timeoutMs) + oprot.writeFieldEnd() + if self.threads is not None: + oprot.writeFieldBegin('threads', TType.I32, 3) + oprot.writeI32(self.threads) + oprot.writeFieldEnd() + if self.authorizations is not None: + oprot.writeFieldBegin('authorizations', TType.SET, 4) + oprot.writeSetBegin(TType.STRING, len(self.authorizations)) + for iter99 in self.authorizations: + oprot.writeString(iter99) + oprot.writeSetEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class ActiveScan: """ Attributes: @@ -1494,32 +1898,32 @@ class ActiveScan: elif fid == 9: if ftype == TType.LIST: self.columns = [] - (_etype68, _size65) = iprot.readListBegin() - for _i69 in xrange(_size65): - _elem70 = Column() - _elem70.read(iprot) - self.columns.append(_elem70) + (_etype103, _size100) = iprot.readListBegin() + for _i104 in xrange(_size100): + _elem105 = Column() + _elem105.read(iprot) + self.columns.append(_elem105) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 10: if ftype == TType.LIST: self.iterators = [] - (_etype74, _size71) = iprot.readListBegin() - for _i75 in xrange(_size71): - _elem76 = IteratorSetting() - _elem76.read(iprot) - self.iterators.append(_elem76) + (_etype109, _size106) = iprot.readListBegin() + for _i110 in xrange(_size106): + _elem111 = IteratorSetting() + _elem111.read(iprot) + self.iterators.append(_elem111) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 11: if ftype == TType.LIST: self.authorizations = [] - (_etype80, _size77) = iprot.readListBegin() - for _i81 in xrange(_size77): - _elem82 = iprot.readString(); - self.authorizations.append(_elem82) + (_etype115, _size112) = iprot.readListBegin() + for _i116 in xrange(_size112): + _elem117 = iprot.readString(); + self.authorizations.append(_elem117) iprot.readListEnd() else: iprot.skip(ftype) @@ -1568,22 +1972,22 @@ class ActiveScan: if self.columns is not None: oprot.writeFieldBegin('columns', TType.LIST, 9) oprot.writeListBegin(TType.STRUCT, len(self.columns)) - for iter83 in self.columns: - iter83.write(oprot) + for iter118 in self.columns: + iter118.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.iterators is not None: oprot.writeFieldBegin('iterators', TType.LIST, 10) oprot.writeListBegin(TType.STRUCT, len(self.iterators)) - for iter84 in self.iterators: - iter84.write(oprot) + for iter119 in self.iterators: + iter119.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.authorizations is not None: oprot.writeFieldBegin('authorizations', TType.LIST, 11) oprot.writeListBegin(TType.STRING, len(self.authorizations)) - for iter85 in self.authorizations: - oprot.writeString(iter85) + for iter120 in self.authorizations: + oprot.writeString(iter120) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -1668,10 +2072,10 @@ class ActiveCompaction: elif fid == 3: if ftype == TType.LIST: self.inputFiles = [] - (_etype89, _size86) = iprot.readListBegin() - for _i90 in xrange(_size86): - _elem91 = iprot.readString(); - self.inputFiles.append(_elem91) + (_etype124, _size121) = iprot.readListBegin() + for _i125 in xrange(_size121): + _elem126 = iprot.readString(); + self.inputFiles.append(_elem126) iprot.readListEnd() else: iprot.skip(ftype) @@ -1708,11 +2112,11 @@ class ActiveCompaction: elif fid == 10: if ftype == TType.LIST: self.iterators = [] - (_etype95, _size92) = iprot.readListBegin() - for _i96 in xrange(_size92): - _elem97 = IteratorSetting() - _elem97.read(iprot) - self.iterators.append(_elem97) + (_etype130, _size127) = iprot.readListBegin() + for _i131 in xrange(_size127): + _elem132 = IteratorSetting() + _elem132.read(iprot) + self.iterators.append(_elem132) iprot.readListEnd() else: iprot.skip(ftype) @@ -1737,8 +2141,8 @@ class ActiveCompaction: if self.inputFiles is not None: oprot.writeFieldBegin('inputFiles', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.inputFiles)) - for iter98 in self.inputFiles: - oprot.writeString(iter98) + for iter133 in self.inputFiles: + oprot.writeString(iter133) oprot.writeListEnd() oprot.writeFieldEnd() if self.outputFile is not None: @@ -1768,8 +2172,8 @@ class ActiveCompaction: if self.iterators is not None: oprot.writeFieldBegin('iterators', TType.LIST, 10) oprot.writeListBegin(TType.STRUCT, len(self.iterators)) - for iter99 in self.iterators: - iter99.write(oprot) + for iter134 in self.iterators: + iter134.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop()
http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/ruby/accumulo_proxy.rb ---------------------------------------------------------------------- diff --git a/proxy/src/main/ruby/accumulo_proxy.rb b/proxy/src/main/ruby/accumulo_proxy.rb index a7ae2db..4c8f484 100644 --- a/proxy/src/main/ruby/accumulo_proxy.rb +++ b/proxy/src/main/ruby/accumulo_proxy.rb @@ -263,6 +263,24 @@ module Accumulo return end + def getDiskUsage(login, tables) + send_getDiskUsage(login, tables) + return recv_getDiskUsage() + end + + def send_getDiskUsage(login, tables) + send_message('getDiskUsage', GetDiskUsage_args, :login => login, :tables => tables) + end + + def recv_getDiskUsage() + result = receive_message(GetDiskUsage_result) + return result.success unless result.success.nil? + raise result.ouch1 unless result.ouch1.nil? + raise result.ouch2 unless result.ouch2.nil? + raise result.ouch3 unless result.ouch3.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'getDiskUsage failed: unknown result') + end + def getLocalityGroups(login, tableName) send_getLocalityGroups(login, tableName) return recv_getLocalityGroups() @@ -455,13 +473,13 @@ module Accumulo return end - def offlineTable(login, tableName) - send_offlineTable(login, tableName) + def offlineTable(login, tableName, wait) + send_offlineTable(login, tableName, wait) recv_offlineTable() end - def send_offlineTable(login, tableName) - send_message('offlineTable', OfflineTable_args, :login => login, :tableName => tableName) + def send_offlineTable(login, tableName, wait) + send_message('offlineTable', OfflineTable_args, :login => login, :tableName => tableName, :wait => wait) end def recv_offlineTable() @@ -472,13 +490,13 @@ module Accumulo return end - def onlineTable(login, tableName) - send_onlineTable(login, tableName) + def onlineTable(login, tableName, wait) + send_onlineTable(login, tableName, wait) recv_onlineTable() end - def send_onlineTable(login, tableName) - send_message('onlineTable', OnlineTable_args, :login => login, :tableName => tableName) + def send_onlineTable(login, tableName, wait) + send_message('onlineTable', OnlineTable_args, :login => login, :tableName => tableName, :wait => wait) end def recv_onlineTable() @@ -1201,6 +1219,74 @@ module Accumulo return end + def updateRowConditionally(login, tableName, row, updates) + send_updateRowConditionally(login, tableName, row, updates) + return recv_updateRowConditionally() + end + + def send_updateRowConditionally(login, tableName, row, updates) + send_message('updateRowConditionally', UpdateRowConditionally_args, :login => login, :tableName => tableName, :row => row, :updates => updates) + end + + def recv_updateRowConditionally() + result = receive_message(UpdateRowConditionally_result) + return result.success unless result.success.nil? + raise result.ouch1 unless result.ouch1.nil? + raise result.ouch2 unless result.ouch2.nil? + raise result.ouch3 unless result.ouch3.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'updateRowConditionally failed: unknown result') + end + + def createConditionalWriter(login, tableName, options) + send_createConditionalWriter(login, tableName, options) + return recv_createConditionalWriter() + end + + def send_createConditionalWriter(login, tableName, options) + send_message('createConditionalWriter', CreateConditionalWriter_args, :login => login, :tableName => tableName, :options => options) + end + + def recv_createConditionalWriter() + result = receive_message(CreateConditionalWriter_result) + return result.success unless result.success.nil? + raise result.ouch1 unless result.ouch1.nil? + raise result.ouch2 unless result.ouch2.nil? + raise result.ouch3 unless result.ouch3.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'createConditionalWriter failed: unknown result') + end + + def updateRowsConditionally(conditionalWriter, updates) + send_updateRowsConditionally(conditionalWriter, updates) + return recv_updateRowsConditionally() + end + + def send_updateRowsConditionally(conditionalWriter, updates) + send_message('updateRowsConditionally', UpdateRowsConditionally_args, :conditionalWriter => conditionalWriter, :updates => updates) + end + + def recv_updateRowsConditionally() + result = receive_message(UpdateRowsConditionally_result) + return result.success unless result.success.nil? + raise result.ouch1 unless result.ouch1.nil? + raise result.ouch2 unless result.ouch2.nil? + raise result.ouch3 unless result.ouch3.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'updateRowsConditionally failed: unknown result') + end + + def closeConditionalWriter(conditionalWriter) + send_closeConditionalWriter(conditionalWriter) + recv_closeConditionalWriter() + end + + def send_closeConditionalWriter(conditionalWriter) + send_message('closeConditionalWriter', CloseConditionalWriter_args, :conditionalWriter => conditionalWriter) + end + + def recv_closeConditionalWriter() + result = receive_message(CloseConditionalWriter_result) + return + end + def getRowRange(row) send_getRowRange(row) return recv_getRowRange() @@ -1440,6 +1526,21 @@ module Accumulo write_result(result, oprot, 'flushTable', seqid) end + def process_getDiskUsage(seqid, iprot, oprot) + args = read_args(iprot, GetDiskUsage_args) + result = GetDiskUsage_result.new() + begin + result.success = @handler.getDiskUsage(args.login, args.tables) + rescue ::Accumulo::AccumuloException => ouch1 + result.ouch1 = ouch1 + rescue ::Accumulo::AccumuloSecurityException => ouch2 + result.ouch2 = ouch2 + rescue ::Accumulo::TableNotFoundException => ouch3 + result.ouch3 = ouch3 + end + write_result(result, oprot, 'getDiskUsage', seqid) + end + def process_getLocalityGroups(seqid, iprot, oprot) args = read_args(iprot, GetLocalityGroups_args) result = GetLocalityGroups_result.new() @@ -1601,7 +1702,7 @@ module Accumulo args = read_args(iprot, OfflineTable_args) result = OfflineTable_result.new() begin - @handler.offlineTable(args.login, args.tableName) + @handler.offlineTable(args.login, args.tableName, args.wait) rescue ::Accumulo::AccumuloException => ouch1 result.ouch1 = ouch1 rescue ::Accumulo::AccumuloSecurityException => ouch2 @@ -1616,7 +1717,7 @@ module Accumulo args = read_args(iprot, OnlineTable_args) result = OnlineTable_result.new() begin - @handler.onlineTable(args.login, args.tableName) + @handler.onlineTable(args.login, args.tableName, args.wait) rescue ::Accumulo::AccumuloException => ouch1 result.ouch1 = ouch1 rescue ::Accumulo::AccumuloSecurityException => ouch2 @@ -2197,6 +2298,58 @@ module Accumulo write_result(result, oprot, 'closeWriter', seqid) end + def process_updateRowConditionally(seqid, iprot, oprot) + args = read_args(iprot, UpdateRowConditionally_args) + result = UpdateRowConditionally_result.new() + begin + result.success = @handler.updateRowConditionally(args.login, args.tableName, args.row, args.updates) + rescue ::Accumulo::AccumuloException => ouch1 + result.ouch1 = ouch1 + rescue ::Accumulo::AccumuloSecurityException => ouch2 + result.ouch2 = ouch2 + rescue ::Accumulo::TableNotFoundException => ouch3 + result.ouch3 = ouch3 + end + write_result(result, oprot, 'updateRowConditionally', seqid) + end + + def process_createConditionalWriter(seqid, iprot, oprot) + args = read_args(iprot, CreateConditionalWriter_args) + result = CreateConditionalWriter_result.new() + begin + result.success = @handler.createConditionalWriter(args.login, args.tableName, args.options) + rescue ::Accumulo::AccumuloException => ouch1 + result.ouch1 = ouch1 + rescue ::Accumulo::AccumuloSecurityException => ouch2 + result.ouch2 = ouch2 + rescue ::Accumulo::TableNotFoundException => ouch3 + result.ouch3 = ouch3 + end + write_result(result, oprot, 'createConditionalWriter', seqid) + end + + def process_updateRowsConditionally(seqid, iprot, oprot) + args = read_args(iprot, UpdateRowsConditionally_args) + result = UpdateRowsConditionally_result.new() + begin + result.success = @handler.updateRowsConditionally(args.conditionalWriter, args.updates) + rescue ::Accumulo::UnknownWriter => ouch1 + result.ouch1 = ouch1 + rescue ::Accumulo::AccumuloException => ouch2 + result.ouch2 = ouch2 + rescue ::Accumulo::AccumuloSecurityException => ouch3 + result.ouch3 = ouch3 + end + write_result(result, oprot, 'updateRowsConditionally', seqid) + end + + def process_closeConditionalWriter(seqid, iprot, oprot) + args = read_args(iprot, CloseConditionalWriter_args) + result = CloseConditionalWriter_result.new() + @handler.closeConditionalWriter(args.conditionalWriter) + write_result(result, oprot, 'closeConditionalWriter', seqid) + end + def process_getRowRange(seqid, iprot, oprot) args = read_args(iprot, GetRowRange_args) result = GetRowRange_result.new() @@ -2794,6 +2947,46 @@ module Accumulo ::Thrift::Struct.generate_accessors self end + class GetDiskUsage_args + include ::Thrift::Struct, ::Thrift::Struct_Union + LOGIN = 1 + TABLES = 2 + + FIELDS = { + LOGIN => {:type => ::Thrift::Types::STRING, :name => 'login', :binary => true}, + TABLES => {:type => ::Thrift::Types::SET, :name => 'tables', :element => {:type => ::Thrift::Types::STRING}} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class GetDiskUsage_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + OUCH1 = 1 + OUCH2 = 2 + OUCH3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Accumulo::DiskUsage}}, + OUCH1 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch1', :class => ::Accumulo::AccumuloException}, + OUCH2 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch2', :class => ::Accumulo::AccumuloSecurityException}, + OUCH3 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch3', :class => ::Accumulo::TableNotFoundException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class GetLocalityGroups_args include ::Thrift::Struct, ::Thrift::Struct_Union LOGIN = 1 @@ -3255,10 +3448,12 @@ module Accumulo include ::Thrift::Struct, ::Thrift::Struct_Union LOGIN = 1 TABLENAME = 2 + WAIT = 3 FIELDS = { LOGIN => {:type => ::Thrift::Types::STRING, :name => 'login', :binary => true}, - TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'} + TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'}, + WAIT => {:type => ::Thrift::Types::BOOL, :name => 'wait', :default => false} } def struct_fields; FIELDS; end @@ -3293,10 +3488,12 @@ module Accumulo include ::Thrift::Struct, ::Thrift::Struct_Union LOGIN = 1 TABLENAME = 2 + WAIT = 3 FIELDS = { LOGIN => {:type => ::Thrift::Types::STRING, :name => 'login', :binary => true}, - TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'} + TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'}, + WAIT => {:type => ::Thrift::Types::BOOL, :name => 'wait', :default => false} } def struct_fields; FIELDS; end @@ -4998,6 +5195,166 @@ module Accumulo ::Thrift::Struct.generate_accessors self end + class UpdateRowConditionally_args + include ::Thrift::Struct, ::Thrift::Struct_Union + LOGIN = 1 + TABLENAME = 2 + ROW = 3 + UPDATES = 4 + + FIELDS = { + LOGIN => {:type => ::Thrift::Types::STRING, :name => 'login', :binary => true}, + TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'}, + ROW => {:type => ::Thrift::Types::STRING, :name => 'row', :binary => true}, + UPDATES => {:type => ::Thrift::Types::STRUCT, :name => 'updates', :class => ::Accumulo::ConditionalUpdates} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class UpdateRowConditionally_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + OUCH1 = 1 + OUCH2 = 2 + OUCH3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::I32, :name => 'success', :enum_class => ::Accumulo::ConditionalStatus}, + OUCH1 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch1', :class => ::Accumulo::AccumuloException}, + OUCH2 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch2', :class => ::Accumulo::AccumuloSecurityException}, + OUCH3 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch3', :class => ::Accumulo::TableNotFoundException} + } + + def struct_fields; FIELDS; end + + def validate + unless @success.nil? || ::Accumulo::ConditionalStatus::VALID_VALUES.include?(@success) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field success!') + end + end + + ::Thrift::Struct.generate_accessors self + end + + class CreateConditionalWriter_args + include ::Thrift::Struct, ::Thrift::Struct_Union + LOGIN = 1 + TABLENAME = 2 + OPTIONS = 3 + + FIELDS = { + LOGIN => {:type => ::Thrift::Types::STRING, :name => 'login', :binary => true}, + TABLENAME => {:type => ::Thrift::Types::STRING, :name => 'tableName'}, + OPTIONS => {:type => ::Thrift::Types::STRUCT, :name => 'options', :class => ::Accumulo::ConditionalWriterOptions} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class CreateConditionalWriter_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + OUCH1 = 1 + OUCH2 = 2 + OUCH3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'}, + OUCH1 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch1', :class => ::Accumulo::AccumuloException}, + OUCH2 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch2', :class => ::Accumulo::AccumuloSecurityException}, + OUCH3 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch3', :class => ::Accumulo::TableNotFoundException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class UpdateRowsConditionally_args + include ::Thrift::Struct, ::Thrift::Struct_Union + CONDITIONALWRITER = 1 + UPDATES = 2 + + FIELDS = { + CONDITIONALWRITER => {:type => ::Thrift::Types::STRING, :name => 'conditionalWriter'}, + UPDATES => {:type => ::Thrift::Types::MAP, :name => 'updates', :key => {:type => ::Thrift::Types::STRING, :binary => true}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::Accumulo::ConditionalUpdates}} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class UpdateRowsConditionally_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + OUCH1 = 1 + OUCH2 = 2 + OUCH3 = 3 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::MAP, :name => 'success', :key => {:type => ::Thrift::Types::STRING, :binary => true}, :value => {:type => ::Thrift::Types::I32, :enum_class => ::Accumulo::ConditionalStatus}}, + OUCH1 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch1', :class => ::Accumulo::UnknownWriter}, + OUCH2 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch2', :class => ::Accumulo::AccumuloException}, + OUCH3 => {:type => ::Thrift::Types::STRUCT, :name => 'ouch3', :class => ::Accumulo::AccumuloSecurityException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class CloseConditionalWriter_args + include ::Thrift::Struct, ::Thrift::Struct_Union + CONDITIONALWRITER = 1 + + FIELDS = { + CONDITIONALWRITER => {:type => ::Thrift::Types::STRING, :name => 'conditionalWriter'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class CloseConditionalWriter_result + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class GetRowRange_args include ::Thrift::Struct, ::Thrift::Struct_Union ROW = 1 http://git-wip-us.apache.org/repos/asf/accumulo/blob/3298263a/proxy/src/main/ruby/proxy_types.rb ---------------------------------------------------------------------- diff --git a/proxy/src/main/ruby/proxy_types.rb b/proxy/src/main/ruby/proxy_types.rb index b267b62..8b9cbf0 100644 --- a/proxy/src/main/ruby/proxy_types.rb +++ b/proxy/src/main/ruby/proxy_types.rb @@ -71,6 +71,16 @@ module Accumulo VALID_VALUES = Set.new([IDLE, RUNNING, QUEUED]).freeze end + module ConditionalStatus + ACCEPTED = 0 + REJECTED = 1 + VIOLATED = 2 + UNKNOWN = 3 + INVISIBLE_VISIBILITY = 4 + VALUE_MAP = {0 => "ACCEPTED", 1 => "REJECTED", 2 => "VIOLATED", 3 => "UNKNOWN", 4 => "INVISIBLE_VISIBILITY"} + VALID_VALUES = Set.new([ACCEPTED, REJECTED, VIOLATED, UNKNOWN, INVISIBLE_VISIBILITY]).freeze + end + module CompactionType MINOR = 0 MERGE = 1 @@ -155,6 +165,24 @@ module Accumulo ::Thrift::Struct.generate_accessors self end + class DiskUsage + include ::Thrift::Struct, ::Thrift::Struct_Union + TABLES = 1 + USAGE = 2 + + FIELDS = { + TABLES => {:type => ::Thrift::Types::LIST, :name => 'tables', :element => {:type => ::Thrift::Types::STRING}}, + USAGE => {:type => ::Thrift::Types::I64, :name => 'usage'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class KeyValue include ::Thrift::Struct, ::Thrift::Struct_Union KEY = 1 @@ -359,6 +387,68 @@ module Accumulo ::Thrift::Struct.generate_accessors self end + class Condition + include ::Thrift::Struct, ::Thrift::Struct_Union + COLUMN = 1 + TIMESTAMP = 2 + VALUE = 3 + ITERATORS = 4 + + FIELDS = { + COLUMN => {:type => ::Thrift::Types::STRUCT, :name => 'column', :class => ::Accumulo::Column}, + TIMESTAMP => {:type => ::Thrift::Types::I64, :name => 'timestamp', :optional => true}, + VALUE => {:type => ::Thrift::Types::STRING, :name => 'value', :binary => true, :optional => true}, + ITERATORS => {:type => ::Thrift::Types::LIST, :name => 'iterators', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Accumulo::IteratorSetting}, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class ConditionalUpdates + include ::Thrift::Struct, ::Thrift::Struct_Union + CONDITIONS = 2 + UPDATES = 3 + + FIELDS = { + CONDITIONS => {:type => ::Thrift::Types::LIST, :name => 'conditions', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Accumulo::Condition}}, + UPDATES => {:type => ::Thrift::Types::LIST, :name => 'updates', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Accumulo::ColumnUpdate}} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class ConditionalWriterOptions + include ::Thrift::Struct, ::Thrift::Struct_Union + MAXMEMORY = 1 + TIMEOUTMS = 2 + THREADS = 3 + AUTHORIZATIONS = 4 + + FIELDS = { + MAXMEMORY => {:type => ::Thrift::Types::I64, :name => 'maxMemory', :optional => true}, + TIMEOUTMS => {:type => ::Thrift::Types::I64, :name => 'timeoutMs', :optional => true}, + THREADS => {:type => ::Thrift::Types::I32, :name => 'threads', :optional => true}, + AUTHORIZATIONS => {:type => ::Thrift::Types::SET, :name => 'authorizations', :element => {:type => ::Thrift::Types::STRING, :binary => true}, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class ActiveScan include ::Thrift::Struct, ::Thrift::Struct_Union CLIENT = 1
