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

Inherits:
Object
  • Object
show all
Includes:
Thrift::Processor
Defined in:
lib/thrift/hbase.rb

Instance Method Summary collapse

Instance Method Details

#process_atomicIncrement(seqid, iprot, oprot) ⇒ Object 



805
806
807
808
809
810
811
812
813
814
815
816
 
# 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

#process_compact(seqid, iprot, oprot) ⇒ Object 



595
596
597
598
599
600
601
602
603
604
 
# 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

#process_createTable(seqid, iprot, oprot) ⇒ Object 



650
651
652
653
654
655
656
657
658
659
660
661
662
663
 
# 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

#process_deleteAll(seqid, iprot, oprot) ⇒ Object 



818
819
820
821
822
823
824
825
826
827
 
# 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

#process_deleteAllRow(seqid, iprot, oprot) ⇒ Object 



840
841
842
843
844
845
846
847
848
849
 
# 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

#process_deleteAllRowTs(seqid, iprot, oprot) ⇒ Object 



851
852
853
854
855
856
857
858
859
860
 
# 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

#process_deleteAllTs(seqid, iprot, oprot) ⇒ Object 



829
830
831
832
833
834
835
836
837
838
 
# 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

#process_deleteTable(seqid, iprot, oprot) ⇒ Object 



665
666
667
668
669
670
671
672
673
674
 
# 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

#process_disableTable(seqid, iprot, oprot) ⇒ Object 



573
574
575
576
577
578
579
580
581
582
 
# 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

#process_enableTable(seqid, iprot, oprot) ⇒ Object 



562
563
564
565
566
567
568
569
570
571
 
# 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

#process_get(seqid, iprot, oprot) ⇒ Object 



676
677
678
679
680
681
682
683
684
685
 
# 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

#process_getColumnDescriptors(seqid, iprot, oprot) ⇒ Object 



628
629
630
631
632
633
634
635
636
637
 
# 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

#process_getRow(seqid, iprot, oprot) ⇒ Object 



709
710
711
712
713
714
715
716
717
718
 
# 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

#process_getRowTs(seqid, iprot, oprot) ⇒ Object 



731
732
733
734
735
736
737
738
739
740
 
# 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

#process_getRowWithColumns(seqid, iprot, oprot) ⇒ Object 



720
721
722
723
724
725
726
727
728
729
 
# 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

#process_getRowWithColumnsTs(seqid, iprot, oprot) ⇒ Object 



742
743
744
745
746
747
748
749
750
751
 
# 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

#process_getTableNames(seqid, iprot, oprot) ⇒ Object 



617
618
619
620
621
622
623
624
625
626
 
# 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

#process_getTableRegions(seqid, iprot, oprot) ⇒ Object 



639
640
641
642
643
644
645
646
647
648
 
# 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

#process_getVer(seqid, iprot, oprot) ⇒ Object 



687
688
689
690
691
692
693
694
695
696
 
# 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

#process_getVerTs(seqid, iprot, oprot) ⇒ Object 



698
699
700
701
702
703
704
705
706
707
 
# 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

#process_isTableEnabled(seqid, iprot, oprot) ⇒ Object 



584
585
586
587
588
589
590
591
592
593
 
# 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

#process_majorCompact(seqid, iprot, oprot) ⇒ Object 



606
607
608
609
610
611
612
613
614
615
 
# 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

#process_mutateRow(seqid, iprot, oprot) ⇒ Object 



753
754
755
756
757
758
759
760
761
762
763
764
 
# 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

#process_mutateRows(seqid, iprot, oprot) ⇒ Object 



779
780
781
782
783
784
785
786
787
788
789
790
 
# 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

#process_mutateRowsTs(seqid, iprot, oprot) ⇒ Object 



792
793
794
795
796
797
798
799
800
801
802
803
 
# 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

#process_mutateRowTs(seqid, iprot, oprot) ⇒ Object 



766
767
768
769
770
771
772
773
774
775
776
777
 
# 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

#process_scannerClose(seqid, iprot, oprot) ⇒ Object 



943
944
945
946
947
948
949
950
951
952
953
954
 
# 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

#process_scannerGet(seqid, iprot, oprot) ⇒ Object 



917
918
919
920
921
922
923
924
925
926
927
928
 
# 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

#process_scannerGetList(seqid, iprot, oprot) ⇒ Object 



930
931
932
933
934
935
936
937
938
939
940
941
 
# 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

#process_scannerOpen(seqid, iprot, oprot) ⇒ Object 



862
863
864
865
866
867
868
869
870
871
 
# 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

#process_scannerOpenTs(seqid, iprot, oprot) ⇒ Object 



895
896
897
898
899
900
901
902
903
904
 
# 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

#process_scannerOpenWithPrefix(seqid, iprot, oprot) ⇒ Object 



884
885
886
887
888
889
890
891
892
893
 
# 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

#process_scannerOpenWithStop(seqid, iprot, oprot) ⇒ Object 



873
874
875
876
877
878
879
880
881
882
 
# 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

#process_scannerOpenWithStopTs(seqid, iprot, oprot) ⇒ Object 



906
907
908
909
910
911
912
913
914
915
 
# 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