corm 0.0.25 → 0.0.26

data/lib/corm.rb

@@ -1,2 +1,3 @@
 # encoding: utf-8
 require 'corm/model'
+require 'corm/retry/policies'

data/lib/corm/exceptions.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
 
 module Corm
-  class TooManyKeysError < StandardError; end
-  class UnknownKey < StandardError; end
-  class MissingPartitionKey < StandardError; end
-  class MissingClusteringKey < StandardError; end
-  class UnknownClusteringKey < StandardError; end
+  class GenericError < StandardError; end
+  class TooManyKeysError < GenericError; end
+  class UnknownPrimaryKey < GenericError; end
+  class MissingPartitionKey < GenericError; end
+  class MissingClusteringKey < GenericError; end
+  class UnknownClusteringKey < GenericError; end
 end

data/lib/corm/model.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 require 'cassandra'
-require 'corm/enhancements'
 require 'corm/exceptions'
 require 'corm/validations'
 require 'multi_json'
@@ -11,7 +10,6 @@ require 'digest/md5'
 module Corm
   class Model
     include Enumerable
-    extend Enhancements
     extend Validations
 
     @@cluster = nil
@@ -21,23 +19,15 @@ module Corm
     # give up...
     # If it fails `@@cluster` was nil and nil remains.
     def self.configure(opts = {})
-      attempts_wrapper do
-        @@cluster = Cassandra.cluster(opts)
-      end
+      @@cluster = Cassandra.cluster(opts)
     end
 
     def self.cluster
       @@cluster
     end
 
-    # Please, note the wrapper around the `session execute`.
-    # This wrapper (implemented in the Enhancements module) will recover some
-    # Cassandra::Error(s) retrying a couple of times.
-    #
-    # Note also that the <instance>#execute is just calling this Class#execute,
-    # as well as count, find, get, drop, etc...
     def self.execute(*args)
-      attempts_wrapper { session.execute(*args) }
+      session.execute(*args)
     end
 
     def self.field(name, type, pkey = false)
@@ -173,7 +163,7 @@ module Corm
     # The options hash support the ':limit' option to append at the statement;
     # the default is no limit.
     #
-    # The 'key_values' parameter is an Hash where the keys are the "column
+    # The 'params' parameter is an Hash where the keys are the "column
     # names" and the values... are the values.
     #
     # If the keys passed as parameter are more than the defined by the table the
@@ -181,50 +171,27 @@ module Corm
     # Other exceptions are raised when the keys doesn't include all the
     # (required) partition_keys or the clustering keys doesn't are in the
     # defined order.
-    def self.find(key_values = {}, query_options = {}, &block)
-
-      raise ArgumentError unless key_values.is_a?(Hash)
-      raise ArgumentError unless query_options.is_a?(Hash)
-
-      unless key_values.empty?
-        raise TooManyKeysError if there_are_too_many_keys_requested?(key_values)
-        raise MissingPartitionKey if a_partition_key_is_missing?(key_values)
-        raise UnknownClusteringKey if an_unknown_clustering_key_is_requested?(key_values)
-        # raise UnknownKey if an_unknown_key_is_requested?(key_values)
-        raise MissingClusteringKey if a_clustering_key_is_missing?(key_values)
-      end
-
-      return to_enum(:find, key_values, query_options) unless block_given?
-
-      statement_find_key = Array(query_options.fetch(:statement_key, 'find')).flatten
-      field_names = []
-
-      key_values.each do |key, value|
-
-        statement_find_key << key.to_s
-        field_names << "#{key} = ?"
+    def self.find(params = {}, opts = {}, &block)
+      validate_query(params, opts)
+      return to_enum(:find, params, opts) unless block_given?
+      statement_key = Array(opts.fetch(:statement_key, 'find')).flatten
+      statement_key.concat(params.keys)
+      statement_key.concat(["_limit#{opts[:limit]}"]) if opts[:limit]
+      statement_key = statement_key.join('_')
+      fields = params.map { |key, _value| "#{key} = ?" }
+      if statements[statement_key].nil?
+        statement = select_statement_for(fields, opts[:limit])
+        statements[statement_key] = session.prepare(statement)
       end
