cassandra_migrations 0.0.1.pre3 → 0.0.1.pre4

data/lib/cassandra_migrations/cassandra/keyspace_operations.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module CassandraMigrations
+  module Cassandra
+    module KeyspaceOperations
+  
+      def create_keyspace!
+        begin
+          execute(
+            "CREATE KEYSPACE #{Config.keyspace} \
+             WITH replication = { \ 
+               'class':'#{Config.replication['class']}', \
+               'replication_factor': #{Config.replication['replication_factor']} \
+             }"
+          )
+          use(Config.keyspace)
+        rescue Exception => exception
+          drop_keyspace!
+          raise exception
+        end
+      end
+      
+      def drop_keyspace!
+        begin
+          execute("DROP KEYSPACE #{Config.keyspace}")
+        rescue Cql::QueryError
+          raise Errors::UnexistingKeyspaceError, keyspace
+        end
+      end
+    
+    end
+  end
+end

data/lib/cassandra_migrations/cassandra/queries.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module CassandraMigrations
+  module Cassandra
+    module Queries
+  
+      def write!(table, hash)
+        columns = []
+        values = []
+        
+        hash.each do |k,v| 
+          columns << k.to_s
+          values << (v.is_a?(String) ? "'#{v.to_s}'" : v.to_s)
+        end
+    
+        execute("INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{values.join(', ')})")
+      end
+      
+      def select(table, options={})
+        query_string = "SELECT #{options[:projection] || '*'} FROM #{table}"
+        
+        if options[:selection]
+          query_string << " WHERE #{options[:selection]}"
+        end
+        
+        if options[:order_by]
+          query_string << " ORDER BY #{options[:order_by]}"
+        end
+        
+        if options[:limit]
+          query_string << " LIMIT #{options[:limit]}"
+        end
+    
+        execute(query_string)
+      end
+      
+      def delete!(table, selection, options={})
+        execute("DELETE #{options[:projection]} FROM #{table} WHERE #{selection}")
+      end
+      
+      def truncate!(table)
+        execute("TRUNCATE #{table}")
+      end
+      
+    end
+  end
+end

data/lib/cassandra_migrations/cassandra.rb

@@ -2,102 +2,63 @@
 
 require 'yaml'
 require 'cql'
-require 'cassandra_migrations/cassandra/query'
-require 'cassandra_migrations/cassandra/errors'
-require 'cassandra_migrations/cassandra/migrator'
+require 'cassandra_migrations/cassandra/queries'
+require 'cassandra_migrations/cassandra/keyspace_operations'
 
-module CassandraMigrations::Cassandra
-  extend Query
-  
-  mattr_accessor :client
-  mattr_accessor :config 
+
+module CassandraMigrations
+  module Cassandra
+    extend Queries
+    extend KeyspaceOperations
   
-  def self.start!
-    connect_to_server unless client
+    mattr_accessor :client
     
-    # setup keyspace use
-    begin
-      use(config['keyspace'])
-    rescue Cql::QueryError # keyspace does not exist
-      raise Errors::UnexistingKeyspaceError, config['keyspace']
+    def self.start!
+      # setup keyspace use
+      use(Config.keyspace)
     end
-  end
-  
-  def self.restart!
-    self.client = nil
-    self.config = nil
-    start!
-  end
-  
-  def self.shutdown!
-    if client
-      client.close
+    
+    def self.restart!
+      raise Errors::ClientNotStartedError unless client
+
+      client.close if client && client.connected?
       self.client = nil
+      start!
     end
-      
-    self.config = nil
-  end
-  
-  def self.create_keyspace!
-    connect_to_server unless client
     
