datastax_rails 1.1.0.3 → 1.2.3

data/lib/datastax_rails/schema/cassandra.rb

@@ -0,0 +1,165 @@
+module DatastaxRails
+  module Schema
+    module Cassandra
+      # Check for missing columns or columns needing cassandra indexes
+      def check_missing_schema(model)
+        count = 0
+        model.attribute_definitions.each do |attribute, definition|
+          unless column_exists?(model.column_family.to_s, attribute.to_s)
+            count += 1
+            say "Adding column '#{attribute}'", :subitem
+            DatastaxRails::Cql::AlterColumnFamily.new(model.column_family).add(attribute => :text).execute
+          end
+          if(definition.indexed == :cassandra)
+            unless index_exists?(model.column_family.to_s, attribute.to_s)
+              if index_exists?(model.column_family.to_s, attribute.to_s)
+                count += 1
+                say "Dropping solr index on #{attribute.to_s}", :subitem
+                DatastaxRails::Cql::DropIndex.new(solr_index_cql_name(model.column_family.to_s, attribute.to_s)).execute
+              end
+              count += 1
+              say "Creating cassandra index on #{attribute.to_s}", :subitem
+              DatastaxRails::Cql::CreateIndex.new(cassandra_index_cql_name(model.column_family.to_s, attribute.to_s)).on(model.column_family.to_s).column(attribute.to_s).execute
+            end
+          elsif(definition.indexed == :both)
+            unless column_exists?(model.column_family.to_s, "__#{attribute.to_s}")
+              # Create and populate the new column
+              count += 1
+              say "Adding column '__#{attribute}'", :subitem
+              DatastaxRails::Cql::AlterColumnFamily.new(model.column_family).add("__#{attribute.to_s}" => model.attribute_definitions[attribute].coder.options[:cassandra_type]).execute
+              say "Populating column '__#{attribute}' (this might take a while)", :subitem
+              export = "echo \"copy #{model.column_family.to_s} (key, #{attribute.to_s}) TO 'dsr_export.csv';\" | cqlsh #{model.current_server}"
+              import = "echo \"copy #{model.column_family.to_s} (key, __#{attribute.to_s}) FROM 'dsr_export.csv';\" | cqlsh #{model.current_server}"
+              if system(export)
+                system(import)
+              else
+                @errors << "Looks like you don't have a working cqlsh command in your path.\nRun the following two commands from a server with cqlsh:\n\n#{export}\n#{import}"
+              end
+            end
+            count += 1
+            say "Creating cassandra index on __#{attribute.to_s}", :subitem
+            DatastaxRails::Cql::CreateIndex.new(cassandra_index_cql_name(model.column_family.to_s, "__#{attribute.to_s}")).on(model.column_family.to_s).column("__#{attribute.to_s}").execute
+          end
+        end
+        count
+      end
+      
+      # Creates a payload column family via CQL
+      def create_payload_column_family(model)
+        say "Creating Payload Column Family", :subitem
+        columns = {:chunk => :int, :payload => :text}
+        DatastaxRails::Cql::CreateColumnFamily.new(model.column_family).key_name(:digest).key_columns("digest, chunk").key_type(:text).columns(columns).with("COMPACT STORAGE").execute
+      end
+      
+      # Creates a wide-storage column family via CQL
+      def create_wide_storage_column_family(model)
+        say "Creating Wide-Storage Column Family", :subitem
+        key_name = model.key_factory.attributes.join
+        cluster_by = model.cluster_by.keys.first
+        cluster_dir = model.cluster_by.values.first
+        key_columns = "#{key_name}, #{cluster_by}"
+        columns = {}
+        model.attribute_definitions.each {|k,v| columns[k] = v.coder.options[:cassandra_type] unless k.to_s == key_name}
+        DatastaxRails::Cql::CreateColumnFamily.new(model.column_family).key_name(key_name).key_columns(key_columns).key_type(:text).columns(columns).
+          with("CLUSTERING ORDER BY (#{cluster_by} #{cluster_dir.to_s.upcase})").execute
+      end
+      
+      # Creates a regular cassandra-only column family via CQL
+      def create_cassandra_column_family(model)
+        say "Creating Cassandra-Only Column Family", :subitem
+        key_name = "key"
+        key_columns = "#{key_name}"
+        columns = {}
+        model.attribute_definitions.each {|k,v| columns[k] = v.coder.options[:cassandra_type]}
+        DatastaxRails::Cql::CreateColumnFamily.new(model.column_family).key_name(key_name).key_columns(key_columns).key_type(:text).columns(columns).execute
+      end
+      
+      # Creates the named keyspace
+      def create_keyspace(keyspace, options = {})
+        opts = { :name => keyspace.to_s,
+                 :strategy_class => 'org.apache.cassandra.locator.NetworkTopologyStrategy'}.with_indifferent_access.merge(options)
+
+        if(connection.keyspaces.collect(&:name).include?(keyspace.to_s))
+          say "Keyspace #{keyspace.to_s} already exists"
+          return false
+        else
+          cql = DatastaxRails::Cql::CreateKeyspace.new(opts.delete(:name))
+          cql.strategy_class(opts.delete(:strategy_class))
+          strategy_options = opts.delete('strategy_options')
+          cql.strategy_options(strategy_options.symbolize_keys)
+          say "Creating keyspace #{keyspace.to_s}"
+          cql.execute
+          return true
+        end
+      end
+      
+      def drop_keyspace
+        say "Dropping keyspace #{@keyspace.to_s}"
+        DatastaxRails::Cql::DropKeyspace.new(@keyspace.to_s).execute
+      end
+      
+      # Checks the Cassandra system tables to see if the key column is named properly.  This is
+      # a migration method to handle the fact that Solr used to create column families with "KEY"
+      # instead of the now default "key".
+      def check_key_name(cf)
+        count = 0
+        if(cf.respond_to?(:column_family))
+          cf = cf.column_family
+        end
+        klass = OpenStruct.new(:column_family => 'system.schema_columnfamilies', :default_consistency => 'QUORUM')
+        cql = DatastaxRails::Cql::ColumnFamily.new(klass)
+        results = CassandraCQL::Result.new(cql.select("key_alias, key_aliases").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute)
+        result = results.fetch
+        if(result && (result['key_alias'] == 'KEY' || result['key_aliases'].include?('KEY')) && (result['key_aliases'].blank? || !result['key_aliases'].include?('key')))
+          count += 1
+          say "Renaming KEY column", :subitem
+          DatastaxRails::Cql::AlterColumnFamily.new(cf).rename("KEY",'key').execute
+        end
+        count
+      end
+      
+      # Computes the expected solr index name as reported by CQL.
+      def solr_index_cql_name(cf, column)
+        "#{@keyspace}_#{cf.to_s}_#{column.to_s}_index"
+      end
+      
+      # Computes the expected cassandra index name as reported by CQL.
+      def cassandra_index_cql_name(cf, column)
+        "#{cf.to_s}_#{column.to_s}_idx"
+      end
+      
+      # Checks the Cassandra system tables to see if a column family exists
+      def column_family_exists?(cf)
+        klass = OpenStruct.new(:column_family => 'system.schema_columnfamilies', :default_consistency => 'QUORUM')
+        cql = DatastaxRails::Cql::ColumnFamily.new(klass)
+        results = CassandraCQL::Result.new(cql.select("count(*)").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute)
+        results.fetch['count'] > 0
+      end
+      
+      # Checks the Cassandra system tables to see if a column exists on a column family
+      def column_exists?(cf, col)
+        klass = OpenStruct.new(:column_family => 'system.schema_columns', :default_consistency => 'QUORUM')
+        cql = DatastaxRails::Cql::ColumnFamily.new(klass)
+        results = CassandraCQL::Result.new(cql.select("count(*)").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf, 'column_name' => col).execute)
+        exists = results.fetch['count'] > 0
+        unless exists
+          # We need to check if it's part of the primary key (ugh)
+          klass = OpenStruct.new(:column_family => 'system.schema_columnfamilies', :default_consistency => 'QUORUM')
+          cql = DatastaxRails::Cql::ColumnFamily.new(klass)
+          results = CassandraCQL::Result.new(cql.select("column_aliases, key_aliases").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute)
+          row = results.fetch
+          exists = row['key_aliases'].include?(col.to_s) || row['column_aliases'].include?(col.to_s)
+        end
+        exists
+      end
+      
+      # Checks the Cassandra system tables to see if an index exists on a column family
+      def index_exists?(cf, col)
+        klass = OpenStruct.new(:column_family => 'system.schema_columns', :default_consistency => 'QUORUM')
+        cql = DatastaxRails::Cql::ColumnFamily.new(klass)
+        results = CassandraCQL::Result.new(cql.select("index_name").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf, 'column_name' => col).execute)
+        results.fetch['index_name'] != nil
+      end
+    end
+  end
+end

