datastax_rails 1.0.11 → 1.0.12

data/README.rdoc

@@ -36,10 +36,12 @@ Configure the config/datastax.yml file:
     connection_options:
       timeout: 2
     solr:
-      url: http://localhost:8983/solr
+  	  port: 8983
+  	  path: /solr
 
 The above is configured to use NetworkTopologyStrategy.  If you go with this, you'll need to configure Datastax to use the
 NetworkTopologySnitch and set up the cassandra-topology.properties file.  See the Datastax documentation for more information.
+
 For a more simple, single datacenter setup, something like this should probably work:
 
   development:
@@ -50,7 +52,10 @@ For a more simple, single datacenter setup, something like this should probably
     connection_options:
       timeout: 2 
     solr:
-      url: http://localhost:8983/solr
+  	  port: 8983
+  	  path: /solr
+
+See DatastaxRails::Connection::ClassMethods for a description of what options are available.
 
 Create your keyspace:
 

data/lib/blankslate.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+######################################################################
+# BlankSlate provides an abstract base class with no predefined
+# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+# BlankSlate is useful as a base class when writing classes that
+# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+class BlankSlate
+  class << self
+    
+    # Hide the method named +name+ in the BlankSlate class. Don't
+    # hide +instance_eval+ or any method beginning with "__".
+    def hide(name)
+      methods = instance_methods.map(&:to_sym)
+      if methods.include?(name.to_sym) and
+        name !~ /^(__|instance_eval)/
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+
+    def find_hidden_method(name)
+      @hidden_methods ||= {}
+      @hidden_methods[name] || superclass.find_hidden_method(name)
+    end
+
+    # Redefine a previously hidden method so that it may be called on a blank
+    # slate object.
+    def reveal(name)
+      hidden_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless hidden_method
+      define_method(name, hidden_method)
+    end
+  end
+  
+  instance_methods.each { |m| hide(m) }
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods. We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Kernel
+      BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Object
+      BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate. In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+class Module
+  alias blankslate_original_append_features append_features
+  def append_features(mod)
+    result = blankslate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      BlankSlate.hide(name)
+    end
+    result
+  end
+end

data/lib/datastax_rails/base.rb

@@ -445,20 +445,26 @@ module DatastaxRails #:nodoc:
     class << self
       delegate :find, :first, :all, :exists?, :any?, :many?, :to => :scoped
       delegate :destroy, :destroy_all, :delete, :update, :update_all, :to => :scoped
-      # delegate :find_each, :find_in_batches, :to => :scoped
       delegate :order, :limit, :where, :where_not, :page, :paginate, :select, :to => :scoped
       delegate :per_page, :each, :group, :total_pages, :search, :fulltext, :to => :scoped
       delegate :count, :first, :first!, :last, :last!, :to => :scoped
       delegate :cql, :with_cassandra, :with_solr, :commit_solr, :to => :scoped
 
+      # Sets the column family name
+      #
+      # @param [String] column_family the name of the column family in cassandra
       def column_family=(column_family)
         @column_family = column_family
       end
 
+      # Returns the column family name.  If it has been set manually, the set name is returned.
+      # Otherwise returns the pluralized version of the class name.
+      #
+      # Returns [String] the name of the column family
       def column_family
         @column_family || name.pluralize
       end
-
+      
       def base_class
         klass = self
         while klass.superclass != Base

data/lib/datastax_rails/connection.rb

@@ -1,9 +1,13 @@
+# require 'datastax_rails/rsolr_client_wrapper'
 module DatastaxRails
+  # The connection module holds all the code for establishing and maintaining a connection to
+  # Datastax Exterprise.  This includes both the Cassandra and Solr connections.
   module Connection
     extend ActiveSupport::Concern
     
     included do
       class_attribute :connection
+      class_attribute :solr
     end
 
     module ClassMethods
@@ -11,12 +15,86 @@ module DatastaxRails
         :servers => "127.0.0.1:9160",
         :thrift => {}
       }
