hbase-ruby 1.1.0

data/lib/hbase/operation/scanner_operation.rb

@@ -0,0 +1,82 @@
+module HBase
+  module Operation
+    module ScannerOperation
+      # Trying to maintain some API stability for now
+      def open_scanner(table_name, columns, start_row, stop_row = nil, timestamp = nil)
+        warn "[DEPRECATION] This method is deprecated. Use #open_scanner(table_name, options) instead."
+
+        open_scanner(table_name, {:columns => columns, :start_row => start_row, :stop_row => stop_row, :timestamp => timestamp})
+      end
+
+      def open_scanner(table_name, options = {})
+        raise ArgumentError, "options should be given as a Hash" unless options.instance_of? Hash
+        columns = options.delete(:columns)
+
+        begin
+          request = Request::ScannerRequest.new(table_name)
+
+          xml_data = "<?xml version='1.0' encoding='UTF-8' standalone='yes'?><Scanner "
+          options.each do |key,value|
+            if Model::Scanner::AVAILABLE_OPTS.include? key
+              xml_data << "#{Model::Scanner::AVAILABLE_OPTS[key]}='"
+              xml_data << ( (key == :batch) ? value.to_s : [value.to_s].flatten.pack('m') )
+              xml_data << "' "
+            else
+              warn "[open_scanner] Received invalid option key :#{key}"
+            end
+          end
+          if columns
+            xml_data << ">"
+            [columns].flatten.each do |col|
+              xml_data << "<column>#{[col].flatten.pack('m')}</column>"
+            end
+            xml_data << "</Scanner>"
+          else
+            xml_data << "/>"
+          end
+
+          scanner = Response::ScannerResponse.new(post_response(request.open, xml_data), :open_scanner).parse
+          scanner.table_name = table_name
+          scanner
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table #{table_name} Not Found!"
+          else
+            raise StandardError, e.to_s
+          end
+        end
+      end
+
+      def get_rows(scanner, limit = nil)
+        warn "[DEPRECATION] Use of 'limit' here is deprecated. Instead, define the batch size when creating the scanner." if limit
+        begin
+          request = Request::ScannerRequest.new(scanner.table_name)
+          rows = Response::ScannerResponse.new(get(request.get_rows(scanner)), :get_rows).parse
+          rows.each do |row|
+            row.table_name = scanner.table_name
+          end
+          rows
+        rescue StandardError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table #{table_name} Not Found!"
+          else
+            raise StandardError, e.to_s
+          end
+        end
+      end
+
+      def close_scanner(scanner)
+        begin
+          request = Request::ScannerRequest.new(scanner.table_name)
+          Response::ScannerResponse.new(delete_response(request.close(scanner)), :close_scanner).parse
+        rescue StandardError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table #{table_name} Not Found!"
+          else
+            raise StandardError, e.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hbase/operation/table_operation.rb

@@ -0,0 +1,95 @@
+module HBase
+  module Operation
+    module TableOperation
+      def show_table(name)
+        begin
+          request = Request::TableRequest.new(name)
+          table_descriptor = Response::TableResponse.new(get(request.show)).parse
+        rescue Net::ProtocolError => e
+          raise TableNotFoundError, "Table '#{name}' Not found"
+        end
+      end
+
+      def create_table(name, *args)
+        request = Request::TableRequest.new(name)
+
+        raise StandardError, "Table name must be of type String" unless name.instance_of? String
+
+        begin
+          xml_data = "<?xml version='1.0' encoding='UTF-8' standalone='yes'?><TableSchema name='#{name}' IS_META='false' IS_ROOT='false'>"
+          for arg in args
+            if arg.instance_of? String
+              xml_data << "<ColumnSchema name='#{arg}' />"
+            elsif arg.instance_of? Hash
+              xml_data << "<ColumnSchema "
+
+              arg.each do |k,v|
+                if Model::ColumnDescriptor::AVAILABLE_OPTS.include? k
+                  xml_data << "#{Model::ColumnDescriptor::AVAILABLE_OPTS[k]}='#{v}' "
+                end
+              end
+
+              xml_data << "/>"
+            else
+              raise StandardError, "#{arg.class.to_s} of #{arg.to_s} is not of Hash Type"
+            end
+          end
+          xml_data << "</TableSchema>"
+          Response::TableResponse.new(post(request.create, xml_data))
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("TableExistsException")
+            raise TableExistsError, "Table '#{name}' already exists"
+          else
+            raise TableFailCreateError, e.message
+          end
+        end
+      end
+
+      def alter_table(name, *args)
+        raise StandardError, "Table name must be of type String" unless name.instance_of? String
+
+        request = Request::TableRequest.new(name)
+
+        begin
+          xml_data = construct_xml_stream(name, *args)
+          Response::TableResponse.new(put(request.update, xml_data))
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table '#{name}' not exists"
+          else
+            raise TableFailCreateError, e.message
+          end
+        end
+      end
+
+      def delete_table(name, columns = nil)
+        begin
+          request = Request::TableRequest.new(name)
+          Response::TableResponse.new(delete(request.delete(columns)))
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table '#{name}' not exists"
+          elsif e.to_s.include?("TableNotDisabledException")
+            raise TableNotDisabledError, "Table '#{name}' not disabled"
+          end
+        end
+      end
+
+      def destroy_table(name, columns = nil)
+        delete_table(name, columns)
+      end
+
+      def enable_table(name)
+        warn "[DEPRECATION] Explicitly enabling tables isn't required anymore. HBase Stargate will enable/disable as needed."
+      end
+
+      def disable_table(name)
+        warn "[DEPRECATION] Explicitly disabling tables isn't required anymore. HBase Stargate will enable/disable as needed."
+      end
+
+      def table_regions(name, start_row = nil, end_row = nil)
+      end
+
+    end
+  end
+end

