sishen-hbase-ruby 0.2.4 → 0.2.5

data/hbase-ruby.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = %q{hbase-ruby}
-  s.version = "0.2.4"
+  s.version = "0.2.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ye Dingding"]

data/lib/hbase/client.rb

@@ -38,9 +38,16 @@ module HBase
 
     private
     def safe_request(&block)
-      response = yield
+      begin
+        response = yield
+      rescue Errno::ECONNREFUSED
+        raise ConnectionNotEstablishedError, "can't connect to #{@url}"
+      rescue Timeout::Error => e
+        raise ConnectionTimeoutError, "execution expired. Maybe query disabled tables"
+      end
+
       case response
-        when Net::HTTPSuccess then response.body
+      when Net::HTTPSuccess then response.body
       else
         response.error!
       end

data/lib/hbase/exception.rb

@@ -1 +1,19 @@
-class HBase::Exception < Exception; end
+class HBase::Exception < StandardError; end
+
+class HBase::ConnectionNotEstablishedError < HBase::Exception; end
+
+class HBase::ConnectionTimeoutError < HBase::Exception; end
+
+class HBase::TableNotFoundError < HBase::Exception; end
+
+class HBase::TableExistsError < HBase::Exception; end
+
+class HBase::TableFailCreateError < HBase::Exception; end
+
+class HBase::TableNotDisabledError < HBase::Exception; end
+
+class HBase::TableFailDisableError < HBase::Exception; end
+
+class HBase::TableFailEnableError < HBase::Exception; end
+
+class HBase::RowNotFoundError < HBase::Exception; end

data/lib/hbase/operation/row_operation.rb

@@ -6,37 +6,61 @@ module HBase
       end
 
       def show_row(table_name, name, timestamp = nil, columns = nil, version = nil)
-        request = Request::RowRequest.new(table_name, name, timestamp)
-        row = Response::RowResponse.new(get(request.show(columns, version))).parse
-        row.table_name = table_name
-        row.name = name
-        row.timestamp = timestamp
-        row
+        begin
+          request = Request::RowRequest.new(table_name, name, timestamp)
+          row = Response::RowResponse.new(get(request.show(columns, version))).parse
+          row.table_name = table_name
+          row.name = name
+          row.timestamp = timestamp
+          row
+        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
 
       def create_row(table_name, name, timestamp = nil, *args)
-        request = Request::RowRequest.new(table_name, name, timestamp)
-        data = []
-        if args.instance_of? Array
-          data = args
-        elsif args.instance_of? Hash
-          data = [args]
-        else
-          raise StandardError, "Only Array or Hash data accepted"
-        end
-        xml_data ="<?xml version='1.0' encoding='UTF-8'?><columns>"
-        data.each do |d|
-          xml_data << "<column><name>#{d[:name]}</name>"
-          xml_data << "<value>#{[d[:value]].pack("m") rescue ''}</value></column>"
-        end
-        xml_data << "</columns>"
+        begin
+          request = Request::RowRequest.new(table_name, name, timestamp)
+          data = []
+          if args.instance_of? Array
+            data = args
+          elsif args.instance_of? Hash
+            data = [args]
+          else
+            raise StandardError, "Only Array or Hash data accepted"
+          end
+          xml_data ="<?xml version='1.0' encoding='UTF-8'?><columns>"
+          data.each do |d|
+            xml_data << "<column><name>#{d[:name]}</name>"
+            xml_data << "<value>#{[d[:value]].pack("m") rescue ''}</value></column>"
+          end
+          xml_data << "</columns>"
 
-        Response::RowResponse.new(post(request.create, xml_data))
+          Response::RowResponse.new(post(request.create, xml_data))
+        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
 
       def delete_row(table_name, name, timestamp = nil, columns = nil)
-        request = Request::RowRequest.new(table_name, name, timestamp)
-        Response::RowResponse.new(delete(request.delete(columns)))
+        begin
+          request = Request::RowRequest.new(table_name, name, timestamp)
+          Response::RowResponse.new(delete(request.delete(columns)))
+        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