+      
+      # Returns the current server that we are talking to.  This is useful when you are talking to a
+      # cluster, and we want to know which server specifically we are connected to.
+      #
+      # Used by Relation to calculate the SOLR URL so that it follows the Cassandra connection.
+      def current_server
+        thrift_client.instance_variable_get(:@current_server).to_s.split(/\:/).first
+      end
+      
+      # Returns the thrift client object
+      def thrift_client
+        self.connection.instance_variable_get(:@connection)
+      end
+      
+      # Establish a Cassandra connection to DSE.  datastax.yml will be read and the current environment's
+      # settings passed to this method.
+      #
+      # The following is an example production configuration document.  Assume that your setup consists
+      # of three datacenters each with three servers and RF=3 (i.e., you're storing your data 9 times)
+      #
+      #   servers: ["10.1.2.5:9160", "10.1.2.6:9160", "10.1.2.7:9160"]
+      #   keyspace: "datastax_rails_production"
+      #   strategy_class: "org.apache.cassandra.locator.NetworkTopologyStrategy"
+      #   strategy_options: {"DS1": "3", "DS2": "3", "DS3": "3"} 
+      #   connection_options:
+      #     timeout: 10
+      #     retries: 2
+      #     server_max_requests: 1000
+      #   solr:
+      #     port: 8983
+      #     path: /solr
+      #
+      # The +servers+ entry should be a list of all of the servers in your local datacenter.  These
+      # are the servers that DSR will attempt to connect to and will round-robin through.
+      #
+      # 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
+      # information.
+      #
+      # strategy_options lets us specify what our topology looks like.  In this case, we have RF=3 in all
+      # three of our datacenters (DS1, DS2, and DS3).
+      #
+      # connection_options are the options that are passed to the thrift layer for the connection to
+      # cassandra.
+      # * *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.
+      # * *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)
         connection_options = spec[:connection_options] || {}
         self.connection = CassandraCQL::Database.new(spec[:servers], {:keyspace => spec[:keyspace]}, connection_options.symbolize_keys)
       end
+      
+      # Similar to +establish_connection+, this method creates a connection object for Solr.  Since HTTP is stateless, this doesn't
+      # actually launch the connection, but it gets everything set up so that RSolr can do its work.  It's important to note that
+      # unlike the cassandra connection which is global to all of DSR, each model will have its own solr_connection.
+      def solr_connection
+        DatastaxRails::Base.establish_connection unless self.connection 
+        port = DatastaxRails::Base.config[:solr][:port]
+        path = DatastaxRails::Base.config[:solr][:path]
+        @rsolr ||= DatastaxRails::RSolrClientWrapper.new(RSolr.connect :url => "http://#{self.current_server}:#{port}#{path}/#{DatastaxRails::Base.connection.keyspace}.#{self.column_family}")
+      end
     end
   end
 end

data/lib/datastax_rails/railtie.rb

@@ -13,8 +13,8 @@ module DatastaxRails
       load 'datastax_rails/tasks/ds.rake'
     end
     
-    generators do
-      require 'datastax_rails/generators/migration_generator'
-    end
+    # generators do
+      # require 'datastax_rails/generators/migration_generator'
+    # end
   end
 end

data/lib/datastax_rails/relation.rb

@@ -406,8 +406,9 @@ module DatastaxRails
         end
       end
       
-      def rsolr #:nodoc:
-        @rsolr ||= RSolr.connect :url => "#{DatastaxRails::Base.config[:solr][:url]}/#{DatastaxRails::Base.connection.keyspace}.#{@klass.column_family}"
+      # Calculates the solr URL and sets up an RSolr connection
+      def rsolr
+        @klass.solr_connection
       end
   end
 end

data/lib/datastax_rails/rsolr_client_wrapper.rb