data/lib/datastax_rails/schema/migrator.rb

@@ -1,212 +1,104 @@
 module DatastaxRails
   module Schema
-
     class Migrator
-
-      def self.migrate(migrations_path, target_version = nil)
-        case
-        when target_version.nil?
-          up(migrations_path, target_version)
-        when current_version == 0 && target_version == 0
-        when current_version > target_version
-          down(migrations_path, target_version)
-        else
-          up(migrations_path, target_version)
+      include DatastaxRails::Schema::Solr
+      include DatastaxRails::Schema::Cassandra
+      
+      cattr_accessor :verbose
+      self.verbose = true
+      attr_accessor :errors
+      
+      def initialize(keyspace)
+        @keyspace = keyspace
+        check_schema_migrations unless keyspace == 'system'
+        @errors = []
+      end
+
+      def migrate_all(force = false)
+        say_with_time("Migrating all models") do
+          # Ensure all models are loaded (necessary for non-production mode)
+          Dir[Rails.root.join("app","models",'*.rb').to_s].each do |file|
+            require File.basename(file, File.extname(file))
+          end
+          count = 0
+          DatastaxRails::Base.models.each do |m|
+            if !m.abstract_class?
+              count += migrate_one(m, force)
+            end
+          end
+          count
         end
       end
-
-      def self.rollback(migrations_path, steps = 1)
-        move(:down, migrations_path, steps)
-      end
-
-      def self.forward(migrations_path, steps = 1)
-        move(:up, migrations_path, steps)
-      end
-
-      def self.up(migrations_path, target_version = nil)
-        new(:up, migrations_path, target_version).migrate
-      end
-
-      def self.down(migrations_path, target_version = nil)
-        new(:down, migrations_path, target_version).migrate
-      end
-
-      def self.run(direction, migrations_path, target_version)
-        new(direction, migrations_path, target_version).run
-      end
-
-      def self.migrations_path
-        'ks/migrate'
-      end
-
-      def self.schema_migrations_column_family
-        :schema_migrations
-      end
-
-      def self.column_family_tasks
-        cas = DatastaxRails::Base.connection
-        Tasks::ColumnFamily.new(cas.keyspace)
-      end
-
-      def self.get_all_versions
-        cas = DatastaxRails::Base.connection
-        cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
-      end
-
-      def self.current_version
-        sm_cf = schema_migrations_column_family
-        if column_family_tasks.exists?(sm_cf)
-          get_all_versions.max || 0
-        else
-          0
+      
+      def migrate_one(model, force = false)
+        count = 0
+        say_with_time("Migrating #{model.name} to latest version") do
+          if model.payload_model?
+            unless column_family_exists?(model.column_family.to_s)
+              create_payload_column_family(model)
+              count += 1
+            end
+          elsif model.wide_storage_model?
+            unless column_family_exists?(model.column_family.to_s)
+              create_wide_storage_column_family(model)
+              count += 1
+            end
+            count += check_missing_schema(model)
+          elsif model <= DatastaxRails::CassandraOnlyModel
+            unless column_family_exists?(model.column_family.to_s)
+              create_cassandra_column_family(model)
+              count += 1
+            end
+            count += check_key_name(model)
+            count += check_missing_schema(model)
+          else
+            count += check_key_name(model)
+            count += upload_solr_configuration(model, force)
+            count += check_missing_schema(model)
+          end
         end