data/lib/hbase/request.rb

@@ -0,0 +1,7 @@
+module HBase; module Request; end; end
+
+require 'hbase/request/basic_request'
+require 'hbase/request/meta_request'
+require 'hbase/request/table_request'
+require 'hbase/request/row_request'
+require 'hbase/request/scanner_request'

data/lib/hbase/request/basic_request.rb

@@ -0,0 +1,27 @@
+require 'cgi'
+
+module HBase
+  module Request
+    class BasicRequest
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+
+      protected
+
+      def pack_params columns
+        if columns.is_a? String
+          columns = [columns]
+        elsif columns.is_a? Array
+        else
+          raise StandardError, "Only String or Array type allows for columns"
+        end
+
+        columns.join(',')
+      end
+    end
+  end
+end

data/lib/hbase/request/meta_request.rb

@@ -0,0 +1,17 @@
+module HBase
+  module Request
+    class MetaRequest < BasicRequest
+      def initialize
+        super("")
+      end
+
+      def list_tables
+        @path << "/"
+      end
+
+      def create_table
+        @path << "/tables"
+      end
+    end
+  end
+end

data/lib/hbase/request/row_request.rb

@@ -0,0 +1,34 @@
+module HBase
+  module Request
+    class RowRequest < BasicRequest
+      attr_reader :table_name
+      attr_reader :name
+      attr_reader :timestamp
+
+      def initialize(table_name, name, timestamp=nil)
+        @table_name, @name, @timestamp = CGI.escape(table_name), CGI.escape(name), timestamp
+        path = "/#{@table_name}/#{@name}"
+        super(path)
+      end
+
+      def show(columns = nil, options = { })
+        @path << "/#{pack_params(columns)}" if columns
+        @path << "/#{@timestamp}" if @timestamp
+        @path << "?v=#{options[:version]}" if options[:version]
+        @path
+      end
+
+      def create(columns = nil)
+        @path << "/#{pack_params(columns)}" if columns
+        @path << "/#{@timestamp}" if @timestamp
+        @path
+      end
+
+      def delete(columns = nil)
+        @path << "/#{pack_params(columns)}" if columns
+        @path << "/#{@timestamp}" if @timestamp
+        @path
+      end
+    end
+  end
+end

data/lib/hbase/request/scanner_request.rb

@@ -0,0 +1,25 @@
+module HBase
+  module Request
+    class ScannerRequest < BasicRequest
+      attr_reader :table_name
+
+      def initialize(table_name)
+        @table_name = CGI.escape(table_name)
+        path = "/#{@table_name}/scanner"
+        super(path)
+      end
+
+      def open
+        @path
+      end
+
+      def get_rows(scanner)
+        @path = URI.parse(scanner.scanner_url).path
+      end
+
+      def close(scanner)
+        @path = URI.parse(scanner.scanner_url).path
+      end
+    end
+  end
+end

data/lib/hbase/request/table_request.rb

