datastax_rails 2.0.16 → 2.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 132b266af9a95c9c39cf2ebd31070736456203a9
-  data.tar.gz: 456554a5b9f107ceb7766f8dc8d80b9e842ef53a
+  metadata.gz: 19e0c7c773fb3991c35ee3c5a4f76ec967d9041c
+  data.tar.gz: 4a5033007b3009ea785e38935f0d0a7c5a6eb410
 SHA512:
-  metadata.gz: f91a8dcaba63be7244c3d58621fab35a9677e7cf1c93e9763f6adf9ef25b203a6883531100c7a357082b60e980435c1f7a276eab0f87ed35758be4701a3debe5
-  data.tar.gz: 773c2de70abae6deae8ba0119873c760b61cb14e0992c88e39975446136a82856f1fc177802b23a78e378ece41b075942adef07d5b13f2af891d49967c31f3c1
+  metadata.gz: f3ead232f919376053a15e813cec9d08630ff7ae4414300590ff2b8500077b9c6622a5347dec3d2ce5f25e22a528df05399843d8eff6587ef24df14ba1cc7be1
+  data.tar.gz: 4f620b9de99f047c114386357424cd1516432f81a45c1c3d446d31343712cd67c4396f46d2dab624b75361026dd58905982553540e8872c8bed9d06a3b98eac5

data/README.rdoc

@@ -15,10 +15,11 @@ Significant changes from SolandraObject:
 
 === Usage Note
 
-Before using this gem, you should probably take a strong look at the type of problem you are trying to solve.  Cassandra is primarily 
-designed as a solution to Big Data problems.  This gem is not.  You will notice that it still carries a lot of relational logic with it.  
-We are using DSE to solve a replication problem more so than a Big Data problem.  That's not to say that this gem won't work for Big Data problems, 
-it just might not be ideal.  You've been warned...
+Before using this gem, you should probably take a strong look at the type of problem you are trying to solve.
+Cassandra is primarily designed as a solution to Big Data problems. This gem is not. You will notice that it
+still carries a lot of relational logic with it. We are using DSE to solve a replication problem more so than
+a Big Data problem. That's not to say that this gem won't work for Big Data problems, it just might not be
+ideal. You've been warned...
 
 === Getting started
 
@@ -31,6 +32,7 @@ Configure the config/datastax.yml file:
   development:
     servers: ["127.0.0.1"]
     port: 9042
+    ssl: true
     keyspace: "<my_app>_development"
     strategy_class: "org.apache.cassandra.locator.NetworkTopologyStrategy"
     strategy_options: {"DC1": "1"} 
@@ -48,6 +50,7 @@ For a more simple, single datacenter setup, something like this should probably
   development:
     servers: ["127.0.0.1"]
     port: 9042
+    ssl: false
     keyspace: "datastax_rails_development"
     strategy_class: "org.apache.cassandra.locator.SimpleStrategy"
     strategy_options: {"replication_factor": "1"}

data/config/solrconfig.xml.erb

@@ -70,20 +70,14 @@
        the classpath, this is useful for including all jars in a
        directory.
     -->
-  <lib dir="../../contrib/extraction/lib" />
   <!-- When a regex is specified in addition to a directory, only the
        files in that directory which completely match the regex
        (anchored on both ends) will be included.
     -->
-  <lib dir="../../dist/" regex="apache-solr-cell-\d.*\.jar" />
-  <lib dir="../../dist/" regex="apache-solr-clustering-\d.*\.jar" />
-  <lib dir="../../dist/" regex="apache-solr-dataimporthandler-\d.*\.jar" />
 
   <!-- If a dir option (with or without a regex) is used and nothing
        is found that matches, it will be ignored
     -->
-  <lib dir="../../contrib/clustering/lib/" />
-  <lib dir="/total/crap/dir/ignored" /> 
   <!-- an exact path can be used to specify a specific file.  This
        will cause a serious error to be logged if it can't be loaded.
     -->
@@ -219,8 +213,7 @@
                    triggering a new commit. 
       -->
        <autoSoftCommit> 
-         <maxTime>1000</maxTime> 
-         <maxDocs>1</maxDocs>
+         <maxTime><%= @solr_commit_time %></maxTime> 
        </autoSoftCommit>
 
     <!-- Update Related Event Listeners

data/lib/cql-rb_extensions.rb

@@ -12,7 +12,7 @@ Cql::Client::ConnectionManager.class_eval do
   attr_reader :current_connection
 
   def random_connection
-    fail NotConnectedError unless connected?
+    fail ::Cql::NotConnectedError unless connected?
     @lock.synchronize do
       @count ||= 0
       @count += 1

data/lib/datastax_rails.rb

@@ -9,6 +9,7 @@ module DatastaxRails
   autoload :Associations
   autoload :AttributeAssignment
   autoload :AttributeMethods
+  autoload :AutosaveAssociation
   autoload :Base
   autoload :Batches
   autoload :Callbacks
@@ -101,3 +102,7 @@ require 'datastax_rails/errors'
 require 'cql-rb_extensions'
 
 ActiveSupport.run_load_hooks(:datastax_rails, DatastaxRails::Base)
+
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.dirname(__FILE__) + '/datastax_rails/locale/en.yml'
+end

data/lib/datastax_rails/associations.rb

@@ -62,7 +62,7 @@ module DatastaxRails
       @association_cache[name] = association
     end
 
-    module ClassMethods
+    module ClassMethods # rubocop:disable Style/Documentation
       def belongs_to(name, options = {})
         Builder::BelongsTo.build(self, name, options)
       end