-
-      statement_find_key = statement_find_key.join('_')
-      statement_find_key.concat("_limit#{query_options[:limit]}") if query_options[:limit]
-
-      if statements[statement_find_key].nil?
-        statement = self.the_select_statement_for(key_values, field_names, query_options[:limit])
-        statements[statement_find_key] = session.prepare(statement)
-      end
-
-      execute(statements[statement_find_key], arguments: key_values).each do |cassandra_record_|
-        block.call(new(_cassandra_record: cassandra_record_))
+      execute(statements[statement_key], arguments: params.values).each do |res|
+        block.call(new(_cassandra_record: res))
       end
     end
 
     def self.get(relations)
-      query_options = {
-        limit: 1,
-        statement_key: 'get'
-      }
-      cassandra_record = self.find(relations, query_options).first
-      return cassandra_record ? cassandra_record : nil
+      query_options = { limit: 1, statement_key: 'get' }
+      cassandra_record = find(relations, query_options).first
+      cassandra_record ? cassandra_record : nil
     end
 
     def self.keyspace(name = nil)
@@ -241,11 +208,9 @@ module Corm
                     "{'class': 'SimpleStrategy', 'replication_factor': '1'}"
       durable_writes = opts[:durable_writes].nil? ? true : opts[:durable_writes]
       if_not_exists = opts[:if_not_exists] ? 'IF NOT EXISTS' : ''
-      attempts_wrapper do
-        cluster.connect.execute(
-          "CREATE KEYSPACE #{if_not_exists} #{keyspace} WITH replication = #{replication} AND durable_writes = #{durable_writes};"
-        )
-      end
+      cluster.connect.execute(
+        "CREATE KEYSPACE #{if_not_exists} #{keyspace} WITH replication = #{replication} AND durable_writes = #{durable_writes};"
+      )
     end
 
     def self.primary_key(partition_key = nil, *cols)
@@ -257,15 +222,15 @@ module Corm
     end
 
     def self.primary_key_count
-      self.primary_key.flatten.count
+      primary_key.flatten.count
     end
 
     def self.partition_key
-      self.primary_key.first.map(&:to_sym)
+      primary_key.first.map(&:to_sym)
     end
 
     def self.clustering_key
-      self.primary_key.count == 2 ? self.primary_key[1].flatten.map(&:to_sym) : []
+      primary_key.count == 2 ? primary_key[1].flatten.map(&:to_sym) : []
     end
 
     def self.properties(*args)
@@ -282,12 +247,10 @@ module Corm
     # This operation is wrapped by the retry policy (module Enhancements).
     def self.session
       unless class_variable_defined?(:@@session)
-        attempts_wrapper do
-          class_variable_set(
-            :@@session,
-            cluster.connect(keyspace)
-          )
-        end
+        class_variable_set(
+          :@@session,
+          cluster.connect(keyspace)
+        )
       end
       class_variable_get :@@session
     end
@@ -366,6 +329,20 @@ module Corm
 
     protected
 
+    ##
+    # Create and return the proper query to find the C* entries, given an array
+    # of keys.
+    #
+    # @param key_values An array of key names; can be empty, cannot be, in size, greater than the length of the model keys.
+    # @param field_names The "column names" for the `WHERE` clause.
+    def self.select_statement_for(fields, limit = nil)
+      statement  = "SELECT * FROM #{keyspace}.#{table}"
+      statement += " WHERE #{fields.join(' AND ')}" unless fields.empty?
+      statement += " LIMIT #{limit.to_i}" if limit.to_i > 0
+      statement += ';'
+      statement
+    end
+
     def execute(*args)
       self.class.execute(*args)
     end
@@ -393,22 +370,5 @@ module Corm
     def table
       self.class.table
     end
