Apache::Hadoop::Hbase::Thrift::Hbase::Processor

# File lib/thrift/hbase.rb, line 805
def process_atomicIncrement(seqid, iprot, oprot)
  args = read_args(iprot, AtomicIncrement_args)
  result = AtomicIncrement_result.new()
  begin
    result.success = @handler.atomicIncrement(args.tableName, args.row, args.column, args.value)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'atomicIncrement', seqid)
end

# File lib/thrift/hbase.rb, line 595
def process_compact(seqid, iprot, oprot)
  args = read_args(iprot, Compact_args)
  result = Compact_result.new()
  begin
    @handler.compact(args.tableNameOrRegionName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'compact', seqid)
end

# File lib/thrift/hbase.rb, line 650
def process_createTable(seqid, iprot, oprot)
  args = read_args(iprot, CreateTable_args)
  result = CreateTable_result.new()
  begin
    @handler.createTable(args.tableName, args.columnFamilies)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  rescue Apache::Hadoop::Hbase::Thrift::AlreadyExists => exist
    result.exist = exist
  end
  write_result(result, oprot, 'createTable', seqid)
end

# File lib/thrift/hbase.rb, line 818
def process_deleteAll(seqid, iprot, oprot)
  args = read_args(iprot, DeleteAll_args)
  result = DeleteAll_result.new()
  begin
    @handler.deleteAll(args.tableName, args.row, args.column)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'deleteAll', seqid)
end

# File lib/thrift/hbase.rb, line 840
def process_deleteAllRow(seqid, iprot, oprot)
  args = read_args(iprot, DeleteAllRow_args)
  result = DeleteAllRow_result.new()
  begin
    @handler.deleteAllRow(args.tableName, args.row)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'deleteAllRow', seqid)
end

# File lib/thrift/hbase.rb, line 851
def process_deleteAllRowTs(seqid, iprot, oprot)
  args = read_args(iprot, DeleteAllRowTs_args)
  result = DeleteAllRowTs_result.new()
  begin
    @handler.deleteAllRowTs(args.tableName, args.row, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'deleteAllRowTs', seqid)
end

# File lib/thrift/hbase.rb, line 829
def process_deleteAllTs(seqid, iprot, oprot)
  args = read_args(iprot, DeleteAllTs_args)
  result = DeleteAllTs_result.new()
  begin
    @handler.deleteAllTs(args.tableName, args.row, args.column, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'deleteAllTs', seqid)
end

# File lib/thrift/hbase.rb, line 665
def process_deleteTable(seqid, iprot, oprot)
  args = read_args(iprot, DeleteTable_args)
  result = DeleteTable_result.new()
  begin
    @handler.deleteTable(args.tableName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'deleteTable', seqid)
end

# File lib/thrift/hbase.rb, line 573
def process_disableTable(seqid, iprot, oprot)
  args = read_args(iprot, DisableTable_args)
  result = DisableTable_result.new()
  begin
    @handler.disableTable(args.tableName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'disableTable', seqid)
end

# File lib/thrift/hbase.rb, line 562
def process_enableTable(seqid, iprot, oprot)
  args = read_args(iprot, EnableTable_args)
  result = EnableTable_result.new()
  begin
    @handler.enableTable(args.tableName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'enableTable', seqid)
end

# File lib/thrift/hbase.rb, line 676
def process_get(seqid, iprot, oprot)
  args = read_args(iprot, Get_args)
  result = Get_result.new()
  begin
    result.success = @handler.get(args.tableName, args.row, args.column)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'get', seqid)
end