data/lib/datastax_rails/associations/association_scope.rb

@@ -1,6 +1,7 @@
 module DatastaxRails
   module Associations
-    class AssociationScope #:nodoc:
+    # Creates the scope (relation) for the assocation
+    class AssociationScope
       attr_reader :association
 
       delegate :klass, :owner, :reflection, to: :association

data/lib/datastax_rails/associations/belongs_to_association.rb

@@ -1,6 +1,17 @@
 module DatastaxRails
   module Associations
-    class BelongsToAssociation < SingularAssociation #:nodoc:
+    # belongs_to associations are the child side of a parent/child relationship
+    #
+    #   class Car < DatastaxRails::Base
+    #     uuid :id
+    #     uuid :owner_id
+    #     belongs_to :owner, class_name: 'Person'
+    #   end
+    #
+    # Valid options:
+    # * class_name - The class on the other side (if different than what +classify+ returns)
+    # * foreign_key - The name of the foreign_key column if not just _id at the end of the association name
+    class BelongsToAssociation < SingularAssociation
       attr_reader :updated
       alias_method :updated?, :updated
       def replace(record)

data/lib/datastax_rails/associations/builder/association.rb

@@ -16,11 +16,14 @@ module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModu
       @model, @name, @options = model, name, options
     end
 
+    include Module.new { def build; end }
+
     def build
       validate_options
-      reflection = model.create_reflection(self.class.macro, name, options, model)
+      @reflection = model.create_reflection(self.class.macro, name, options, model)
       define_accessors
-      reflection
+      super # provides an extension point
+      @reflection
     end
 
     def mixin

data/lib/datastax_rails/associations/has_one_association.rb

@@ -1,6 +1,7 @@
 module DatastaxRails
   module Associations
-    class HasOneAssociation < SingularAssociation #:nodoc:
+    # A has_one association is the parent of a one-to-one parent/child relation
+    class HasOneAssociation < SingularAssociation
       def replace(record, save = true)
         raise_on_type_mismatch(record) if record
         load_target

data/lib/datastax_rails/associations/singular_association.rb

@@ -1,6 +1,7 @@
 module DatastaxRails
   module Associations
-    class SingularAssociation < Association #:nodoc:
+    # Encapsulates the common functionality between belongs_to and has_one relationships
+    class SingularAssociation < Association
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
       def reader(force_reload = false)
         reload if force_reload || !loaded? || stale_target?

data/lib/datastax_rails/autosave_association.rb