-    begin
-      execute(
-        "CREATE KEYSPACE #{config['keyspace']} \
-         WITH replication = { \ 
-           'class':'#{config['replication']['class']}', \
-           'replication_factor': #{config['replication']['replication_factor']} \
-         }"
-      )
-      use(config['keyspace'])
-      execute("CREATE TABLE metadata (data_name varchar PRIMARY KEY, data_value varchar)") 
-      write("metadata", {:data_name => 'version', :data_value => '0'})
-    rescue Exception => exception
-      drop!
-      raise exception
+    def self.shutdown!
+      raise Errors::ClientNotStartedError unless client
+
+      client.close if client.connected?
+      self.client = nil
     end
-  end
-  
-  def self.drop!
-    connect_to_server unless client
     
-    begin
-      execute("DROP KEYSPACE #{config['keyspace']}")
-    rescue Cql::QueryError
-      raise Errors::UnexistingKeyspaceError, config['keyspace']
+    def self.use(keyspace)
+      connect_to_server unless client
+
+      begin
+        client.use(keyspace)
+      rescue Cql::QueryError # keyspace does not exist
+        raise Errors::UnexistingKeyspaceError, keyspace
+      end
     end
-  end
-  
-  def self.use(keyspace)
-    raise Errors::ClientNotStartedError unless client
-    client.use(keyspace)
-  end
 
-  def self.execute(cql)
-    raise Errors::ClientNotStartedError unless client
-    client.execute(cql)
-  end  
-  
-private
-  
-  def self.connect_to_server
-    load_config
+    def self.execute(cql)
+      connect_to_server unless client
+      client.execute(cql)
+    end  
     
-    Rails.logger.try(:info, "Connecting to Cassandra on #{config['host']}:#{config['port']}")
+  private
     
-    begin
-      self.client = Cql::Client.new(:host => config['host'], :port => config['port'])
-      client.connect
-    rescue Cql::Io::ConnectionError => e
-      raise Errors::ConnectionError, e.message      
-    end
-  end
-  
-  def self.load_config
-    begin
-      self.config = YAML.load_file(Rails.root.join("config", "cassandra.yml"))[Rails.env]
-    rescue Errno::ENOENT
-      raise Errors::MissingConfigurationError
+    def self.connect_to_server
+      Rails.logger.try(:info, "Connecting to Cassandra on #{Config.host}:#{Config.port}")
+      
+      begin
+        self.client = Cql::Client.new(:host => Config.host, :port => Config.port)
+        client.connect
+      rescue Cql::Io::ConnectionError => e
+        raise Errors::ConnectionError, e.message      
+      end
     end
   end
-end
+end

data/lib/cassandra_migrations/config.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module CassandraMigrations
+  module Config
+  
+    mattr_accessor :config
+    
+    def self.method_missing(method_sym, *arguments, &block)
+      load_config unless config    
+      config[method_sym.to_s]
+    end
+    
+  private
+
+    def self.load_config
+      begin
+        self.config = YAML.load_file(Rails.root.join("config", "cassandra.yml"))[Rails.env]
+      rescue Errno::ENOENT
+        raise Errors::MissingConfigurationError
+      end
+    end
+  
+  end
+end

data/lib/cassandra_migrations/{cassandra/errors.rb → errors.rb}

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-module CassandraMigrations::Cassandra
+module CassandraMigrations
   module Errors
 
     class CassandraError < StandardError
@@ -39,4 +39,4 @@ module CassandraMigrations::Cassandra
     end
     
   end
-end
+end

data/lib/cassandra_migrations/{cassandra/migrator.rb → migrator.rb}

@@ -1,9 +1,11 @@
 # encoding: utf-8
 
-module CassandraMigrations::Cassandra
+module CassandraMigrations
   module Migrator
     
-    def self.up_to_latest
+    METADATA_TABLE = 'cassandra_migrations_metadata'
+    
+    def self.up_to_latest!
       current_version = read_current_version
   
       new_migrations = get_all_migration_names.sort.select do |migration_name|
@@ -17,7 +19,7 @@ module CassandraMigrations::Cassandra
       new_migrations.size
     end
   
