hbase-driver 0.0.1

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake/gempackagetask'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = "spec/**/[^_]*_spec.rb"
+end
+
+task :default => :spec
+
+spec = Gem::Specification.new do |s| 
+  s.name = "hbase-driver"
+  s.version = '0.0.1'
+  s.summary = "HBase Ruby Driver"
+  s.homepage = "http://github.com/railsware/hbase-driver"
+  s.email = ["Alexey.Petrushin@railsware.com", "dmitry.larkin@railsware.com"]
+  s.authors = ["Alexey Petrushin", "Dmitry Larkin"]
+  s.files = FileList["{lib}/**/*"].to_a + %w(readme.md Rakefile)
+  s.require_paths = ["lib"]
+  s.has_rdoc = false
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end

data/lib/hbase.rb

@@ -0,0 +1,9 @@
+%w(
+  support
+  cell
+  record
+  table
+  hbase
+).each{|f| require "hbase/#{f}"}
+
+require 'stargate'

data/lib/hbase/cell.rb

@@ -0,0 +1,9 @@
+class HBase
+  class Cell
+    attr_accessor :value, :timestamp
+    
+    def initialize value, timestamp
+      @value, @timestamp = value, timestamp
+    end
+  end
+end

data/lib/hbase/hbase.rb

@@ -0,0 +1,42 @@
+class HBase
+  attr_reader :stargate
+  
+  def initialize *args
+    @stargate = Stargate::Client.new *args
+  end
+  
+  def get table_name
+    HBase::Table.new stargate, table_name
+  end
+  alias_method :[], :get
+    
+  def delete table_name
+    stargate.delete_table table_name
+  end
+
+  def truncate table_name
+    stargate.truncate table_name
+  end
+
+  def all      
+    stargate.list_tables
+  end
+  alias_method :list, :all
+  
+  def include? table_name
+    all.any?{|meta| meta.name == table_name}
+  end
+  alias_method :exist?, :include?
+  
+  def create *args
+    stargate.create_table *args
+  end
+  
+  def disable *args
+    stargate.disable_table *args
+  end
+  
+  def enable *args
+    stargate.enable_table *args
+  end
+end

data/lib/hbase/record.rb

@@ -0,0 +1,22 @@
+class HBase
+  class Record
+    attr_reader :cells
+    
+    def initialize
+      @cells = {}
+    end
+    
+    def get(key)
+      if cell = cells[key]
+        cell.value
+      else
+        nil
+      end
+    end
+    alias_method :[], :get
+    
+    def size
+      cells.size
+    end
+  end
+end

data/lib/hbase/support.rb

@@ -0,0 +1,9 @@
+unless {}.respond_to? :symbolize_keys
+  class Hash
+    def symbolize_keys
+      h = {}
+      each{|k, v| h[k.to_sym] = v}
+      h
+    end
+  end
+end

data/lib/hbase/table.rb

@@ -0,0 +1,75 @@
+class HBase
+  class Table
+    attr_reader :stargate, :table_name
+    
+    def initialize(stargate, table_name)
+      @stargate, @table_name = stargate, table_name
+    end
+    
+    def get(key, with_timestamps = false)
+      begin
+        record = Record.new
+        old_row = stargate.show_row(table_name, key)
+        old_row.columns.each do |old_cell|
+          record.cells[old_cell.name] = Cell.new old_cell.value, old_cell.timestamp
+        end
+        record
+      rescue Stargate::RowNotFoundError
+        nil
+      end
+    end
+    alias_method :[], :get
+    
+    def update(key, attributes)
+      raise "ivalid usage, attributes should be a hash!" unless attributes.is_a? Hash
+      timestamp = attributes.delete(:timestamp) || attributes.delete('timestamp') # || Time.now.to_i      
+      attr_in_driver_format = attributes.to_a.collect do |attr_name, attr_value| 
+        {:name => attr_name, :value => attr_value}
+      end      
+      stargate.create_row(table_name, key, timestamp, attr_in_driver_format)
+    end
+    alias_method :[]=, :update
+    
+    def delete(key)
+      stargate.delete_row table_name, key      
+    end
+    
+    def include?(key)
+      !!get(key)      
+    end
+    alias_method :exist?, :include?
+    
+    def metadata
+      stargate.show_table table_name
+    end
+    
+    TRANSLATION = {
+      :start => :start_row,
+      :end => :end_row
+    }
+    def scan(options = {})
+      options.symbolize_keys
+      
+      stargate_options = {}
+      options.each do |k, v|
+        stargate_options[TRANSLATION[k] || k] = v
+      end
+      
+      scanner = stargate.open_scanner(table_name, stargate_options)
+      begin
+        old_rows = stargate.get_rows(scanner)
+        records = []
+        old_rows.each do |old_row|
+          old_row.columns.each do |old_cell|
+            record = Record.new
+            record.cells[old_cell.name] = Cell.new old_cell.value, old_cell.timestamp
+            records << record
+          end
+        end
+        records
+      ensure
+        stargate.close_scanner(scanner) if scanner
+      end
+    end
+  end
+end