@@ -0,0 +1,429 @@
+# rubocop:disable
+module DatastaxRails
+  # = DatastaxRails Autosave Association
+  #
+  # +AutosaveAssociation+ is a module that takes care of automatically saving
+  # associated records when their parent is saved. In addition to saving, it
+  # also destroys any associated records that were marked for destruction.
+  # (See +mark_for_destruction+ and <tt>marked_for_destruction?</tt>).
+  #
+  # If validations for any of the associations fail, their error messages will
+  # be applied to the parent.
+  #
+  # Note that it also means that associations marked for destruction won't
+  # be destroyed directly. They will however still be marked for destruction.
+  #
+  # Note that <tt>autosave: false</tt> is not same as not declaring <tt>:autosave</tt>.
+  # When the <tt>:autosave</tt> option is not present then new association records are
+  # saved but the updated association records are not saved.
+  #
+  # == Validation
+  #
+  # Children records are validated unless <tt>:validate</tt> is +false+.
+  #
+  # == Callbacks
+  #
+  # Association with autosave option defines several callbacks on your
+  # model (before_save, after_create, after_update). Please note that
+  # callbacks are executed in the order they were defined in the
+  # model. You should avoid modifying the association content, before
+  # autosave callbacks are executed. Placing your callbacks after
+  # associations is usually a good practice.
+  #
+  # === One-to-one Example
+  #
+  #   class Post
+  #     has_one :author, autosave: true
+  #   end
+  #
+  # Saving changes to the parent and its associated model can now be performed
+  # automatically:
+  #
+  #   post = Post.find(1)
+  #   post.title       # => "The current global position of migrating ducks"
+  #   post.author.name # => "alloy"
+  #
+  #   post.title = "On the migration of ducks"
+  #   post.author.name = "Eloy Duran"
+  #
+  #   post.save
+  #   post.reload
+  #   post.title       # => "On the migration of ducks"
+  #   post.author.name # => "Eloy Duran"
+  #
+  # Destroying an associated model, as part of the parent's save action, is as
+  # simple as marking it for destruction:
+  #
+  #   post.author.mark_for_destruction
+  #   post.author.marked_for_destruction? # => true
+  #
+  # Note that the model is _not_ yet removed from the database:
+  #
+  #   id = post.author.id
+  #   Author.find_by(id: id).nil? # => false
+  #
+  #   post.save
+  #   post.reload.author # => nil
+  #
+  # Now it _is_ removed from the database:
+  #
+  #   Author.find_by(id: id).nil? # => true
+  #
+  # === One-to-many Example
+  #
+  # When <tt>:autosave</tt> is not declared new children are saved when their parent is saved:
+  #
+  #   class Post
+  #     has_many :comments # :autosave option is not declared
+  #   end
+  #
+  #   post = Post.new(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  # When <tt>:autosave</tt> is true all children are saved, no matter whether they
+  # are new records or not:
+  #
+  #   class Post
+  #     has_many :comments, autosave: true
+  #   end
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
+  #   post.comments[0].body = 'hi everyone'
+  #   post.save # => saves both post and comment, with 'hi everyone' as body
+  #
+  # Destroying one of the associated models as part of the parent's save action
+  # is as simple as marking it for destruction:
+  #
+  #   post.comments.last.mark_for_destruction
+  #   post.comments.last.marked_for_destruction? # => true
+  #   post.comments.length # => 2
+  #
+  # Note that the model is _not_ yet removed from the database:
+  #
+  #   id = post.comments.last.id
+  #   Comment.find_by(id: id).nil? # => false
+  #
+  #   post.save
+  #   post.reload.comments.length # => 1
+  #
+  # Now it _is_ removed from the database:
+  #
+  #   Comment.find_by(id: id).nil? # => true
+  module AutosaveAssociation
+    extend ActiveSupport::Concern
+
+    # Extends the association builder to add autosave callbacks
+    module AssociationBuilderExtension
+      def build
+        model.send(:add_autosave_association_callbacks, reflection)
+        super
+      end
+    end
+
+    included do
+      require 'datastax_rails/associations/builder/association'
+      Associations::Builder::Association.class_eval do
+        valid_options << :autosave
+        include AssociationBuilderExtension
+      end
+    end
+
+    module ClassMethods # rubocop:disable Style/Documentation
+      private
+
+      def define_non_cyclic_method(name, reflection, &block)
+        define_method(name) do |*_args|
+          result = true
+          @_already_called ||= {}
+          # Loop prevention for validation of associations
+          unless @_already_called[[name, reflection.name]]
+            begin
+              @_already_called[[name, reflection.name]] = true
+              result = instance_eval(&block)
+            ensure
+              @_already_called[[name, reflection.name]] = false
+            end
+          end
+
+          result
+        end
+      end
+
+      # Adds validation and save callbacks for the association as specified by
+      # the +reflection+.
+      #
+      # For performance reasons, we don't check whether to validate at runtime.
+      # However the validation and callback methods are lazy and those methods
+      # get created when they are invoked for the very first time. However,
+      # this can change, for instance, when using nested attributes, which is
+      # called _after_ the association has been defined. Since we don't want
+      # the callbacks to get defined multiple times, there are guards that
+      # check if the save or validation methods have already been defined
+      # before actually defining them.
+      def add_autosave_association_callbacks(reflection)
+        save_method = :"autosave_associated_records_for_#{reflection.name}"
+        validation_method = :"validate_associated_records_for_#{reflection.name}"
+        collection = reflection.collection?
+
+        unless method_defined?(save_method)
+          if collection
+            before_save :before_save_collection_association
+
+            define_non_cyclic_method(save_method, reflection) { save_collection_association(reflection) }
+            # Doesn't use after_save as that would save associations added in after_create/after_update twice
+            after_create save_method
+            after_update save_method
+          elsif reflection.macro == :has_one
+            define_method(save_method) { save_has_one_association(reflection) }
+            # Configures two callbacks instead of a single after_save so that
+            # the model may rely on their execution order relative to its
+            # own callbacks.
+            #
+            # For example, given that after_creates run before after_saves, if
+            # we configured instead an after_save there would be no way to fire
+            # a custom after_create callback after the child association gets
+            # created.
+            after_create save_method
+            after_update save_method
+          else
+            define_non_cyclic_method(save_method, reflection) { save_belongs_to_association(reflection) }
+            before_save save_method
+          end
+        end
+
+        if reflection.validate? && !method_defined?(validation_method) # rubocop:disable Style/GuardClause
+          method = (collection ? :validate_collection_association : :validate_single_association)
+          define_non_cyclic_method(validation_method, reflection) { send(method, reflection) }
+          validate validation_method
+        end
+      end
+    end
+
+    # Reloads the attributes of the object as usual and clears <tt>marked_for_destruction</tt> flag.
+    def reload(options = nil)
+      @marked_for_destruction = false
+      @destroyed_by_association = nil
+      super
+    end
+
+    # Marks this record to be destroyed as part of the parents save transaction.
+    # This does _not_ actually destroy the record instantly, rather child record will be destroyed
+    # when <tt>parent.save</tt> is called.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    # Returns whether or not this record will be destroyed as part of the parents save transaction.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    attr_reader :marked_for_destruction
+    alias_method :marked_for_destruction?, :marked_for_destruction
+
+    # Records the association that is being destroyed and destroying this
+    # record in the process.
+    attr_writer :destroyed_by_association
+
+    # Returns the association for the parent being destroyed.
+    #
+    # Used to avoid updating the counter cache unnecessarily.
+    attr_reader :destroyed_by_association
+
+    # Returns whether or not this record has been changed in any way (including whether
+    # any of its nested autosave associations are likewise changed)
+    def changed_for_autosave?
+      new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
+    end
+
+    private
+
+    # Returns the record for an association collection that should be validated
+    # or saved. If +autosave+ is +false+ only new records will be returned,
+    # unless the parent is/was a new record itself.
+    def associated_records_to_validate_or_save(association, new_record, autosave)
+      if new_record
+        association && association.target
+      elsif autosave
+        association.target.select { |record| record.changed_for_autosave? }
+      else
+        association.target.select { |record| record.new_record? }
+      end
+    end
+
+    # go through nested autosave associations that are loaded in memory (without loading
+    # any new ones), and return true if is changed for autosave
+    def nested_records_changed_for_autosave?
+      self.class.reflect_on_all_autosave_associations.any? do |reflection|
+        association = association_instance_get(reflection.name)
+        association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
+      end
+    end
+
+    # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
+    # turned on for the association.
+    def validate_single_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association && association.reader
+      association_valid?(reflection, record) if record
+    end
+
+    # Validate the associated records if <tt>:validate</tt> or
+    # <tt>:autosave</tt> is turned on for the association specified by
+    # +reflection+.
+    def validate_collection_association(reflection)
+      if (association = association_instance_get(reflection.name))
+        records = associated_records_to_validate_or_save(association,
+                                                         new_record?,
+                                                         reflection.options[:autosave])
+        if records
+          records.each { |record| association_valid?(reflection, record) }
+        end
+      end
+    end
+
+    # Returns whether or not the association is valid and applies any errors to
+    # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
+    # enabled records if they're marked_for_destruction? or destroyed.
+    def association_valid?(reflection, record)
+      return true if record.destroyed? || record.marked_for_destruction?
+
+      unless valid = record.valid?
+        if reflection.options[:autosave]
+          record.errors.each do |attribute, message|
+            attribute = "#{reflection.name}.#{attribute}"
+            errors[attribute] << message
+            errors[attribute].uniq!
+          end
+        else
+          errors.add(reflection.name)
+        end
+      end
+      valid
+    end
+
+    # Is used as a before_save callback to check while saving a collection
+    # association whether or not the parent was a new record before saving.
+    def before_save_collection_association
+      @new_record_before_save = new_record?
+      true
+    end
+
+    # Saves any new associated records, or all loaded autosave associations if
+    # <tt>:autosave</tt> is enabled on the association.
+    #
+    # In addition, it destroys all children that were marked for destruction
+    # with mark_for_destruction.
+    def save_collection_association(reflection)
+      if association = association_instance_get(reflection.name)
+        autosave = reflection.options[:autosave]
+
+        if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+
+          if autosave
+            records_to_destroy = records.select(&:marked_for_destruction?)
+            records_to_destroy.each { |record| association.destroy(record) }
+            records -= records_to_destroy
+          end
+
+          records.each do |record|
+            next if record.destroyed?
+
+            saved = true
+
+            if autosave != false && (@new_record_before_save || record.new_record?)
+              if autosave
+                saved = association.insert_record(record, false)
+              else
+                association.insert_record(record) unless reflection.nested?
+              end
+            elsif autosave
+              saved = record.save(validate: false)
+            end
+
+            fail ActiveRecord::Rollback unless saved
+          end
+          @new_record_before_save = false unless reflection.macro == :has_and_belongs_to_many
+        end
+
+        # reconstruct the scope now that we know the owner's id
+        association.reset_scope if association.respond_to?(:reset_scope)
+      end
+    end
+
+    # Saves the associated record if it's new or <tt>:autosave</tt> is enabled
+    # on the association.
+    #
+    # In addition, it will destroy the association if it was marked for
+    # destruction with mark_for_destruction.
+    #
+    # This all happens inside a transaction, _if_ the Transactions module is included into
+    # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
+    def save_has_one_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+
+          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
+            unless reflection.through_reflection
+              record[reflection.foreign_key] = key
+            end
+
+            saved = record.save(validate: !autosave)
+            fail ActiveRecord::Rollback if !saved && autosave
+            saved
+          end
+        end
+      end
+    end
+
+    # If the record is new or it has changed, returns true.
+    def record_changed?(reflection, record, key)
+      record.new_record? ||
+        record[reflection.foreign_key] != key ||
+        record.changed_attributes.include?(reflection.foreign_key)
+    end
+
+    # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
+    #
+    # In addition, it will destroy the association if it was marked for destruction.
+    def save_belongs_to_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          self[reflection.foreign_key] = nil
+          record.destroy
+        elsif autosave != false
+          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+
+          if association.updated?
+            association_id = record.send(reflection.options[:primary_key] || :id)
+            self[reflection.foreign_key] = association_id
+            association.loaded!
+          end
+
+          saved if autosave
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/base.rb