data/lib/hbase/operation/table_operation.rb

@@ -2,8 +2,12 @@ module HBase
   module Operation
     module TableOperation
       def show_table(name)
-        request = Request::TableRequest.new(name)
-        table_descriptor = Response::TableResponse.new(get(request.show)).parse
+        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)
@@ -11,39 +15,71 @@ module HBase
 
         raise StandardError, "Table name must be of type String" unless name.instance_of? String
 
-        xml_data = "<?xml version='1.0' encoding='UTF-8'?><table><name>#{name}</name><columnfamilies>"
-        for arg in args
-          if arg.instance_of? String
-            xml_data << "<columnfamily><name>#{arg}</name></columnfamily>"
-          elsif arg.instance_of? Hash
-            xml_data << "<columnfamily>"
-            arg.each do |k,v|
-              if Model::ColumnDescriptor::AVAILABLE_OPTS.include? k
-                xml_data << "<#{Model::ColumnDescriptor::AVAILABLE_OPTS[k]}>#{v}</#{Model::ColumnDescriptor::AVAILABLE_OPTS[k]}>"
+        begin
+          xml_data = "<?xml version='1.0' encoding='UTF-8'?><table><name>#{name}</name><columnfamilies>"
+          for arg in args
+            if arg.instance_of? String
+              xml_data << "<columnfamily><name>#{arg}</name></columnfamily>"
+            elsif arg.instance_of? Hash
+              xml_data << "<columnfamily>"
+              arg.each do |k,v|
+                if Model::ColumnDescriptor::AVAILABLE_OPTS.include? k
+                  xml_data << "<#{Model::ColumnDescriptor::AVAILABLE_OPTS[k]}>#{v}</#{Model::ColumnDescriptor::AVAILABLE_OPTS[k]}>"
+                end
               end
+              xml_data << "</columnfamily>"
+            else
+              raise StandardError, "#{arg.class.to_s} of #{arg.to_s} is not of Hash Type"
             end
-            xml_data << "</columnfamily>"
+          end
+          xml_data << "</columnfamilies></table>"
+          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 StandardError, "#{arg.class.to_s} of #{arg.to_s} is not of Hash Type"
+            raise TableFailCreateError, e.message
           end
         end
-        xml_data << "</columnfamilies></table>"
-        Response::TableResponse.new(post(request.create, xml_data))
       end
 
       def delete_table(name)
-        request = Request::TableRequest.new(name)
-        Response::TableResponse.new(delete(request.delete))
+        begin
+          request = Request::TableRequest.new(name)
+          Response::TableResponse.new(delete(request.delete))
+        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 enalbe_table(name)
-        request = Request::TableRequest.new(name)
-        Response::TableResponse.new(post(request.enable))
+      def enable_table(name)
+        begin
+          request = Request::TableRequest.new(name)
+          Response::TableResponse.new(post(request.enable))
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table '#{name}' not exists"
+          else
+            raise TableFailEnableError, "Table '#{name}' can not be enabled"
+          end
+        end
       end
 
       def disable_table(name)
-        request = Request::TableRequest.new(name)
-        Response::TableResponse.new(post(request.disable))
+        begin
+          request = Request::TableRequest.new(name)
+          Response::TableResponse.new(post(request.disable))
+        rescue Net::ProtocolError => e
+          if e.to_s.include?("TableNotFoundException")
+            raise TableNotFoundError, "Table '#{name}' not exists"
+          else
+            raise TableFailDisableError, "Table '#{name}' can not be disabled"
+          end
+        end
       end
 
       def table_regions(name, start_row = nil, end_row = nil)

data/lib/hbase/response/meta_response.rb

@@ -13,7 +13,7 @@ module HBase
         when :list_tables
           if raw_data.blank?
             puts "There are no available tables in the HBase"
-            return nil
+            return []
           end
 
           doc = REXML::Document.new(raw_data)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sishen-hbase-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors: 
 - Ye Dingding