-    def self.rollback(count=1)
+    def self.rollback!(count=1)
       current_version = read_current_version
       
       executed_migrations = get_all_migration_names.sort.reverse.select do |migration_name|
@@ -39,7 +41,13 @@ module CassandraMigrations::Cassandra
     end
   
     def self.read_current_version
-      CassandraMigrations::Cassandra.select("metadata", :selection => "data_name='version'", :projection => 'data_value').first['data_value'].to_i
+      begin
+        Cassandra.select(METADATA_TABLE, :selection => "data_name='version'", :projection => 'data_value').first['data_value'].to_i
+      rescue Cql::QueryError # table cassandra_migrations_metadata does not exist
+        Cassandra.execute("CREATE TABLE #{METADATA_TABLE} (data_name varchar PRIMARY KEY, data_value varchar)") 
+        Cassandra.write!(METADATA_TABLE, {:data_name => 'version', :data_value => '0'})
+        return 0
+      end
     end
     
 private
@@ -51,7 +59,7 @@ private
       get_class_from_migration_name(migration_name).up
       
       # update version
-      CassandraMigrations::Cassandra.write("metadata", {:data_name => 'version', :data_value => get_version_from_migration_name(migration_name).to_s})
+      Cassandra.write!(METADATA_TABLE, {:data_name => 'version', :data_value => get_version_from_migration_name(migration_name).to_s})
     end
     
     def self.down(migration_name, previous_migration_name=nil)
@@ -62,9 +70,9 @@ private
       
       # downgrade version
       if previous_migration_name
-        CassandraMigrations::Cassandra.write("metadata", {:data_name => 'version', :data_value => get_version_from_migration_name(previous_migration_name).to_s})
+        Cassandra.write!(METADATA_TABLE, {:data_name => 'version', :data_value => get_version_from_migration_name(previous_migration_name).to_s})
       else
-        CassandraMigrations::Cassandra.write("metadata", {:data_name => 'version', :data_value => '0'})
+        Cassandra.write!(METADATA_TABLE, {:data_name => 'version', :data_value => '0'})
       end
     end
     
@@ -80,4 +88,4 @@ private
       migration_name.match(/([0-9]{14})_.+\.rb$/).captures.first.to_i
     end
   end
-end
+end

data/lib/cassandra_migrations/railtie/initializer.rb

@@ -1,17 +1,30 @@
 # encoding : utf-8
 
-# Em produção (como usamos o Passenger), vários processos ruby são criados através do fork
-# do original. No UNIX, quando um fork é realizado, is file descriptors (arquivos, conexões a base de dados,
-# sockets, e etc) são copiados em estado aberto para o processo filho. Se não reabrirmos a conexão com o cassandra
-# no processo filho, quando ela for ser usada ela estará 'locked' pelo processo pai, o que resultará em deadlock. 
+# In production (when Passenger is used with smart spawn), many ruby processes are created
+# by forking the original spawner. Since the child process is a different process, it shares
+# no memory with its father. Because of that we have to connect to cassandra again.
+# It is also common that file descriptors are unintentionally shared when the process forks,
+# that's why we go through the safe path and check if the client exists in order to restart it
+# (production tests have shown that the client is nil when forked)
 
-# Mais explicações em: http://www.modrails.com/documentation/Users%20guide%20Apache.html#spawning_methods_explained
-if defined?(PhusionPassenger)
-  PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    if forked
-      CassandraMigrations::Cassandra.restart!
+# More explanations in: http://www.modrails.com/documentation/Users%20guide%20Apache.html#spawning_methods_explained
+
+module CassandraMigrations
+
+  if defined?(PhusionPassenger)
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+      if forked
+        if Cassandra.client
+          Rails.logger.info "Passenger process forked: reconnecting to Cassandra..."
+          Cassandra.restart!
+        else
+          Rails.logger.info "Passenger process forked: connecting to Cassandra..."
+          Cassandra.start!
+        end
+      end
     end
+  else
+    Cassandra.start!
   end