+        count
       end
 
-      private
-
-      def self.move(direction, migrations_path, steps)
-        migrator = self.new(direction, migrations_path)
-        start_index = migrator.migrations.index(migrator.current_migration)
-
-        if start_index
-          finish = migrator.migrations[start_index + steps]
-          version = finish ? finish.version : 0
-          send(direction, migrations_path, version)
-        end
+      def connection
+        DatastaxRails::Base.connection
       end
 
-      public
-
-      def initialize(direction, migrations_path, target_version = nil)
-        sm_cf = self.class.schema_migrations_column_family
-
-        unless column_family_tasks.exists?(sm_cf)
-          column_family_tasks.create(sm_cf) do |cf|
-            cf.comparator_type = 'LongType'
+      private
+      
+        # Checks to ensure that the schema_migrations column family exists and creates it if not
+        def check_schema_migrations
+          unless column_family_exists?('schema_migrations')
+            say "Creating schema_migrations column family"
+            connection.execute_cql_query(DatastaxRails::Cql::CreateColumnFamily.new('schema_migrations').key_type(:text).columns(:digest => :text, :solrconfig => :text, :stopwords => :text).to_cql)
           end
+          
+          check_key_name('schema_migrations')
         end
-
-        @direction, @migrations_path, @target_version = direction, migrations_path, target_version
-      end
-
-      def current_version
-        migrated.last || 0
-      end
-
-      def current_migration
-        migrations.detect { |m| m.version == current_version }
-      end
-
-      def run
-        target = migrations.detect { |m| m.version == @target_version }
-        raise UnknownMigrationVersionError.new(@target_version) if target.nil?
-        unless (up? && migrated.include?(target.version.to_i)) || (down? && !migrated.include?(target.version.to_i))
-          target.migrate(@direction)
-          record_version_state_after_migrating(target)
+        
+        def write(text="")
+          puts(text) if verbose
         end