-
-    ##
-    # Create and return the proper query to find the C* entries, given an array
-    # of keys.
-    #
-    # @param key_values An array of key names; can be empty, cannot be, in size, greater than the length of the model keys.
-    # @param field_names The "column names" for the `WHERE` clause.
-    def self.the_select_statement_for(key_values, field_names, limit = nil)
-      limit = "LIMIT #{limit.to_i}" if (limit && limit > 0)
-      if key_values.empty?
-        return "SELECT * FROM #{keyspace}.#{table} #{limit} ;"
-      elsif key_values.count > self.primary_key_count
-        raise Corm::TooManyKeysError
-      else
-        return "SELECT * FROM #{keyspace}.#{table} WHERE #{field_names.join(' AND ')} #{limit} ;"
-      end
-    end
   end
 end

data/lib/corm/retry/policies.rb

@@ -0,0 +1 @@
+require 'corm/retry/policies/default'

data/lib/corm/retry/policies/default.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'cassandra'
+
+module Corm
+  module Retry
+    module Policies
+      class Default
+        include Cassandra::Retry::Policy
+
+        def read_timeout(_statement, consistency, _required, _received, retrieved, retries)
+          return reraise if retries >= 5
+          sleep(retries.to_f + Random.rand(0.0..1.0))
+          retrieved ? reraise : try_again(consistency)
+        end
+
+        def write_timeout(_statement, consistency, _type, _required, _received, retries)
+          return reraise if retries >= 5
+          sleep(retries.to_f + Random.rand(0.0..1.0))
+          try_again(consistency)
+        end
+
+        def unavailable(_statement, consistency, _required, _alive, retries)
+          return reraise if retries >= 5
+          sleep(retries.to_f + Random.rand(0.0..1.0))
+          try_again(consistency)
+        end
+      end
+    end
+  end
+end

data/lib/corm/validations.rb

@@ -2,55 +2,52 @@
 
 module Corm
   module Validations
-
-    def there_are_too_many_keys_requested?(key_values)
-      if key_values.keys.count > self.primary_key_count
-        return "You defined more find keys than the primary keys of the table!"
-      end
-      false
+    def clustering_key_missing?(params)
+      return false if no_clustering_key?(params)
+      keys = clustering_key.map(&:to_sym) - params.keys.map(&:to_sym)
+      keys.empty? ? false : true
     end
 
-    def an_unknown_key_is_requested?(key_values)
-      unless (key_values.keys.map(&:to_sym) - self.primary_key.flatten).empty?
-        return "You requested a key that it's not in the table primary key!"
-      end
-      false
+    def no_clustering_key?(params)
+      (params.keys.map(&:to_sym) - partition_key.flatten.map(&:to_sym)).empty?
     end
 
-    def an_unknown_clustering_key_is_requested?(key_values)
-      unless ((key_values.keys.map(&:to_sym) - self.partition_key.flatten) - self.clustering_key).empty?
-        return "You requested some unsupported clustering keys!"
-      end
-      false
+    def partition_key_missing?(params)
+      keys = partition_key.map(&:to_sym) - params.keys.map(&:to_sym)
+      keys.empty? ? false : true
     end
 
-    def a_partition_key_is_missing?(key_values)
-      self.partition_key.each do |part_key|
-        return "#{part_key} is required as partition key!" unless key_values.keys.map(&:to_sym).include?(part_key.to_sym)
-      end
-      false
+    def too_many_keys?(params)
+      params.keys.count > primary_key_count ? true : false
     end
 
-    def a_clustering_key_is_missing?(key_values)
-
-      # This exception mimic the following...
-      # Class: <Cassandra::Errors::InvalidError>
-      # Message: <"PRIMARY KEY column 'still_another_uuid_field' cannot be
-      # restricted (preceding column 'another_uuid_field' is either not
-      # restricted or by a non-EQ relation)"
-      #
-      # ... and TBH leaving this check to the Cassandra driver is still an
-      # option.
-      return false if self.clustering_key.empty?
-      return false if no_clustering_key_requested?(key_values)
-      self.clustering_key.each do |clust_key|
-        return "#{clust_key} is required as clustering key! (Order matters)" unless key_values.keys.map(&:to_sym).include?(clust_key.to_sym)
-      end
-      false
+    def unknown_primary_key?(params)
+      (params.keys.map(&:to_sym) - primary_key.flatten.map(&:to_sym)).empty? ? false : true
     end
 