-else
-  CassandraMigrations::Cassandra.start!
+  
 end

data/lib/cassandra_migrations/railtie/tasks.rake

@@ -10,26 +10,26 @@ namespace :cassandra do
   task :create do
     begin
       CassandraMigrations::Cassandra.start!
-      puts "Keyspace #{CassandraMigrations::Cassandra.config['keyspace']} already exists!"
-    rescue CassandraMigrations::Cassandra::Errors::UnexistingKeyspaceError
+      puts "Keyspace #{CassandraMigrations::Config.keyspace} already exists!"
+    rescue CassandraMigrations::Errors::UnexistingKeyspaceError
       CassandraMigrations::Cassandra.create_keyspace!
-      puts "Created keyspace #{CassandraMigrations::Cassandra.config['keyspace']}"
+      puts "Created keyspace #{CassandraMigrations::Config.keyspace}"
     end
   end
 
   desc 'Drop keyspace in config/cassandra.yml for the current environment'
   task :drop do
     begin
-      CassandraMigrations::Cassandra.drop!
-      puts "Dropped keyspace #{CassandraMigrations::Cassandra.config['keyspace']}"
-    rescue CassandraMigrations::Cassandra::Errors::UnexistingKeyspaceError
-      puts "Keyspace #{CassandraMigrations::Cassandra.config['keyspace']} does not exist already... cannot be dropped"
+      CassandraMigrations::Cassandra.drop_keyspace!
+      puts "Dropped keyspace #{CassandraMigrations::Config.keyspace}"
+    rescue CassandraMigrations::Errors::UnexistingKeyspaceError
+      puts "Keyspace #{CassandraMigrations::Config.keyspace} does not exist... cannot be dropped"
     end
   end
 
   desc 'Migrate the keyspace to the latest version'
   task :migrate => :start do
-    migrations_up_count = CassandraMigrations::Cassandra::Migrator.up_to_latest
+    migrations_up_count = CassandraMigrations::Migrator.up_to_latest!
 
     if migrations_up_count == 0
       puts "Already up-to-date"
@@ -40,9 +40,9 @@ namespace :cassandra do
 
   desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n)'
   task :rollback => :start do
-    steps = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    steps = (ENV['STEP'] ? ENV['STEP'].to_i : 1)
 
-    migrations_down_count = CassandraMigrations::Cassandra::Migrator.rollback(steps)
+    migrations_down_count = CassandraMigrations::Migrator.rollback!(steps)
 
     if steps == migrations_down_count
       puts "Rolled back #{steps} version(s)."
@@ -68,7 +68,7 @@ namespace :cassandra do
 
   desc 'Retrieves the current schema version number'
   task :version => :start do
-    puts "Current version: #{Cassandra::Migrator.read_current_version}"
+    puts "Current version: #{CassandraMigrations::Migrator.read_current_version}"
   end
 
 end

data/lib/cassandra_migrations.rb

@@ -1,6 +1,6 @@
-
-module CassandraMigrations
-end
-
+require 'cassandra_migrations/config'
+require 'cassandra_migrations/errors'
 require 'cassandra_migrations/cassandra'
+require 'cassandra_migrations/migrator'
+
 require 'cassandra_migrations/railtie' if defined?(Rails)

data/spec/cassandra_migrations/cassandra_spec.rb

@@ -14,7 +14,7 @@ describe CassandraMigrations::Cassandra do
   end
   
   after do
-    CassandraMigrations::Cassandra.shutdown!
+    CassandraMigrations::Cassandra.shutdown! if CassandraMigrations::Cassandra.client
   end
   
   describe ".start!" do
@@ -45,18 +45,16 @@ describe CassandraMigrations::Cassandra do
     
     it "should use host and port configurations to create cassandra client" do
       cql_client_mock = Cql::Client.new
-      cql_client_mock.should_receive(:start!)
+      cql_client_mock.should_receive(:connect)
+      cql_client_mock.stub(:use)
       Cql::Client.should_receive(:new).with(:host => '127.0.0.1', :port => 9042).and_return(cql_client_mock)
       
