corm 0.0.22 → 0.0.23

data/lib/corm/enhancements.rb

@@ -0,0 +1,54 @@
+# 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

data/lib/corm/exceptions.rb

@@ -0,0 +1,9 @@
+# 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
+end

data/lib/corm/model.rb

@@ -1,25 +1,43 @@
 # encoding: utf-8
 
 require 'cassandra'
+require 'corm/enhancements'
+require 'corm/exceptions'
+require 'corm/validations'
 require 'multi_json'
 require 'set'
+require 'digest/md5'
 
 module Corm
   class Model
     include Enumerable
+    extend Enhancements
+    extend Validations
 
     @@cluster = nil
 
+    # Since the `Cassandra.cluster` method wants to connect, the configure will
+    # retry a couple of times (implemented in the Enhancements module) before
+    # give up...
+    # If it fails `@@cluster` was nil and nil remains.
     def self.configure(opts = {})
-      @@cluster = Cassandra.cluster(opts)
+      attempts_wrapper do
+        @@cluster = Cassandra.cluster(opts)
+      end
     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)
-      session.execute(*args)
+      attempts_wrapper { session.execute(*args) }
     end
 
     def self.field(name, type, pkey = false)
@@ -139,20 +157,74 @@ module Corm
     end
 
     def self.drop!
-      execute("DROP TABLE #{[keyspace, table].compact.join '.'};")
+      execute("DROP TABLE IF EXISTS #{[keyspace, table].compact.join('.')};")
     end
 
-    def self.get(relations)
-      if statements['get'].nil?
-        fields = primary_key.flatten.map { |key| "#{key} = ?" }.join ' AND '
-        statement = "SELECT * FROM #{keyspace}.#{table} WHERE #{fields} LIMIT 1;"
-        statements['get'] = session.prepare statement
+    ##
+    # Find by keys.
+    # This `find` methods wants to be as flexible as possible.
+    #
+    # Unless a block is given, it returns an `Enumerator`, otherwise it yields
+    # to the block an instance of the found Cassandra entries.
+    #
+    # If no keys is passed as parameter, the methods returns (an Enumerator for)
+    # all the results in the table.
+    #
+    # 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
+    # names" and the values... are the values.
+    #
+    # If the keys passed as parameter are more than the defined by the table the
+    # query is not valid, it cannot be executed and an error is raised.
+    # 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
-      values = primary_key.flatten.map do |key|
-        relations[key.to_s] || relations[key.to_sym]
+
+      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} = ?"
       end
-      cassandra_record_ = execute(statements['get'], arguments: values).first
-      cassandra_record_ ? new(_cassandra_record: cassandra_record_) : nil
+
+      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_))
+      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
     end
 
     def self.keyspace(name = nil)
@@ -160,14 +232,20 @@ module Corm
       class_variable_get(:@@keyspace)
     end
 
+    # Eventually set and return the session, taken from the connection to
+    # the cluster.
+    #
+    # This operation is wrapped by the retry policy (module Enhancements).
     def self.keyspace!(opts = {})
       replication = opts[:replication] ||
                     "{'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' : ''
-      cluster.connect.execute(
-        "CREATE KEYSPACE #{if_not_exists} #{keyspace} WITH replication = #{replication} AND durable_writes = #{durable_writes};"
-      )
+      attempts_wrapper do
+        cluster.connect.execute(
+          "CREATE KEYSPACE #{if_not_exists} #{keyspace} WITH replication = #{replication} AND durable_writes = #{durable_writes};"
+        )
+      end
     end
 
     def self.primary_key(partition_key = nil, *cols)
@@ -178,6 +256,18 @@ module Corm
       class_variable_get(:@@primary_key)
     end
 
+    def self.primary_key_count
+      self.primary_key.flatten.count
+    end
+
+    def self.partition_key
+      self.primary_key.first.map(&:to_sym)
+    end
+
+    def self.clustering_key
+      self.primary_key.count == 2 ? self.primary_key[1].flatten.map(&:to_sym) : []
+    end
+
     def self.properties(*args)
       class_variable_set(
         :@@properties,
@@ -186,11 +276,19 @@ module Corm
       class_variable_get(:@@properties)
     end
 
+    # Eventually set and return the session, taken from the connection to
+    # the cluster.
+    #
+    # This operation is wrapped by the retry policy (module Enhancements).
     def self.session
-      class_variable_set(
-        :@@session,
-        cluster.connect(keyspace)
-      ) unless class_variable_defined?(:@@session)
+      unless class_variable_defined?(:@@session)
+        attempts_wrapper do
+          class_variable_set(
+            :@@session,
+            cluster.connect(keyspace)
+          )
+        end
+      end
       class_variable_get :@@session
     end
 
@@ -295,5 +393,22 @@ 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/validations.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+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
+    end
+
+    def an_unknown_key_is_requested?(key_values)
+      unless (key_values.keys - self.primary_key.flatten).empty?
+        return "You requested a key that it's not in the table primary key!"
+      end
+      false
+    end
+
+    def an_unknown_clustering_key_is_requested?(key_values)
+      unless ((key_values.keys - self.partition_key.flatten) - self.clustering_key).empty?
+        return "You requested some unsupported clustering keys!"
+      end
+      false
+    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.include?(part_key.to_sym)
+      end
+      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.include?(clust_key.to_sym)
+      end
+      false
+    end
+
+    def no_clustering_key_requested?(key_values)
+      (key_values.keys - self.partition_key.flatten).empty?
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: corm
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.0.23
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-11 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -71,6 +71,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 10.0.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.1
 description: ''
 email:
 - stefano@gild.com
@@ -79,7 +95,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/corm.rb
+- lib/corm/enhancements.rb
+- lib/corm/exceptions.rb
 - lib/corm/model.rb
+- lib/corm/validations.rb
 homepage: https://github.com/stefanofontanelli/corm
 licenses: []
 post_install_message: 
@@ -92,12 +111,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1645116542226153215
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 1645116542226153215
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23.2