@@ -360,6 +360,7 @@ module DatastaxRails #:nodoc:
     include Callbacks
     include Reflection
     include Associations
+    include AutosaveAssociation
     include Scoping
     include Timestamps
     include Serialization
@@ -387,6 +388,10 @@ module DatastaxRails #:nodoc:
     # See {DatastaxRails::WideStorageModel} or {DatastaxRails::Payload} model for an example
     class_attribute :create_options
 
+    # Allows the setting of how frequently to commit data to solr. Default is 10s.
+    class_attribute :solr_commit_time
+    self.solr_commit_time = 10_000
+
     # Stores the attribute that wide models should cluster on. Basically, this is the
     # attribute that CQL uses to "group" columns into logical records even though they
     # are stored on the same row.
@@ -401,9 +406,6 @@ module DatastaxRails #:nodoc:
     class_attribute :serialized_attributes
     self.serialized_attributes = {}
 
-    # Whether or not we are using solr legacy mappings
-    class_attribute :legacy_mapping
-
     def initialize(attributes = {}, _options = {})
       defaults = self.class.column_defaults.dup
       defaults.each { |_k, v| v.duplicable? ? v.dup : v }
@@ -556,10 +558,6 @@ module DatastaxRails #:nodoc:
         ancestors.include?(DatastaxRails::WideStorageModel)
       end
 
-      def legacy_mapping?
-        legacy_mapping
-      end
-
       def base_class
         klass = self
         klass = klass.superclass while klass.superclass != Base

data/lib/datastax_rails/connection.rb

@@ -15,11 +15,12 @@ module DatastaxRails
       class_attribute :solr
     end
 