@@ -0,0 +1,27 @@
+module DatastaxRails
+  # Wraps the RSolr Client class so that exceptions such as Connection Refused can be caught and
+  # a new server tried (if one is available)
+  class RSolrClientWrapper < BlankSlate
+    def initialize(rsolr)
+      @rsolr = rsolr
+    end
+    
+    def method_missing(sym, *args, &block)
+      if @rsolr.uri.host != DatastaxRails::Base.current_server
+        @rsolr.uri.host = DatastaxRails::Base.current_server
+        @rsolr = RSolr.connect(:url => @rsolr.uri.to_s)
+      end
+      @rsolr.__send__(sym, *args, &block)
+    rescue Errno::ECONNREFUSED
+      tries ||= DatastaxRails::Base.thrift_client.options[:retries] + 1
+      tries -= 1
+      if tries > 0
+        # Force cassandra connection to roll
+        DatastaxRails::Cql::Select.new(SchemaMigration, ['id']).limit(1).execute
+        retry
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/datastax_rails/tasks/column_family.rb

@@ -2,12 +2,6 @@ require 'digest/sha1'
 
 module DatastaxRails
   module Tasks
-    class SchemaMigration
-      def self.column_family
-        'schema_migrations'
-      end
-    end
-    
     class ColumnFamily
       COMPARATOR_TYPES = [:blob, :ascii, :text, :varint, :bigint, :uuid, :timestamp, :boolean, :float, :doublt, :decimal]
 

data/lib/datastax_rails/version.rb

@@ -1,4 +1,4 @@
 module DatastaxRails
   # The current version of the gem
-  VERSION = "1.0.11"
+  VERSION = "1.0.12"
 end

data/lib/datastax_rails.rb

@@ -1,5 +1,7 @@
 require 'active_support/all'
 require 'cassandra-cql/1.0'
+require 'blankslate'
+require 'schema_migration'
 
 # Welcome to DatastaxRails.  DatastaxRails::Base is probably a good place to start.
 module DatastaxRails
@@ -27,6 +29,7 @@ module DatastaxRails
     autoload :SpawnMethods
   end
   
+  autoload :RSolrClientWrapper, 'datastax_rails/rsolr_client_wrapper'
   autoload :Schema
   autoload :Scoping
   autoload :Serialization

data/lib/schema_migration.rb

@@ -0,0 +1,8 @@
+# Placeholder class to imitate a model for the schema migrations column family.
+# Used as part of the CQL generation.
+class SchemaMigration
+  # Returns the name of the column family
+  def self.column_family
+    'schema_migrations'
+  end
+end

data/spec/datastax_rails/cql/update_spec.rb

@@ -8,7 +8,7 @@ describe DatastaxRails::Cql::Update do
   it "should generate valid CQL" do
     cql = DatastaxRails::Cql::Update.new(@model_class, "12345")
     cql.using(DatastaxRails::Cql::Consistency::QUORUM).columns(:name => 'John', :age => '23')
-    cql.to_cql.should == "update users using consistency QUORUM SET age = '23', name = 'John' WHERE KEY IN ('12345')"
+    cql.to_cql.should == "update users using consistency QUORUM SET name = 'John', age = '23' WHERE KEY IN ('12345')"
   end
   
   it_has_behavior "default_consistency"

data/spec/dummy/config/datastax.yml

@@ -3,16 +3,20 @@ development:
   keyspace: "datastax_rails_development"
   strategy_class: "org.apache.cassandra.locator.SimpleStrategy"
   strategy_options: {"DC1": "1"} 
-  replication_factor: 1
+  connection_options:
+    timeout: 10
   solr:
-    url: http://localhost:8983/solr
+    port: 8983
+    path: /solr
     
 test:
   servers: ["localhost:9160"]
   keyspace: "datastax_rails_test"
   strategy_class: "org.apache.cassandra.locator.SimpleStrategy"
   strategy_options: {"DC1": "1"} 
-  replication_factor: 1
+  connection_options:
+    timeout: 10
   solr:
-    url: http://localhost:8983/solr
+    port: 8983
+    path: /solr