hbase-stargate 1.5.0

data/lib/stargate/operation/scanner_operation.rb

@@ -0,0 +1,90 @@
+module Stargate
+  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)
+        batch = options.delete(:batch) || "10"
+
+        begin
+          request = Request::ScannerRequest.new(table_name)
+
+          xml_data = "<?xml version='1.0' encoding='UTF-8' standalone='yes'?><Scanner batch='#{batch}' "
+          options.each do |key,value|
+            if Model::Scanner::AVAILABLE_OPTS.include? key
+              xml_data << "#{Model::Scanner::AVAILABLE_OPTS[key]}='#{[value.to_s].flatten.pack('m')}' "
+            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.batch_size = batch
+          scanner
+        rescue Net::ProtocolError => e
+          raise StandardError, e.to_s
+        end
+      end
+
+      def get_rows(scanner, limit = nil)
+        begin
+          request = Request::ScannerRequest.new(scanner.table_name)
+          request_url = request.get_rows(scanner) # The url to the scanner is the same for each batch
+
+          rows = []
+          begin
+            # Loop until we've reached the limit, or the scanner was exhausted (HTTP 204 returned)
+            until (limit && rows.size >= limit) || (response = get_response(request_url)).code == "204"
+              rows.concat Response::ScannerResponse.new(response.body, :get_rows).parse
+
+              rows.each do |row|
+                row.table_name = scanner.table_name
+              end
+            end
+          rescue Exception => e
+            raise Stargate::ScannerError, "Scanner failed while getting rows. #{e.message}"
+          end
+
+          # Prune the last few rows if the limit was passed.
+          (limit) ? rows.slice(0, limit) : 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/stargate/operation/table_operation.rb

@@ -0,0 +1,95 @@
+module Stargate
+  module Operation
+    module TableOperation
+      def show_table(name)
+        begin
+          request = Request::TableRequest.new(name)
+          Response::TableResponse.new(get(request.show)).parse
+        rescue Net::ProtocolError
+          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/stargate/request.rb

@@ -0,0 +1,7 @@
+module Stargate module Request; end; end
+
+require File.dirname(__FILE__) + '/request/basic_request'
+require File.dirname(__FILE__) + '/request/meta_request'
+require File.dirname(__FILE__) + '/request/table_request'
+require File.dirname(__FILE__) + '/request/row_request'
+require File.dirname(__FILE__) + '/request/scanner_request'

data/lib/stargate/request/basic_request.rb

@@ -0,0 +1,27 @@
+require 'cgi'
+
+module Stargate
+  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/stargate/request/meta_request.rb

@@ -0,0 +1,25 @@
+module Stargate
+  module Request
+    class MetaRequest < BasicRequest
+      def initialize
+        super("")
+      end
+
+      def list_tables
+        @path << "/"
+      end
+
+      def create_table
+        @path << "/tables"
+      end
+
+      def version
+        @path << "/version"
+      end
+
+      def cluster_version
+        @path << "/version/cluster"
+      end
+    end
+  end
+end

data/lib/stargate/request/row_request.rb

@@ -0,0 +1,34 @@
+module Stargate
+  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 << (columns ? "/#{pack_params(columns)}" : "/")
+        @path << "/#{@timestamp}" if @timestamp
+        @path << "?v=#{options[:version]}" if options[:version]
+        @path
+      end
+
+      def create(columns = nil)
+        @path << (columns ? "/#{pack_params(columns)}" : "/")
+        @path << "/#{@timestamp}" if @timestamp
+        @path
+      end
+
+      def delete(columns = nil)
+        @path << (columns ? "/#{pack_params(columns)}" : "/")
+        @path << "/#{@timestamp}" if @timestamp
+        @path
+      end
+    end
+  end
+end

data/lib/stargate/request/scanner_request.rb

@@ -0,0 +1,25 @@
+module Stargate
+  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/stargate/request/table_request.rb

@@ -0,0 +1,43 @@
+module Stargate
+  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/stargate/response.rb

@@ -0,0 +1,7 @@
+module Stargate module Response; end; end
+
+require File.dirname(__FILE__) + '/response/basic_response'
+require File.dirname(__FILE__) + '/response/meta_response'
+require File.dirname(__FILE__) + '/response/table_response'
+require File.dirname(__FILE__) + '/response/row_response'
+require File.dirname(__FILE__) + '/response/scanner_response'

data/lib/stargate/response/basic_response.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Stargate
+  module Response
+    class BasicResponse
+
+      def initialize(raw_data)
+        @raw_data = raw_data
+      end
+
+      def parse
+        parse_content @raw_data
+      end
+
+      def verify_success(response)
+        case response
+        when Net::HTTPSuccess
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/stargate/response/meta_response.rb

@@ -0,0 +1,35 @@
+module Stargate
+  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.to_s.empty? || 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/stargate/response/row_response.rb

@@ -0,0 +1,47 @@
+module Stargate
+  module Response
+    class RowResponse < BasicResponse
+      attr_reader :method
+
+      def initialize(raw_data, method)
+        @method = method
+        super(raw_data)
+      end
+
+      def parse_content(raw_data)
+        case @method
+        when :show_row
+          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 << Stargate::Model::Column.new(  :name => name,
+                                                    :value => value,
+                                                    :timestamp => timestamp)
+            end
+
+            model_rows << Stargate::Model::Row.new(:name => rname, :total_count => count, :columns => columns)
+          end
+
+          model_rows
+        when :create_row
+          verify_success(raw_data)
+        when :delete_row
+          verify_success(raw_data)
+        else
+          puts "method '#{@method}' not supported yet"
+        end
+      end
+    end
+  end
+end