-    module ClassMethods
+    module ClassMethods # rubocop:disable Style/Documentation
       DEFAULT_OPTIONS = {
-        servers:     '127.0.0.1:9160',
-        thrift:      {},
-        cql_version: '3.0.0'
+        servers:            '127.0.0.1',
+        port:               9160,
+        connection_options: { timeout: 10 },
+        ssl:                false
       }
 
       # Returns the current server that we are talking to.  This is useful when you are talking to a
@@ -40,6 +41,11 @@ module DatastaxRails
       #
       #   servers: ["10.1.2.5"]
       #   port: 9042
+      #   ssl:
+      #     cert: config/datastax_rails.crt
+      #     key: config/datastax_rails.key
+      #     ca_cert: config/ca.crt
+      #     keypass: changeme
       #   keyspace: "datastax_rails_production"
       #   strategy_class: "org.apache.cassandra.locator.NetworkTopologyStrategy"
       #   strategy_options: {"DS1": "3", "DS2": "3", "DS3": "3"}
@@ -48,18 +54,13 @@ module DatastaxRails
       #   solr:
       #     port: 8983
       #     path: /solr
-      #     ssl:
-      #       use_ssl: true
-      #       cert: config/datastax_rails.crt
-      #       key: config/datastax_rails.key
-      #       keypass: changeme
       #
       # The +servers+ entry should be a list of all seed nodes for servers you wish to connect to.  DSR
       # will automatically connect to all nodes in the cluster or in the datacenter if you are using multiple
       # datacenters.  You can safely just list all nodes in a particular datacenter if you would like.
       #
-      # The port to connect to, this port will be used for all nodes. Because the `system.peers` table does not contain
-      # the port that the nodes are listening on, the port must be the same for all nodes.
+      # The port to connect to, this port will be used for all nodes. Because the `system.peers` table does
+      # not contain the port that the nodes are listening on, the port must be the same for all nodes.
       #
       # Since we're using the NetworkTopologyStrategy for our locator, it is important that you configure
       # cassandra-topology.properties.  See the DSE documentation at http://www.datastax.com for more
@@ -73,36 +74,59 @@ module DatastaxRails
       # * *retries* - Number of times a request will be retried. Should likely be the number of servers - 1.
       #   Defaults to 0.
       # * *server_retry_period* - Amount of time to wait before retrying a down server. Defaults to 1.
-      # * *server_max_requests* - Number of requests to make to a server before moving to the next one (helps keep load
-      #   balanced). Default to nil which means cycling does not take place.
+      # * *server_max_requests* - Number of requests to make to a server before moving to the next one (helps
+      #   keep load balanced). Default to nil which means cycling does not take place.
       # * *retry_overrides* - Overrides retries option for individual exceptions.
       # * *connect_timeout* - The connection timeout on the Thrift socket. Defaults to 0.1.
       # * *timeout* - The timeout for the transport layer. Defaults to 1.
-      # * *timeout_overrides* - Overrides the timeout value for specific methods (advanced).
-      # * *exception_classes* - List of exceptions for which Thrift will automatically retry a new server in the cluster
-      #   (up to retry limit).
-      #   Defaults to [IOError, Thrift::Exception, Thrift::ApplicationException, Thrift::TransportException].
-      # * *exception_class_overrides* - List of exceptions which will never cause a retry.
-      #   Defaults to [CassandraCQL::Thrift::InvalidRequestException].
-      # * *wrapped_exception_options* - List of exceptions that will be automatically wrapped in an exception provided
-      #   by client class with the same name (advanced).
-      #   Defaults to [Thrift::ApplicationException, Thrift::TransportException].
-      # * *raise* - Whether to raise exceptions or default calls that cause an error (advanced). Defaults to true
-      #   (raise exceptions).
-      # * *defaults* - When raise is false and an error is encountered, these methods are called to default the return
-      #   value (advanced). Should be a hash of method names to values.
-      # * *protocol* - The thrift protocol to use (advanced). Defaults to Thrift::BinaryProtocol.
-      # * *protocol_extra_params* - Any extra parameters to send to the protocol (advanced).
-      # * *transport* - The thrift transport to use (advanced). Defaults to Thrift::Socket.
-      # * *transport_wrapper* - The thrift transport wrapper to use (advanced). Defaults to Thrift::FramedTransport.
       #
       # See +solr_connection+ for a description of the solr options in datastax.yml
       def establish_connection(spec)
         DatastaxRails::Base.config = spec.with_indifferent_access
         spec.reverse_merge!(DEFAULT_OPTIONS)