-      end
-
-      def migrate
-        current = migrations.detect { |m| m.version == current_version }
-        target = migrations.detect { |m| m.version == @target_version }
-
-        if target.nil? && !@target_version.nil? && @target_version > 0
-          raise UnknownMigrationVersionError.new(@target_version)
+  
+        def say(message, subitem=false)
+          write "#{subitem ? "   ->" : "--"} #{message}"
         end
-
-        start = up? ? 0 : (migrations.index(current) || 0)
-        finish = migrations.index(target) || migrations.size - 1
-        runnable = migrations[start..finish]
-
-        # skip the last migration if we're headed down, but not ALL the way down
-        runnable.pop if down? && !target.nil?
-
-        runnable.each do |migration|
-          #puts "Migrating to #{migration.name} (#{migration.version})"
-
-          # On our way up, we skip migrating the ones we've already migrated
-          next if up? && migrated.include?(migration.version.to_i)
-
-          # On our way down, we skip reverting the ones we've never migrated
-          if down? && !migrated.include?(migration.version.to_i)
-            migration.announce 'never migrated, skipping'; migration.write
-            next
-          end
-
-          migration.migrate(@direction)
-          record_version_state_after_migrating(migration)
+  
+        def say_with_time(message)
+          say(message)
+          result = nil
+          time = Benchmark.measure { result = yield }
+          say "%.4fs" % time.real, :subitem
+          say("#{result} changes", :subitem) if result.is_a?(Integer)
+          result
         end
-      end
-
-      def migrations
-        @migrations ||= begin
-                          files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
-
-                          migrations = files.inject([]) do |klasses, file|
-                            version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
-
-                            raise IllegalMigrationNameError.new(file) unless version
-                            version = version.to_i
-
-                            if klasses.detect { |m| m.version == version }
-                              raise DuplicateMigrationVersionError.new(version)
-                            end
-
-                            if klasses.detect { |m| m.name == name.camelize }
-                              raise DuplicateMigrationNameError.new(name.camelize)
-                            end
-
-                            migration = MigrationProxy.new
-                            migration.name     = name.camelize
-                            migration.version  = version
-                            migration.filename = file
-                            klasses << migration
-                          end
-
-                          migrations = migrations.sort_by { |m| m.version }
-                          down? ? migrations.reverse : migrations
-                        end
-      end
-
-      def pending_migrations
-        already_migrated = migrated
-        migrations.reject { |m| already_migrated.include?(m.version.to_i) }
-      end
-
-      def migrated
-        @migrated_versions ||= self.class.get_all_versions
-      end
-
-      private
-
-      def column_family_tasks
-        Tasks::ColumnFamily.new(connection.keyspace)
-      end
-
-      def connection
-        DatastaxRails::Base.connection
-      end
-
-      def record_version_state_after_migrating(migration)
-        sm_cf = self.class.schema_migrations_column_family
-
-        @migrated_versions ||= []
-        if down?
-          @migrated_versions.delete(migration.version)
-          connection.remove sm_cf, 'all', migration.version
-        else
-          @migrated_versions.push(migration.version).sort!
-          connection.insert sm_cf, 'all', { migration.version => migration.name }
+  
+        def suppress_messages
+          save, self.verbose = verbose, false
+          yield
+        ensure
+          self.verbose = save
         end