data/lib/stargate.rb

@@ -0,0 +1,7 @@
+module Stargate end
+
+require File.join(File.dirname(__FILE__), "stargate", "client")
+require File.join(File.dirname(__FILE__), "stargate", "exception")
+require File.join(File.dirname(__FILE__), "stargate", "model")
+require File.join(File.dirname(__FILE__), "stargate", "request")
+require File.join(File.dirname(__FILE__), "stargate", "response")

data/lib/stargate/client.rb

@@ -0,0 +1,93 @@
+require 'net/http'
+require File.dirname(__FILE__) + '/operation/meta_operation'
+require File.dirname(__FILE__) + '/operation/table_operation'
+require File.dirname(__FILE__) + '/operation/row_operation'
+require File.dirname(__FILE__) + '/operation/scanner_operation'
+
+module Stargate
+  class Client
+    VERSION = 1 #File.read(File.join(File.dirname(__FILE__), "..", "..", "VERSION")).chomp.freeze
+
+    include Operation::MetaOperation
+    include Operation::TableOperation
+    include Operation::RowOperation
+    include Operation::ScannerOperation
+
+    attr_reader :url, :connection
+
+    def initialize(url = "http://localhost:8080", opts = {})
+      @url = URI.parse(url)
+      unless @url.kind_of? URI::HTTP
+        raise "invalid http url: #{url}"
+      end
+
+      # Not actually opening the connection yet, just setting up the persistent connection.
+      if opts[:proxy]
+        proxy_address, proxy_port = opts[:proxy].split(':')
+        @connection = Net::HTTP.Proxy(proxy_address, proxy_port).new(@url.host, @url.port)
+      else
+        @connection = Net::HTTP.new(@url.host, @url.port)
+      end
+      @connection.read_timeout = opts[:timeout] if opts[:timeout]
+    end
+
+    def get(path, options = {})
+      safe_request { @connection.get(@url.path + path, {'Content-Type' => 'text/xml', "Accept" => "application/json"}.merge(options)) }
+    end
+
+    def get_response(path, options = {})
+      safe_response { @connection.get(@url.path + path, {"Accept" => "application/json"}.merge(options)) }
+    end
+
+    def post(path, data = nil, options = {})
+      safe_request { @connection.post(@url.path + path, data, {'Content-Type' => 'text/xml', "Accept" => "application/json"}.merge(options)) }
+    end
+
+    def post_response(path, data = nil, options = {})
+      safe_response { @connection.post(@url.path + path, data, {'Content-Type' => 'text/xml', "Accept" => "application/json"}.merge(options)) }
+    end
+
+    def delete(path, options = {})
+      safe_request { @connection.delete(@url.path + path, options) }
+    end
+
+    def delete_response(path, options = {})
+      safe_response { @connection.delete(@url.path + path, options) }
+    end
+
+    def put(path, data = nil, options = {})
+      safe_request { @connection.put(@url.path + path, data, {'Content-Type' => 'text/xml', "Accept" => "application/json"}.merge(options)) }
+    end
+
+    def put_response(path, data = nil, options = {})
+      safe_response { @connection.put(@url.path + path, data, {'Content-Type' => 'text/xml', "Accept" => "application/json"}.merge(options)) }
+    end
+
+    private
+
+      # Part of safe_request was broken up into safe_response because when working with scanners
+      # in Stargate, you need to have access to the response itself, and not just the body.
+      def safe_response(&block)
+        begin
+          yield
+        rescue Errno::ECONNREFUSED
+          raise ConnectionNotEstablishedError, "can't connect to #{@url}"
+        rescue Timeout::Error => e
+          puts e.backtrace.join("\n")
+          raise ConnectionTimeoutError, "execution expired. Maybe query disabled tables"
+        end
+      end
+
+      def safe_request(&block)
+        response = safe_response{ yield block }
+
+        case response
+        when Net::HTTPSuccess
+          response.body
+        else
+          response.error!
+        end
+      end
+
+  end
+end