-        self.connection = ::Cql::Client.connect(hosts:              spec[:servers],
-                                                keyspace:           spec[:keyspace],
-                                                connection_timeout: spec[:connection_options][:timeout])
+        cql_options = { hosts:              spec[:servers],
+                        keyspace:           spec[:keyspace],
+                        connection_timeout: spec[:connection_options][:timeout] }
+        if ssl_type
+          ca_cert = Pathname.new(DatastaxRails::Base.config[:ssl][:ca_cert])
+          ca_cert = Rails.root.join(ca_cert) unless ca_cert.absolute?
+          ssl_context = OpenSSL::SSL::SSLContext.new
+          ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          ssl_context.ca_file = ca_cert.to_s
+          if ssl_type == :two_way_ssl
+            cert = Pathname.new(DatastaxRails::Base.config[:ssl][:cert])
+            key = Pathname.new(DatastaxRails::Base.config[:ssl][:key])
+            pass = DatastaxRails::Base.config[:ssl][:keypass]
+            cert = Rails.root.join(cert) unless cert.absolute?
+            key = Rails.root.join(key) unless key.absolute?
+            if pass
+              ssl_context.key = OpenSSL::PKey::RSA.new(key.read, pass)
+            else
+              ssl_context.key = OpenSSL::PKey::RSA.new(key.read)
+            end
+            ssl_context.cert = OpenSSL::X509::Certificate.new(cert.read)
+          end
+          cql_options[:ssl] = ssl_context
+        end
+        self.connection = ::Cql::Client.connect(cql_options)
+      end
+      
+      def ssl_type
+        return false unless DatastaxRails::Base.config && DatastaxRails::Base.config[:ssl]
+        config = DatastaxRails::Base.config
+        if config[:ssl][:key] && config[:ssl][:cert]
+          :two_way_ssl
+        elsif config[:ssl][:ca_cert]
+          :one_way_ssl
+        else
+          false
+        end
+      end
+
+      def reconnect
+        connection.close rescue true
+        self.connection = nil
+        establish_connection(DatastaxRails::Base.config)
       end
 
       # Returns the base portion of the URL for connecting to SOLR based on the current Cassandra server.
@@ -112,7 +136,7 @@ module DatastaxRails
         DatastaxRails::Base.establish_connection unless connection
         port = DatastaxRails::Base.config[:solr][:port]
         path = DatastaxRails::Base.config[:solr][:path]
-        protocol = DatastaxRails::Base.config[:solr].key?(:ssl) && DatastaxRails::Base.config[:solr][:ssl][:use_ssl] ? 'https' : 'http' # rubocop:disable LineLength
+        protocol = ssl_type ? 'https' : 'http'
         "#{protocol}://#{current_server}:#{port}#{path}"
       end
 
@@ -135,17 +159,18 @@ module DatastaxRails
       # @return [RSolr::Client] RSolr client object
       def establish_solr_connection
         opts = { url: "#{solr_base_url}/#{DatastaxRails::Base.connection.keyspace}.#{column_family}" }
-        if DatastaxRails::Base.config[:solr].key?(:ssl) &&
-            DatastaxRails::Base.config[:solr][:ssl].key?(:cert) &&
-            DatastaxRails::Base.config[:solr][:ssl][:use_ssl]
-          cert = Pathname.new(DatastaxRails::Base.config[:solr][:ssl][:cert])
-          key = Pathname.new(DatastaxRails::Base.config[:solr][:ssl][:key])
-          pass = DatastaxRails::Base.config[:solr][:ssl][:keypass]
+        if ssl_type == :two_way_ssl
+          ca_cert = Pathname.new(DatastaxRails::Base.config[:ssl][:ca_cert])
+          cert = Pathname.new(DatastaxRails::Base.config[:ssl][:cert])
+          key = Pathname.new(DatastaxRails::Base.config[:ssl][:key])
+          pass = DatastaxRails::Base.config[:ssl][:keypass]
+          ca_cert = Rails.root.join(ca_cert) unless ca_cert.absolute?
           cert = Rails.root.join(cert) unless cert.absolute?
           key = Rails.root.join(key) unless key.absolute?
           opts[:ssl_cert_file] = cert.to_s
           opts[:ssl_key_file] = key.to_s
           opts[:ssl_key_pass] = pass if pass
+          opts[:ssl_ca_file] = ca_cert.to_s
 
           RSolr::ClientCert.connect opts
         else

data/lib/datastax_rails/cql.rb

@@ -1,4 +1,8 @@
 module DatastaxRails
+  # The Cql classes handle all of the generation of CQL. They are constructed in such a way that
+  # the statement can be built up over multiple calls before generating the actual CQL.
+  #
+  # TODO: Add examples
   module Cql
     extend ActiveSupport::Autoload
     class << self

data/lib/datastax_rails/cql/base.rb

@@ -27,11 +27,23 @@ module DatastaxRails
         puts cql if ENV['DEBUG_CQL'] == 'true'
         pp @values if ENV['DEBUG_CQL'] == 'true'
         digest = Digest::MD5.digest cql
-        stmt = DatastaxRails::Base.statement_cache[digest] ||= DatastaxRails::Base.connection.prepare(cql)
-        if @consistency
-          stmt.execute(*@values, consistency: @consistency)
-        else
-          stmt.execute(*@values)
+        try_again = true
+        begin
+          stmt = DatastaxRails::Base.statement_cache[digest] ||= DatastaxRails::Base.connection.prepare(cql)
+          if @consistency
+            stmt.execute(*@values, consistency: @consistency)
+          else
+            stmt.execute(*@values)
+          end
+        rescue ::Cql::NotConnectedError
+          if try_again
+            Rails.logger.warn('Lost connection to Cassandra. Attempting to reconnect...')
+            try_again = false
+            DatastaxRails::Base.reconnect
+            retry
+          else
+            raise
+          end
         end
       end
     end

data/lib/datastax_rails/locale/en.yml