-      end
-
-      def up?
-        @direction == :up
-      end
-
-      def down?
-        @direction == :down
-      end
     end
   end
 end

data/lib/datastax_rails/schema/solr.rb

@@ -0,0 +1,158 @@
+module DatastaxRails
+  module Schema
+    module Solr
+      # Generates a SOLR schema file.  The default schema template included with DSR can handle
+      # most normal circumstances for indexing.  When a customized template is required, it can
+      # be placed in the application's config/solr directory using the naming convention
+      # column_family-schema.xml.erb.  It will be processed as a normal ERB file.  See the DSR version
+      # for examples.  
+      def generate_solr_schema(model)
+        @fields = []
+        @copy_fields = []
+        @fulltext_fields = []
+        @custom_fields = ""
+        model.attribute_definitions.values.each do |attr|
+          coder = attr.coder
+          if coder.options[:solr_type]
+            @fields.push({ :name => attr.name,
+                           :type => coder.options[:solr_type].to_s,
+                           :indexed => (coder.options[:indexed] == :solr || coder.options[:indexed] == :both).to_s,
+                           :stored => coder.options[:stored].to_s,
+                           :multi_valued => coder.options[:multi_valued].to_s })
+          end
+          if coder.options[:sortable] && coder.options[:tokenized]
+            @fields.push({ :name => "sort_" + attr.name,
+                           :type => "string",
+                           :indexed => true,
+                           :stored => false,
+                           :multi_valued => false })
+            @copy_fields.push({ :source => attr.name, :dest => "sort_" + attr.name }) if (coder.options[:indexed] || coder.options[:stored])
+          end
+          if coder.options[:fulltext]
+            @fulltext_fields << attr.name if (coder.options[:indexed] || coder.options[:stored])
+          end
+        end
+        # Sort the fields so that no matter what order the attributes are arranged into the
+        # same schema file gets generated
+        @fields.sort! {|a,b| a[:name] <=> b[:name]}
+        @copy_fields.sort! {|a,b| a[:source] <=> b[:source]}
+        @fulltext_fields.sort!
+        
+        if Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").exist?
+          say "Using custom schema for #{model.name}", :subitem
+          ERB.new(Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").read).result(binding)
+        else
+          ERB.new(File.read(File.join(File.dirname(__FILE__),"..","..","..","config","schema.xml.erb"))).result(binding)
+        end
+      end
+      
+      # Sends a command to Solr instructing it to reindex the data.  The data is reindexed in the background,
+      # and the new index is swapped in once it is finished.
+      def reindex_solr(model)
+        url = "#{DatastaxRails::Base.solr_base_url}/admin/cores?action=RELOAD&name=#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}&reindex=true&deleteAll=false"
+        say "Posting reindex command to '#{url}'", :subitem
+        `curl -s -X POST '#{url}'`
+        say "Reindexing will run in the background", :subitem
+      end
+      
+      # Creates the initial Solr Core.  This is required once the first time a Solr schema is uploaded.
+      # It will cause the data to be indexed in the background.
+      def create_solr_core(model)
+        url = "#{DatastaxRails::Base.solr_base_url}/admin/cores?action=CREATE&name=#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}"
+        say "Posting create command to '#{url}'", :subitem
+        `curl -s -X POST '#{url}'`
+      end
+      
+      # Uploads the necessary configuration files for solr to function
+      # The solrconfig and stopwords files can be overridden on a per-model basis
+      # by creating a file called config/solr/column_family-solrconfig.xml or
+      # config/solr/column_family-stopwords.txt
+      #
+      # TODO: find a way to upload arbitrary files automatically (e.g., additional stopwords lists)
+      def upload_solr_configuration(model, force=false)
+        count = 0
+        if Rails.root.join('config','solr',"#{model.column_family}-solrconfig.xml").exist?
+          say "Using custom solrconfig file", :subitem
+          solrconfig = Rails.root.join('config','solr',"#{model.column_family}-solrconfig.xml").read
+        else
+          @legacy = model.legacy_mapping?
+          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?
+          say "Using custom stopwords file", :subitem
+          stopwords = Rails.root.join('config','solr',"#{model.column_family}-stopwords.txt").read
+        else
+          stopwords = File.read(File.join(File.dirname(__FILE__),"..","..","..","config","stopwords.txt"))
+        end
+        schema = generate_solr_schema(model)
+        solrconfig_digest = Digest::SHA1.hexdigest(solrconfig)
+        stopwords_digest = Digest::SHA1.hexdigest(stopwords)
+        schema_digest = Digest::SHA1.hexdigest(schema)
+        
+        newcf = !column_family_exists?(model.column_family.to_s)
+        force ||= newcf
+        
+        results = DatastaxRails::Cql::Select.new(SchemaMigration, ['*']).conditions(:key => model.column_family).execute
+        sm_digests = CassandraCQL::Result.new(results).fetch.try(:to_hash) || {}
+        
+        solr_url = "#{DatastaxRails::Base.solr_base_url}/resource/#{@keyspace}.#{model.column_family}"
+        
+        uri = URI.parse(solr_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.cert = OpenSSL::X509::Certificate.new(Rails.root.join("config","datastax_rails.crt").read)
+          http.key = OpenSSL::PKey::RSA.new(Rails.root.join("config","datastax_rails.key").read)
+          http.ca_path = Rails.root.join("config","sade_ca.crt").to_s
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        http.read_timeout = 300
+        
+        if force || solrconfig_digest != sm_digests['solrconfig']
+          count += 1
+          loop do 
+            say "Posting Solr Config file to '#{solr_url}/solrconfig.xml'", :subitem
+            http.post(uri.path+"/solrconfig.xml", solrconfig)
+            if Rails.env.production?
+              sleep(5)
+              resp = http.get(uri.path+"/solrconfig.xml")
+              continue unless resp.message == 'OK'                  
+            end
+            break
+          end
+          DatastaxRails::Cql::Update.new(SchemaMigration, model.column_family).columns(:solrconfig => solrconfig_digest).execute
+        end
+        if force || stopwords_digest != sm_digests['stopwords']
+          count += 1
+          loop do
+            say "Posting Solr Stopwords file to '#{solr_url}/stopwords.txt'", :subitem
+            http.post(uri.path+"/stopwords.txt", stopwords)
+            if Rails.env.production?
+              sleep(5)
+              resp = http.get(uri.path+"/stopwords.txt")
+              continue unless resp.message == 'OK'
+            end
+            break
+          end
+          DatastaxRails::Cql::Update.new(SchemaMigration, model.column_family).columns(:stopwords => stopwords_digest).execute
+        end
+        if force || schema_digest != sm_digests['digest']
+          count += 1
+          loop do
+            say "Posting Solr Schema file to '#{solr_url}/schema.xml'", :subitem
+            http.post(uri.path+"/schema.xml", schema)
+            if Rails.env.production?
+              sleep(5)
+              resp = http.get(uri.path+"/schema.xml")
+              continue unless resp.message == 'OK'
+            end
+            break
+          end
+          DatastaxRails::Cql::Update.new(SchemaMigration, model.column_family).columns(:digest => schema_digest).execute
+          newcf ? create_solr_core(model) : reindex_solr(model)
+        end
+        count
+      end
+    end
+  end
+end

data/lib/datastax_rails/schema.rb

@@ -2,36 +2,8 @@ module DatastaxRails
   module Schema
     extend ActiveSupport::Autoload
 
-    class IrreversibleMigration < StandardError
-    end
-
-    class DuplicateMigrationVersionError < StandardError#:nodoc:
-      def initialize(version)
-        super("Multiple migrations have the version number #{version}")
-      end
-    end
-
-    class DuplicateMigrationNameError < StandardError#:nodoc:
-      def initialize(name)
-        super("Multiple migrations have the name #{name}")
-      end
-    end
-
-    class UnknownMigrationVersionError < StandardError #:nodoc:
-      def initialize(version)
-        super("No migration with version number #{version}")
-      end
-    end
-
-    class IllegalMigrationNameError < StandardError#:nodoc:
-      def initialize(name)
-        super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed)")
-      end
-    end
-
+    autoload :Solr
+    autoload :Cassandra
     autoload :Migrator
-    autoload :Migration
-    autoload :MigrationProxy
-
   end
 end