# File lib/thrift/hbase.rb, line 628
def process_getColumnDescriptors(seqid, iprot, oprot)
  args = read_args(iprot, GetColumnDescriptors_args)
  result = GetColumnDescriptors_result.new()
  begin
    result.success = @handler.getColumnDescriptors(args.tableName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getColumnDescriptors', seqid)
end

# File lib/thrift/hbase.rb, line 709
def process_getRow(seqid, iprot, oprot)
  args = read_args(iprot, GetRow_args)
  result = GetRow_result.new()
  begin
    result.success = @handler.getRow(args.tableName, args.row)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getRow', seqid)
end

# File lib/thrift/hbase.rb, line 731
def process_getRowTs(seqid, iprot, oprot)
  args = read_args(iprot, GetRowTs_args)
  result = GetRowTs_result.new()
  begin
    result.success = @handler.getRowTs(args.tableName, args.row, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getRowTs', seqid)
end

# File lib/thrift/hbase.rb, line 720
def process_getRowWithColumns(seqid, iprot, oprot)
  args = read_args(iprot, GetRowWithColumns_args)
  result = GetRowWithColumns_result.new()
  begin
    result.success = @handler.getRowWithColumns(args.tableName, args.row, args.columns)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getRowWithColumns', seqid)
end

# File lib/thrift/hbase.rb, line 742
def process_getRowWithColumnsTs(seqid, iprot, oprot)
  args = read_args(iprot, GetRowWithColumnsTs_args)
  result = GetRowWithColumnsTs_result.new()
  begin
    result.success = @handler.getRowWithColumnsTs(args.tableName, args.row, args.columns, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getRowWithColumnsTs', seqid)
end

# File lib/thrift/hbase.rb, line 617
def process_getTableNames(seqid, iprot, oprot)
  args = read_args(iprot, GetTableNames_args)
  result = GetTableNames_result.new()
  begin
    result.success = @handler.getTableNames()
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getTableNames', seqid)
end

# File lib/thrift/hbase.rb, line 639
def process_getTableRegions(seqid, iprot, oprot)
  args = read_args(iprot, GetTableRegions_args)
  result = GetTableRegions_result.new()
  begin
    result.success = @handler.getTableRegions(args.tableName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getTableRegions', seqid)
end

# File lib/thrift/hbase.rb, line 687
def process_getVer(seqid, iprot, oprot)
  args = read_args(iprot, GetVer_args)
  result = GetVer_result.new()
  begin
    result.success = @handler.getVer(args.tableName, args.row, args.column, args.numVersions)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getVer', seqid)
end

# File lib/thrift/hbase.rb, line 698
def process_getVerTs(seqid, iprot, oprot)
  args = read_args(iprot, GetVerTs_args)
  result = GetVerTs_result.new()
  begin
    result.success = @handler.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'getVerTs', seqid)
end

# File lib/thrift/hbase.rb, line 584
def process_isTableEnabled(seqid, iprot, oprot)
  args = read_args(iprot, IsTableEnabled_args)
  result = IsTableEnabled_result.new()
  begin
    result.success = @handler.isTableEnabled(args.tableName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'isTableEnabled', seqid)
end

# File lib/thrift/hbase.rb, line 606
def process_majorCompact(seqid, iprot, oprot)
  args = read_args(iprot, MajorCompact_args)
  result = MajorCompact_result.new()
  begin
    @handler.majorCompact(args.tableNameOrRegionName)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'majorCompact', seqid)
end

# File lib/thrift/hbase.rb, line 753
def process_mutateRow(seqid, iprot, oprot)
  args = read_args(iprot, MutateRow_args)
  result = MutateRow_result.new()
  begin
    @handler.mutateRow(args.tableName, args.row, args.mutations)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'mutateRow', seqid)
end

# File lib/thrift/hbase.rb, line 766
def process_mutateRowTs(seqid, iprot, oprot)
  args = read_args(iprot, MutateRowTs_args)
  result = MutateRowTs_result.new()
  begin
    @handler.mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'mutateRowTs', seqid)
end

# File lib/thrift/hbase.rb, line 779
def process_mutateRows(seqid, iprot, oprot)
  args = read_args(iprot, MutateRows_args)
  result = MutateRows_result.new()
  begin
    @handler.mutateRows(args.tableName, args.rowBatches)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'mutateRows', seqid)
end

# File lib/thrift/hbase.rb, line 792
def process_mutateRowsTs(seqid, iprot, oprot)
  args = read_args(iprot, MutateRowsTs_args)
  result = MutateRowsTs_result.new()
  begin
    @handler.mutateRowsTs(args.tableName, args.rowBatches, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'mutateRowsTs', seqid)
end

# File lib/thrift/hbase.rb, line 943
def process_scannerClose(seqid, iprot, oprot)
  args = read_args(iprot, ScannerClose_args)
  result = ScannerClose_result.new()
  begin
    @handler.scannerClose(args.id)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'scannerClose', seqid)
end

# File lib/thrift/hbase.rb, line 917
def process_scannerGet(seqid, iprot, oprot)
  args = read_args(iprot, ScannerGet_args)
  result = ScannerGet_result.new()
  begin
    result.success = @handler.scannerGet(args.id)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'scannerGet', seqid)
end

# File lib/thrift/hbase.rb, line 930
def process_scannerGetList(seqid, iprot, oprot)
  args = read_args(iprot, ScannerGetList_args)
  result = ScannerGetList_result.new()
  begin
    result.success = @handler.scannerGetList(args.id, args.nbRows)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  rescue Apache::Hadoop::Hbase::Thrift::IllegalArgument => ia
    result.ia = ia
  end
  write_result(result, oprot, 'scannerGetList', seqid)
end

# File lib/thrift/hbase.rb, line 862
def process_scannerOpen(seqid, iprot, oprot)
  args = read_args(iprot, ScannerOpen_args)
  result = ScannerOpen_result.new()
  begin
    result.success = @handler.scannerOpen(args.tableName, args.startRow, args.columns)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'scannerOpen', seqid)
end

# File lib/thrift/hbase.rb, line 895
def process_scannerOpenTs(seqid, iprot, oprot)
  args = read_args(iprot, ScannerOpenTs_args)
  result = ScannerOpenTs_result.new()
  begin
    result.success = @handler.scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'scannerOpenTs', seqid)
end

# File lib/thrift/hbase.rb, line 884
def process_scannerOpenWithPrefix(seqid, iprot, oprot)
  args = read_args(iprot, ScannerOpenWithPrefix_args)
  result = ScannerOpenWithPrefix_result.new()
  begin
    result.success = @handler.scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'scannerOpenWithPrefix', seqid)
end

# File lib/thrift/hbase.rb, line 873
def process_scannerOpenWithStop(seqid, iprot, oprot)
  args = read_args(iprot, ScannerOpenWithStop_args)
  result = ScannerOpenWithStop_result.new()
  begin
    result.success = @handler.scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'scannerOpenWithStop', seqid)
end

# File lib/thrift/hbase.rb, line 906
def process_scannerOpenWithStopTs(seqid, iprot, oprot)
  args = read_args(iprot, ScannerOpenWithStopTs_args)
  result = ScannerOpenWithStopTs_result.new()
  begin
    result.success = @handler.scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp)
  rescue Apache::Hadoop::Hbase::Thrift::IOError => io
    result.io = io
  end
  write_result(result, oprot, 'scannerOpenWithStopTs', seqid)
end