@@ -0,0 +1,47 @@
+en:
+  # Attributes names common to most models
+  #attributes:
+    #created_at: "Created at"
+    #updated_at: "Updated at"
+
+  # Default error messages
+  errors:
+    messages:
+      taken: "has already been taken"
+
+  # Active Record models configuration
+  activerecord:
+    errors:
+      messages:
+        record_invalid: "Validation failed: %{errors}"
+        restrict_dependent_destroy:
+          one: "Cannot delete record because a dependent %{record} exists"
+          many: "Cannot delete record because dependent %{record} exist"
+        # Append your own errors here or at the model/attributes scope.
+
+      # You can define own errors for models or model attributes.
+      # The values :model, :attribute and :value are always available for interpolation.
+      #
+      # For example,
+      #   models:
+      #     user:
+      #       blank: "This is a custom blank message for %{model}: %{attribute}"
+      #       attributes:
+      #         login:
+      #           blank: "This is a custom blank message for User login"
+      # Will define custom blank validation message for User model and
+      # custom blank validation message for login attribute of User model.
+      #models:
+
+    # Translate model names. Used in Model.human_name().
+    #models:
+      # For example,
+      #   user: "Dude"
+      # will translate User model name to "Dude"
+
+    # Translate model attribute names. Used in Model.human_attribute_name(attribute).
+    #attributes:
+      # For example,
+      #   user:
+      #     login: "Handle"
+      # will translate User attribute "login" as "Handle"

data/lib/datastax_rails/persistence.rb

@@ -9,8 +9,7 @@ module DatastaxRails
       alias_method :new_record?, :new_record
     end
 
-    # rubocop:disable Style/Documentation
-    module ClassMethods
+    module ClassMethods # rubocop:disable Style/Documentation
       # Removes one or more records with corresponding keys. Last parameter can be a hash
       # specifying the consistency level. The keys should be in the form returned by
       # +#id_for_update+

data/lib/datastax_rails/reflection.rb

@@ -17,6 +17,7 @@ module DatastaxRails
       self.reflections = {}
     end
 
+    # rubocop:disable Style/Documentation
     module ClassMethods
       def create_reflection(macro, name, options, datastax_rails)
         klass = options[:through] ? ThroughReflection : AssociationReflection
@@ -280,6 +281,10 @@ module DatastaxRails
         end
       end
 
+      def nested?
+        false
+      end
+
       private
 
       def derive_class_name
@@ -352,6 +357,11 @@ module DatastaxRails
         end
       end
 
+      # A through association is nested if there would be more than one join table
+      def nested?
+        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+      end
+
       # Consider the following example:
       #
       #   class Person

data/lib/datastax_rails/schema/solr.rb

@@ -65,7 +65,7 @@ module DatastaxRails
           say 'Using custom solrconfig file', :subitem
           solrconfig = Rails.root.join('config', 'solr', "#{model.column_family}-solrconfig.xml").read
         else
-          @legacy = model.legacy_mapping?
+          @solr_commit_time = model.solr_commit_time
           solrconfig = ERB.new(File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'solrconfig.xml.erb'))).result(binding)
         end
         if Rails.root.join('config', 'solr', "#{model.column_family}-stopwords.txt").exist?

data/lib/datastax_rails/version.rb

@@ -1,4 +1,4 @@
 # rubocop:disable Style/Documentation
 module DatastaxRails
-  VERSION = '2.0.16'
+  VERSION = '2.0.18'
 end

data/spec/datastax_rails/autosave_association_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe DatastaxRails::Base do
+  describe 'Autosave Associations' do
+    describe 'collections' do
+      it 'saves child records built via the association' do
+        p = Person.new(name: 'Jim')
+        c1 = p.cars.build(name: 'Jeep')
+        c2 = p.cars.build(name: 'Ford')
+        p.save
+        Person.commit_solr
+        expect(Car.find(c1.id).person).to eq(p)
+        expect(Car.find(c2.id).person).to eq(p)
+      end
+    end
+  end
+end

data/spec/datastax_rails/relation/batches_spec.rb

@@ -3,9 +3,8 @@ require 'spec_helper'
 describe DatastaxRails::Relation do
   before(:each) do
     @relation = DatastaxRails::Relation.new(Hobby, 'hobbies')
-    ('a'..'l').each_with_index do |letter, idx|
+    ('a'..'l').each_with_index do |letter, _idx|
       Hobby.create(name: letter)
-      sleep(1) if idx % 5 == 4 # Performance hack
     end
     Hobby.commit_solr
   end
@@ -13,7 +12,6 @@ describe DatastaxRails::Relation do
   %w(cassandra solr).each do |access_method|
     describe '#find_each' do
       it "returns each record one at a time with #{access_method}" do
-        sleep(1)
         missed_hobbies = ('a'..'l').to_a
         @relation.send('with_' + access_method).find_each(batch_size: 5) do |hobby|
           missed_hobbies.delete_if { |h| h == hobby.name }