data/lib/stargate/exception.rb

@@ -0,0 +1,21 @@
+class Stargate::Exception < StandardError; end
+
+class Stargate::ConnectionNotEstablishedError < Stargate::Exception; end
+
+class Stargate::ConnectionTimeoutError < Stargate::Exception; end
+
+class Stargate::TableNotFoundError < Stargate::Exception; end
+
+class Stargate::TableExistsError < Stargate::Exception; end
+
+class Stargate::TableFailCreateError < Stargate::Exception; end
+
+class Stargate::TableNotDisabledError < Stargate::Exception; end
+
+class Stargate::TableFailDisableError < Stargate::Exception; end
+
+class Stargate::TableFailEnableError < Stargate::Exception; end
+
+class Stargate::RowNotFoundError < Stargate::Exception; end
+
+class Stargate::ScannerError < Stargate::Exception; end

data/lib/stargate/model.rb

@@ -0,0 +1,19 @@
+module Stargate
+  module Model
+    class Record
+      def initialize (params)
+        params.each do |key, value|
+          name = key.to_s
+          instance_variable_set("@#{name}", value) if respond_to?(name)
+        end
+      end
+    end
+  end
+end
+
+require File.dirname(__FILE__) + '/model/column'
+require File.dirname(__FILE__) + '/model/column_descriptor'
+require File.dirname(__FILE__) + '/model/region_descriptor'
+require File.dirname(__FILE__) + '/model/row'
+require File.dirname(__FILE__) + '/model/table_descriptor'
+require File.dirname(__FILE__) + '/model/scanner'

data/lib/stargate/model/column.rb

@@ -0,0 +1,9 @@
+module Stargate
+  module Model
+    class Column < Record
+      attr_accessor :name
+      attr_accessor :value
+      attr_accessor :timestamp
+    end
+  end
+end

data/lib/stargate/model/column_descriptor.rb

@@ -0,0 +1,32 @@
+module Stargate
+  module Model
+    module CompressionType
+      NONE = "NONE"
+      RECORD = "RECORD"
+      BLOCK = "BLOCK"
+
+      CTYPES = [NONE, RECORD, BLOCK]
+
+      def to_compression_type(type_string)
+        CTYPES.include?(type_string) ? type_string : NONE
+      end
+
+      module_function :to_compression_type
+    end
+
+    class ColumnDescriptor < Record
+      AVAILABLE_OPTS = {  :name => "name", :max_versions => "VERSIONS", :versions => "VERSIONS",
+                          :compression => "COMPRESSION", :in_memory => "IN_MEMORY",
+                          :block_cache => "BLOCKCACHE", :blockcache => "BLOCKCACHE",
+                          :blocksize => "BLOCKSIZE", :length => "LENGTH", :ttl => "TTL",
+                          :bloomfilter => "BLOOMFILTER"}
+      attr_accessor :name
+      attr_accessor :compression
+      attr_accessor :bloomfilter
+      attr_accessor :maximum_cell_size
+      attr_accessor :max_versions
+
+      attr_accessor :versions
+    end
+  end
+end

data/lib/stargate/model/region_descriptor.rb

@@ -0,0 +1,9 @@
+module Stargate
+  module Model
+    class Region < Record
+    end
+
+    class RegionDescriptor < Record
+    end
+  end
+end

data/lib/stargate/model/row.rb

@@ -0,0 +1,18 @@
+module Stargate
+  module Model
+    class Row < Record
+      attr_accessor :table_name
+      attr_accessor :name
+      attr_accessor :total_count
+      attr_accessor :columns
+
+      def timestamp
+        warn "[DEPRECATION] timestamp attribute will be removed from the Row model. "
+      end
+
+      def timestamp=
+        timestamp
+      end
+    end
+  end
+end

data/lib/stargate/model/scanner.rb

@@ -0,0 +1,16 @@
+module Stargate
+  module Model
+    class Scanner < Record
+      AVAILABLE_OPTS = {  :start_row => "startRow", :end_row => "endRow",
+                          :start_time => "startTime", :end_time => "endTime",
+                          :batch => "batch" }
+
+      attr_accessor :table_name
+      attr_accessor :scanner_url
+      attr_accessor :batch_size
+
+      # Deprecation: scanner_url is used instead of just the ID
+      attr_accessor :scanner_id
+    end
+  end
+end

data/lib/stargate/model/table_descriptor.rb

@@ -0,0 +1,8 @@
+module Stargate
+  module Model
+    class TableDescriptor < Record
+      attr_accessor :name
+      attr_accessor :column_families
+    end
+  end
+end