-    def no_clustering_key_requested?(key_values)
-      (key_values.keys.map(&:to_sym) - self.partition_key.flatten).empty?
+    def validate_query(params, opts)
+      if !params.is_a?(Hash)
+        error = ArgumentError
+        message = "'params' argument must be an hash: #{params}"
+      elsif !opts.is_a?(Hash)
+        error = ArgumentError
+        message = "'opts' argument must be an hash: #{opts}"
+      elsif too_many_keys?(params)
+        error = TooManyKeysError
+        message = "#{params.keys}"
+      elsif !params.empty? && partition_key_missing?(params)
+        error = MissingPartitionKey
+        message = "#{params.keys}"
+      elsif !params.empty? && clustering_key_missing?(params)
+        error = MissingClusteringKey
+        message = "#{params.keys}"
+      elsif !params.empty? && unknown_primary_key?(params)
+        error = UnknownPrimaryKey
+        message = "#{params.keys}"
+      else
+        return
+      end
+      fail(error, message, caller)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: corm
 version: !ruby/object:Gem::Version
-  version: 0.0.25
+  version: 0.0.26
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-25 00:00:00.000000000 Z
+date: 2015-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -95,9 +95,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/corm.rb
-- lib/corm/enhancements.rb
 - lib/corm/exceptions.rb
 - lib/corm/model.rb
+- lib/corm/retry/policies.rb
+- lib/corm/retry/policies/default.rb
 - lib/corm/validations.rb
 homepage: https://github.com/stefanofontanelli/corm
 licenses: []
@@ -113,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1990675893845593114
+      hash: -3769483612946445211
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -122,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1990675893845593114
+      hash: -3769483612946445211
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23.2

data/lib/corm/enhancements.rb

@@ -1,54 +0,0 @@
-# encoding: utf-8
-
-module Corm
-  module Enhancements
-
-    def enhancements_logger(logger = nil)
-      Logger.new(STDOUT).tap { |l| l.level = Logger::INFO } unless logger
-    end
-
-    RESCUED_CASSANDRA_EXCEPTIONS = [
-      ::Cassandra::Errors::ExecutionError,
-      ::Cassandra::Errors::IOError,
-      ::Cassandra::Errors::InternalError,
-      ::Cassandra::Errors::NoHostsAvailable,
-      ::Cassandra::Errors::ServerError,
-      ::Cassandra::Errors::TimeoutError
-    ]
-
-    # Trying to rescue from a Cassandra::Error
-    #
-    # The relevant documentation is here (version 2.1.3):
-    # https://datastax.github.io/ruby-driver/api/error/
-    #
-    # Saving from:
-    #
-    # - ::Cassandra::Errors::ExecutionError
-    # - ::Cassandra::Errors::IOError
-    # - ::Cassandra::Errors::InternalError
-    # - ::Cassandra::Errors::NoHostsAvailable
-    # - ::Cassandra::Errors::ServerError
-    # - ::Cassandra::Errors::TimeoutError
-    #
-    # Ignoring:
-    # - Errors::ClientError
-    # - Errors::DecodingError
-    # - Errors::EncodingError
-    # - Errors::ValidationError
-    #
-    # A possible and maybe-good refactoring could be refine for the
-    # network related issues.
-    def attempts_wrapper(attempts = 3, &block)
-      (1..attempts).each do |i|
-        begin
-          return block.call() if block_given?
-        rescue *RESCUED_CASSANDRA_EXCEPTIONS => e
-          sleep_for = i * Random.rand(1.5..2.5)
-          enhancements_logger.error { "(#{i}/#{attempts} attempts) Bad fail! Retry in #{sleep_for} seconds to recover  #{e.class.name}: #{e.message}" }
-          sleep(sleep_for)
-        end
-      end
-      nil
-    end
-  end
-end