-      begin
-        CassandraMigrations::Cassandra.start!
-      rescue
-      end
+      CassandraMigrations::Cassandra.start!
     end
     
     it "should raise exception if not able to connect to cassandra host" do
       cql_client_mock = Cql::Client.new
-      cql_client_mock.stub(:start!).and_raise Cql::Io::ConnectionError
+      cql_client_mock.stub(:connect).and_raise Cql::Io::ConnectionError
       Cql::Client.stub(:new).and_return cql_client_mock
       
       expect do
@@ -68,7 +66,9 @@ describe CassandraMigrations::Cassandra do
       CassandraMigrations::Cassandra.should_receive(:use).with('cassandra_migrations_development')
       CassandraMigrations::Cassandra.start!
     end
-    
+  end
+  
+  describe '.use' do
     it "should raise exception if configured keyspace does not exist" do
       expect do
         CassandraMigrations::Cassandra.start!
@@ -85,4 +85,4 @@ describe CassandraMigrations::Cassandra do
     end
   end
   
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra_migrations
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre3
+  version: 0.0.1.pre4
   prerelease: 6
 platform: ruby
 authors:
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre5
+        version: 1.0.0.pre7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre5
+        version: 1.0.0.pre7
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -99,17 +99,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cassandra_migrations.rb
-- lib/cassandra_migrations/cassandra/migrator.rb
-- lib/cassandra_migrations/cassandra/query.rb
-- lib/cassandra_migrations/cassandra/errors.rb
-- lib/cassandra_migrations/railtie/tasks.rake
-- lib/cassandra_migrations/railtie/initializer.rb
+- lib/cassandra_migrations/migrator.rb
 - lib/cassandra_migrations/cassandra.rb
 - lib/cassandra_migrations/railtie.rb
-- spec/cassandra_migrations/cassandra_spec.rb
+- lib/cassandra_migrations/cassandra/keyspace_operations.rb
+- lib/cassandra_migrations/cassandra/queries.rb
+- lib/cassandra_migrations/config.rb
+- lib/cassandra_migrations/railtie/initializer.rb
+- lib/cassandra_migrations/railtie/tasks.rake
+- lib/cassandra_migrations/errors.rb
 - spec/cassandra_migrations_spec.rb
+- spec/cassandra_migrations/cassandra_spec.rb
 homepage: https://github.com/hsgubert/cassandra_migrations
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -133,5 +136,5 @@ signing_key:
 specification_version: 3
 summary: Cassandra schema management for a multi-environment developer.
 test_files:
-- spec/cassandra_migrations/cassandra_spec.rb
 - spec/cassandra_migrations_spec.rb
+- spec/cassandra_migrations/cassandra_spec.rb

data/lib/cassandra_migrations/cassandra/query.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module CassandraMigrations::Cassandra
-  module Query
-  
-    def write(table, hash)
-      columns = []
-      values = []
-      
-      hash.each do |k,v| 
-        columns << k.to_s
-        values << "'#{v.to_s}'"
-      end
-  
-      execute("INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{values.join(', ')})")
-    end
-    
-    def select(table, options={})
-      query_string = "SELECT #{options[:projection] || '*'} FROM #{table}"
-      
-      if options[:selection]
-        query_string << " WHERE #{options[:selection]}"
-      end
-      
-      if options[:order_by]
-        query_string << " ORDER BY #{options[:order_by]}"
-      end
-      
-      if options[:limit]
-        query_string << " LIMIT #{options[:limit]}"
-      end
-  
-      execute(query_string)
-    end
-    
-    def delete(table, selection, options={})
-      execute("DELETE #{options[:projection]} FROM #{table} WHERE #{selection}")
-    end
-    
-    def truncate(table)
-      execute("TRUNCATE #{table}")
-    end
-  end
-end