data/lib/stargate/operation/meta_operation.rb

@@ -0,0 +1,20 @@
+module Stargate
+  module Operation
+    module MetaOperation
+      def list_tables
+        request = Request::MetaRequest.new
+        Response::MetaResponse.new(get(request.list_tables), :list_tables).parse
+      end
+
+      def version
+        request = Request::MetaRequest.new
+        get(request.version, {"Accept" => "text/plain"}).strip
+      end
+
+      def cluster_version
+        request = Request::MetaRequest.new
+        get(request.cluster_version, {"Accept" => "text/plain"}).strip
+      end
+    end
+  end
+end

data/lib/stargate/operation/row_operation.rb

@@ -0,0 +1,86 @@
+module Stargate
+  module Operation
+    module RowOperation
+      Converter = {
+        '&' => '&',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        "'" => '&apos;',
+        '"' => '&quot;'
+      }
+
+      def row_timestamps(table_name, name)
+        raise NotImplementedError, "Currently not supported in Stargate client"
+      end
+
+      def show_row(table_name, name, timestamp = nil, columns = nil, options = { })
+        begin
+          options[:version] ||= 1
+
+          request = Request::RowRequest.new(table_name, name, timestamp)
+          row = Response::RowResponse.new(get(request.show(columns, options)), :show_row).parse.first
+          row.table_name = table_name
+          row
+        rescue Net::ProtocolError => e
+          # TODO: Use better handling instead of this.
+          if e.to_s.include?("Table")
+            raise TableNotFoundError, "Table '#{table_name}' Not Found"
+          elsif e.to_s.include?("404")
+            raise RowNotFoundError, "Row '#{name}' Not Found"
+          end
+        end
+      end
+
+      def create_row(table_name, name, timestamp = nil, columns = nil)
+        begin
+          request = Request::RowRequest.new(table_name, name, timestamp)
+          data = []
+          if columns
+            if columns.instance_of? Array
+              data = columns
+            elsif columns.instance_of? Hash
+              data = [columns]
+            else
+              raise StandardError, "Only Array or Hash data accepted"
+            end
+          end
+
+          xml_data = "<?xml version='1.0' encoding='UTF-8' standalone='yes'?><CellSet>"
+          xml_data << "<Row key='#{[name].pack('m') rescue ''}'>"
+          data.each do |d|
+            escape_name = d[:name].gsub(/[&<>'"]/) { |match| Converter[match] }
+            xml_data << "<Cell "
+            xml_data << "timestamp='#{timestamp}' " if timestamp
+            xml_data << "column='#{[escape_name].pack('m') rescue ''}'>"
+            xml_data << "#{[d[:value]].pack("m") rescue ''}"
+            xml_data << "</Cell>"
+          end
+          xml_data << "</Row></CellSet>"
+
+          Response::RowResponse.new(post_response(request.create(data.map{|col| col[:name]}), xml_data), :create_row).parse
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("Table")
+            raise TableNotFoundError, "Table '#{table_name}' Not Found"
+          elsif e.to_s.include?("Row")
+            raise RowNotFoundError, "Row '#{name}' Not Found"
+          else
+            raise StandardError, "Error encountered while trying to create row: #{e.message}"
+          end
+        end
+      end
+
+      def delete_row(table_name, name, timestamp = nil, columns = nil)
+        begin
+          request = Request::RowRequest.new(table_name, name, timestamp)
+          Response::RowResponse.new(delete_response(request.delete(columns)), :delete_row).parse
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("Table")
+            raise TableNotFoundError, "Table '#{table_name}' Not Found"
+          elsif e.to_s.include?("Row")
+            raise RowNotFoundError, "Row '#{name}' Not Found"
+          end
+        end
+      end
+    end
+  end
+end

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,30 @@
+begin
+  require 'json'
+rescue LoadError => e
+  puts "[hbase-stargate] json is required. Install it with 'gem install json' (or json-jruby for JRuby)"
+  raise e
+end
+
+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

data/lib/stargate/response/scanner_response.rb

@@ -0,0 +1,41 @@
+module Stargate
+  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
+            Stargate::Model::Scanner.new(:scanner_url => raw_data["Location"])
+          else
+            if raw_data.message.include?("TableNotFoundException")
+              raise TableNotFoundError, "Table #{table_name} Not Found!"
+            else
+              raise StandardError, "Unable to open scanner. Received the following message: #{raw_data.message}"
+            end
+          end
+        when :get_rows
+          # Dispatch it to RowResponse, since that method is made
+          # to deal with rows already.
+          RowResponse.new(raw_data, :show_row).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

data/lib/stargate/response/table_response.rb

@@ -0,0 +1,26 @@
+module Stargate
+  module Response
+    class TableResponse < BasicResponse
+      def parse_content(raw_data)
+        table = JSON.parse(raw_data)
+        name = table["name"].strip
+
+        column_families = []
+        table["ColumnSchema"].each do |columnfamily|
+          colname = columnfamily["name"].strip
+          compression = columnfamily["COMPRESSION"].strip
+          bloomfilter = (columnfamily["BLOOMFILTER"].strip =~ /^true$/i ? true : false)
+          max_versions = columnfamily["VERSIONS"].strip.to_i
+
+          column_descriptor = Model::ColumnDescriptor.new(:name => colname,
+                                                          :compression => Model::CompressionType.to_compression_type(compression),
+                                                          :bloomfilter => bloomfilter,
+                                                          :max_versions => max_versions)
+          column_families << column_descriptor
+        end
+
+        Model::TableDescriptor.new(:name => name, :column_families => column_families)
+      end
+    end
+  end
+end

data/readme.md

@@ -0,0 +1,47 @@
+# Ruby driver for HBase
+
+Small and handy Ruby driver for HBase (via Stargate RESTfull interface).
+
+# Usage
+
+**Warning:** HBase and Stargate should be installed and running.
+
+	require 'hbase'
+
+	hbase = HBase.new('http://localhost:8080')
+
+	# creating table
+	hbase.create 'users'
+
+	# listing all tables
+	p hbase.all # => ['users']
+
+	# create record
+	users.update 'john', 'attr:email' => 'john@mail.com'
+
+	# get record
+	john = users['john']
+	p john['attr:email'] # => "john@mail.com"    
+
+	# update record
+	users.update 'john', 'attr:email' => "another@mail.com"
+	p john['attr:email'] # => "another@mail.com"
+
+	# deleting record
+	users.delete 'john'    
+
+	# scanning
+	users.update 'john', 'attr:email' => 'john@mail.com'
+	users.update 'mario', 'attr:email' => 'mario@mail.com'
+	users.update 'stanley', 'attr:email' => 'stanley@mail.com'
+
+	list = users.scan :start => 'john', :batch => 5, :columns => ['attr:']
+	p list.collect{|user| user['attr:email']} # => ['john@mail.com', 'mario@mail.com', 'stanley@mail.com']
+	
+# Installation
+
+	$ gem install ruby-driver
+	
+For installation of HBase and Stargate please see HBase docs (google it).
+
+**Warning:** currently HBase distributed with RESTful interface called 'rest' and it's deprecated and broken. And because it looks very similar to Stargate it's easy to mix it up. So, be aware, you need to install and use the Stargate, not default and broken HBase REST client.

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: hbase-driver
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexey Petrushin
+- Dmitry Larkin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-10 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- Alexey.Petrushin@railsware.com
+- dmitry.larkin@railsware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/hbase/cell.rb
+- lib/hbase/hbase.rb
+- lib/hbase/record.rb
+- lib/hbase/support.rb
+- lib/hbase/table.rb
+- lib/hbase.rb
+- lib/stargate/client.rb
+- lib/stargate/exception.rb
+- lib/stargate/model/column.rb
+- lib/stargate/model/column_descriptor.rb
+- lib/stargate/model/region_descriptor.rb
+- lib/stargate/model/row.rb
+- lib/stargate/model/scanner.rb
+- lib/stargate/model/table_descriptor.rb
+- lib/stargate/model.rb
+- lib/stargate/operation/meta_operation.rb
+- lib/stargate/operation/row_operation.rb
+- lib/stargate/operation/scanner_operation.rb
+- lib/stargate/operation/table_operation.rb
+- lib/stargate/request/basic_request.rb
+- lib/stargate/request/meta_request.rb
+- lib/stargate/request/row_request.rb
+- lib/stargate/request/scanner_request.rb
+- lib/stargate/request/table_request.rb
+- lib/stargate/request.rb
+- lib/stargate/response/basic_response.rb
+- lib/stargate/response/meta_response.rb
+- lib/stargate/response/row_response.rb
+- lib/stargate/response/scanner_response.rb
+- lib/stargate/response/table_response.rb
+- lib/stargate/response.rb
+- lib/stargate.rb
+- readme.md
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/railsware/hbase-driver
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: HBase Ruby Driver
+test_files: []
+