@@ -0,0 +1,43 @@
+module HBase
+  module Request
+    class TableRequest < BasicRequest
+      attr_reader :name
+      attr_reader :body
+
+      def initialize(name)
+        super("")
+        @name = CGI.escape(name) if name
+      end
+
+      def show
+        @path << "/#{name}/schema"
+      end
+
+      def regions(start_row = nil, end_row = nil)
+        #TODO no handle the args!
+        @path << "/#{name}/regions"
+      end
+
+      def create
+        @path << "/#{name}/schema"
+      end
+
+      def update
+        @path << "/#{name}"
+      end
+
+      def enable
+        @path << "/#{name}/enable"
+      end
+
+      def disable
+        @path << "/#{name}/disable"
+      end
+
+      def delete(columns = nil)
+        warn "[DEPRECATION] the use of the 'columns' argument is deprecated. Please use the delete method without any arguments." if columns
+        @path << "/#{name}/schema"
+      end
+    end
+  end
+end

data/lib/hbase/response.rb

@@ -0,0 +1,7 @@
+module HBase; module Response; end; end
+
+require 'hbase/response/basic_response'
+require 'hbase/response/meta_response'
+require 'hbase/response/table_response'
+require 'hbase/response/row_response'
+require 'hbase/response/scanner_response'

data/lib/hbase/response/basic_response.rb

@@ -0,0 +1,16 @@
+require 'json'
+
+module HBase
+  module Response
+    class BasicResponse
+
+      def initialize(raw_data)
+        @raw_data = raw_data
+      end
+
+      def parse
+        parse_content @raw_data
+      end
+    end
+  end
+end

data/lib/hbase/response/meta_response.rb

@@ -0,0 +1,35 @@
+module HBase
+  module Response
+    class MetaResponse < BasicResponse
+      attr_reader :method
+
+      def initialize(raw_data, method)
+        @method = method
+        super(raw_data)
+      end
+
+      def parse_content(raw_data)
+        case @method
+        when :list_tables
+          if raw_data.blank? || raw_data == "null" # "null" from json
+            puts "There are no available tables in the HBase"
+            return []
+          end
+
+          tables = []
+          doc = JSON.parse(raw_data)
+
+          doc["table"].each do |table|
+            name = table["name"].strip rescue nil
+            t = Model::TableDescriptor.new(:name => name)
+            tables << t
+          end
+
+          tables
+        else
+            puts "method '#{@method}' not supported yet"
+        end
+      end
+    end
+  end
+end

data/lib/hbase/response/row_response.rb

@@ -0,0 +1,31 @@
+module HBase
+  module Response
+    class RowResponse < BasicResponse
+      def parse_content(raw_data)
+        doc = JSON.parse(raw_data)
+        rows = doc["Row"]
+
+        model_rows = []
+        rows.each do |row|
+          rname = row["key"].strip.unpack("m").first
+          count = row["Cell"].size
+          columns = []
+
+          row["Cell"].each do |col|
+            name = col["column"].strip.unpack('m').first
+            value = col["$"].strip.unpack('m').first rescue nil
+            timestamp = col["timestamp"].to_i
+
+            columns << HBase::Model::Column.new(  :name => name,
+                                                  :value => value,
+                                                  :timestamp => timestamp)
+          end
+
+          model_rows << HBase::Model::Row.new(:name => rname, :total_count => count, :columns => columns)
+        end
+
+        model_rows
+      end
+    end
+  end
+end

data/lib/hbase/response/scanner_response.rb

@@ -0,0 +1,37 @@
+module HBase
+  module Response
+    class ScannerResponse < BasicResponse
+      attr_reader :method
+
+      def initialize(raw_data, method)
+        @method = method
+        super(raw_data)
+      end
+
+      def parse_content(raw_data)
+        case @method
+        when :open_scanner
+          case raw_data
+          when Net::HTTPCreated
+            HBase::Model::Scanner.new(:scanner_url => raw_data["Location"])
+          else
+            raise StandardError, "Unable to open scanner. Received the following message: #{raw_data.message}"
+          end
+        when :get_rows
+          # Dispatch it to RowResponse, since that method is made
+          # to deal with rows already.
+          RowResponse.new(raw_data).parse
+        when :close_scanner
+          case raw_data
+          when Net::HTTPOK
+            return true
+          else
+            raise StandardError, "Unable to close scanner. Received the following message: #{raw_data.message}"
+          end
+        else
+          puts "method '#{@method}' not supported yet"
+        end
+      end
+    end
+  end
+end