data/spec/dummy/config/ca.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDKDCCApGgAwIBAgIJAIgWnQPYsbWtMA0GCSqGSIb3DQEBBQUAMGwxCzAJBgNV
+BAYTAlVTMREwDwYDVQQIEwhWaXJnaW5pYTEPMA0GA1UEBxMGUmVzdG9uMRswGQYD
+VQQKExJPcGVuIFNvdXJjZSBDZW50ZXIxDTALBgNVBAsTBFNBREUxDTALBgNVBAMT
+BFNBREUwHhcNMTAwODA2MTMzMzA1WhcNMjAwODAzMTMzMzA1WjBsMQswCQYDVQQG
+EwJVUzERMA8GA1UECBMIVmlyZ2luaWExDzANBgNVBAcTBlJlc3RvbjEbMBkGA1UE
+ChMST3BlbiBTb3VyY2UgQ2VudGVyMQ0wCwYDVQQLEwRTQURFMQ0wCwYDVQQDEwRT
+QURFMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDxn2DOHCUMsJoD4MoUEzpW
+1WFNag+ogebitEL1OwDeUuFuwZJAnOk3Gipw7ye27fU8qb+62BtHjg2EbnRa5NSG
+teS4HnCIt149FzgB06A2E+6s10oX9ehqT1FpALLFEyf/KaP82KPVeDq4ki68LIVJ
++YrvBbgNpH7a1czlXeVNNQIDAQABo4HRMIHOMB0GA1UdDgQWBBREhQm645qfcEw3
+uNXO6gaROCpSJzCBngYDVR0jBIGWMIGTgBREhQm645qfcEw3uNXO6gaROCpSJ6Fw
+pG4wbDELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZpcmdpbmlhMQ8wDQYDVQQHEwZS
+ZXN0b24xGzAZBgNVBAoTEk9wZW4gU291cmNlIENlbnRlcjENMAsGA1UECxMEU0FE
+RTENMAsGA1UEAxMEU0FERYIJAIgWnQPYsbWtMAwGA1UdEwQFMAMBAf8wDQYJKoZI
+hvcNAQEFBQADgYEA2ieesbXFL3jG3ebBmQLtHwjcWlQYcVGTq+wjxCBuBcZXEVFn
+Qi6XxbCvRSm0lLWYRHEc80WL3FezfREY43yiewnT24S8oKYlRb2v7Yc2sUjE72Ue
+nV7M6s4CPmqIYGkH+ukbxQVnAE0f1BNIoTsPx9XFr6Yx6kxZ4qSWc2IjuO4=
+-----END CERTIFICATE-----

data/spec/dummy/config/datastax.yml

@@ -12,8 +12,12 @@ productiont:
     path: /solr
 
 development:
-  servers: ["127.0.0.1"]
+  servers: ["sade-jasonk"]
   port: 9042
+  ssl:
+    #cert: config/datastax_rails.crt
+    #key: config/datastax_rails.key
+    #ca_cert: config/ca.crt
   keyspace: "datastax_rails_development"
   strategy_class: "org.apache.cassandra.locator.SimpleStrategy"
   strategy_options: {"replication_factor": "1"}
@@ -24,8 +28,12 @@ development:
     path: /solr
     
 test:
-  servers: ["127.0.0.1"]
+  servers: ["sade-jasonk"]
   port: 9042
+  ssl:
+    #cert: config/datastax_rails.crt
+    #key: config/datastax_rails.key
+    #ca_cert: config/ca.crt
   keyspace: "datastax_rails_test"
   strategy_class: "org.apache.cassandra.locator.SimpleStrategy"
   strategy_options: {"replication_factor": "1"}

data/spec/dummy/log/test.log

@@ -15607,3 +15607,4 @@ Reconnecting and retrying
 Error connecting to database
 the scheme http does not accept registry part: :8983 (or bad hostname?)
 Reconnecting and retrying
+Lost connection to Cassandra. Attempting to reconnect...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datastax_rails
 version: !ruby/object:Gem::Version
-  version: 2.0.16
+  version: 2.0.18
 platform: ruby
 authors:
 - Jason M. Kusar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -202,6 +202,7 @@ files:
 - lib/datastax_rails/attribute_methods/read.rb
 - lib/datastax_rails/attribute_methods/typecasting.rb
 - lib/datastax_rails/attribute_methods/write.rb
+- lib/datastax_rails/autosave_association.rb
 - lib/datastax_rails/base.rb
 - lib/datastax_rails/callbacks.rb
 - lib/datastax_rails/cassandra_only_model.rb
@@ -230,6 +231,7 @@ files:
 - lib/datastax_rails/errors.rb
 - lib/datastax_rails/grouped_collection.rb
 - lib/datastax_rails/inheritance.rb
+- lib/datastax_rails/locale/en.yml
 - lib/datastax_rails/payload_model.rb
 - lib/datastax_rails/persistence.rb
 - lib/datastax_rails/railtie.rb
@@ -272,6 +274,7 @@ files:
 - spec/datastax_rails/associations_spec.rb
 - spec/datastax_rails/attribute_methods/typecasting_spec.rb
 - spec/datastax_rails/attribute_methods_spec.rb
+- spec/datastax_rails/autosave_association_spec.rb
 - spec/datastax_rails/base_spec.rb
 - spec/datastax_rails/callbacks_spec.rb
 - spec/datastax_rails/column_spec.rb
@@ -309,6 +312,7 @@ files:
 - spec/dummy/config.ru
 - spec/dummy/config/application.rb
 - spec/dummy/config/boot.rb
+- spec/dummy/config/ca.crt
 - spec/dummy/config/database.yml
 - spec/dummy/config/datastax.yml
 - spec/dummy/config/datastax_rails.crt
@@ -393,6 +397,7 @@ test_files:
 - spec/datastax_rails/cql/update_spec.rb
 - spec/datastax_rails/cql/base_spec.rb
 - spec/datastax_rails/cql/select_spec.rb
+- spec/datastax_rails/autosave_association_spec.rb
 - spec/datastax_rails/persistence_spec.rb
 - spec/datastax_rails/relation/stats_methods_spec.rb
 - spec/datastax_rails/relation/spawn_methods_spec.rb
@@ -440,6 +445,7 @@ test_files:
 - spec/dummy/config/application.rb
 - spec/dummy/config/datastax.yml
 - spec/dummy/config/routes.rb
+- spec/dummy/config/ca.crt
 - spec/dummy/config/boot.rb
 - spec/dummy/config/datastax_rails.crt
 - spec/dummy/script/rails