active_column 0.1.1 → 0.2

data/lib/active_column/tasks/column_family.rb

@@ -9,39 +9,51 @@ module ActiveColumn
                            :long      => 'LongType',
                            :string    => 'BytesType' }
 
-      def initialize
-        @cassandra = ActiveColumn.connection
+      def initialize(keyspace)
+        raise 'Cannot operate on system keyspace' if keyspace == 'system'
+        @keyspace = keyspace
       end
 
       def exists?(name)
-        @cassandra.schema.cf_defs.find { |cf_def| cf_def.name == name.to_s }
+        connection.schema.cf_defs.find { |cf_def| cf_def.name == name.to_s }
       end
 
-      def create(name, options = {})
-        opts = { :name => name.to_s,
-                 :keyspace => @cassandra.keyspace,
-                 :comparator_type => 'TimeUUIDType' }.merge(options)
+      def create(name, &block)
+        cf = Cassandra::ColumnFamily.new
+        cf.name = name.to_s
+        cf.keyspace = @keyspace.to_s
+        cf.comparator_type = 'TimeUUIDType'
 
-        cf = Cassandra::ColumnFamily.new.with_fields(opts)
-        @cassandra.add_column_family(cf)
+        block.call cf if block
+
+        post_process_column_family(cf)
+        connection.add_column_family(cf)
       end
 
       def drop(name)
-        @cassandra.drop_column_family(name.to_s)
+        connection.drop_column_family(name.to_s)
+      end
+
+      def rename(old_name, new_name)
+        connection.rename_column_family(old_name.to_s, new_name.to_s)
       end
 
       def clear(name)
-        @cassandra.truncate!(name.to_s)
+        connection.truncate!(name.to_s)
       end
 
       private
 
-      def post_process_options(options)
-        type = options[:comparator_type]
+      def connection
+        ActiveColumn.connection
+      end
+
+      def post_process_column_family(cf)
+        type = cf.comparator_type
         if type && COMPARATOR_TYPES.has_key?(type)
-          options[:comparator_type] = COMPARATOR_TYPES[type]
+          cf.comparator_type = COMPARATOR_TYPES[type]
         end
-        options
+        cf
       end
 
     end
@@ -54,11 +66,10 @@ class Cassandra
   class ColumnFamily
     def with_fields(options)
       struct_fields.collect { |f| f[1][:name] }.each do |f|
-        send("#{f}=", options[f.to_sym])
+        send("#{f}=", options[f.to_sym] || options[f.to_s])
       end
       self
     end
   end
 end
 
-

data/lib/active_column/tasks/keyspace.rb

@@ -3,6 +3,16 @@ module ActiveColumn
   module Tasks
 
     class Keyspace
+      include ActiveColumn::Helpers
+
+      def self.parse(hash)
+        ks = Cassandra::Keyspace.new.with_fields hash
+        ks.cf_defs = []
+        hash['cf_defs'].each do |cf|
+          ks.cf_defs << Cassandra::ColumnFamily.new.with_fields(cf)
+        end
+        ks
+      end
 
       def initialize
         c = ActiveColumn.connection
@@ -14,6 +24,11 @@ module ActiveColumn
       end
 
       def create(name, options = {})
+        if exists? name
+          log "Keyspace '#{name}' already exists - cannot create"
+          return nil
+        end
+
         opts = { :name => name.to_s,
                  :strategy_class => 'org.apache.cassandra.locator.LocalStrategy',
                  :replication_factor => 1,
@@ -21,13 +36,18 @@ module ActiveColumn
 
         ks = Cassandra::Keyspace.new.with_fields(opts)
         @cassandra.add_keyspace ks
+        ks
       end
 
       def drop(name)
+        return log 'Cannot drop system keyspace' if name == 'system'
+        return log "Keyspace '#{name}' does not exist - cannot drop" if !exists? name
         @cassandra.drop_keyspace name.to_s
+        true
       end
 
       def set(name)
+        return log "Keyspace '#{name}' does not exist - cannot set" if !exists? name
         @cassandra.keyspace = name.to_s
       end
 
@@ -36,11 +56,26 @@ module ActiveColumn
       end
 
       def clear
-        return puts 'Cannot clear system keyspace' if @cassandra.keyspace == 'system'
-
+        return log 'Cannot clear system keyspace' if @cassandra.keyspace == 'system'
         @cassandra.clear_keyspace!
       end
 
+      def schema_dump
+        @cassandra.schema
+      end
+
+      def schema_load(schema)
+        @cassandra.schema.cf_defs.each do |cf|
+          @cassandra.drop_column_family cf.name
+        end
+
+        keyspace = get
+        schema.cf_defs.each do |cf|
+          cf.keyspace = keyspace
+          @cassandra.add_column_family cf
+        end
+      end
+
     end
 
   end
@@ -51,7 +86,7 @@ class Cassandra
   class Keyspace
     def with_fields(options)
       struct_fields.collect { |f| f[1][:name] }.each do |f|
-        send("#{f}=", options[f.to_sym])
+        send("#{f}=", options[f.to_sym] || options[f.to_s])
       end
       self
     end

data/lib/active_column/tasks/ks.rake

@@ -0,0 +1,142 @@
+require 'rake'
+require 'active_column/tasks/keyspace'
+require 'active_column/tasks/column_family'
+
+namespace :ks do
+
+  if defined? ::Rails
+    task :configure => :environment do
+      configure
+    end
+  else
+    task :configure do
+      configure
+    end
+  end
+
+  task :set_keyspace => :configure do
+    set_keyspace
+  end
+
+  desc 'Create the keyspace in config/cassandra.yml for the current environment'
+  task :create => :configure do
+    ks = ActiveColumn::Tasks::Keyspace.new.create @config['keyspace'], @config
+    puts "Created keyspace: #{@config['keyspace']}" if ks
+  end
+
+  namespace :create do
+    desc 'Create keyspaces in config/cassandra.yml for all environments'
+    task :all => :configure do
+      @configs.values.each do |config|
+        ks = ActiveColumn::Tasks::Keyspace.new.create config['keyspace'], config
+        puts "Created keyspace: #{config['keyspace']}" if ks
+      end
+    end
+  end
+
+  desc 'Drop keyspace in config/cassandra.yml for the current environment'
+  task :drop => :configure do
+    dropped = ActiveColumn::Tasks::Keyspace.new.drop @config['keyspace']
+    puts "Dropped keyspace: #{@config['keyspace']}" if dropped
+  end
+
+  namespace :drop do
+    desc 'Drop keyspaces in config/cassandra.yml for all environments'
+    task :all => :configure do
+      @configs.values.each do |config|
+        dropped = ActiveColumn::Tasks::Keyspace.new.drop config['keyspace']
+        puts "Dropped keyspace: #{config['keyspace']}" if dropped
+      end
+    end
+  end
+
+  desc 'Migrate the keyspace (options: VERSION=x)'
+  task :migrate => :set_keyspace do
+    version = ( ENV['VERSION'] ? ENV['VERSION'].to_i : nil )
+    ActiveColumn::Migrator.migrate ActiveColumn::Migrator.migrations_path, version
+    schema_dump
+  end
+
+  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n)'
+  task :rollback => :set_keyspace do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveColumn::Migrator.rollback ActiveColumn::Migrator.migrations_path, step
+    schema_dump
+  end
+
+  desc 'Pushes the schema to the next version (specify steps w/ STEP=n)'
+  task :forward => :set_keyspace do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveColumn::Migrator.forward ActiveColumn::Migrator.migrations_path, step
+    schema_dump
+  end
+
+  namespace :schema do
+    desc 'Create ks/schema.json file that can be portably used against any Cassandra instance supported by ActiveColumn'
+    task :dump => :configure do
+      schema_dump
+    end
+
+    desc 'Load ks/schema.json file into Cassandra'
+    task :load => :configure do
+      schema_load
+    end
+  end
+
+  namespace :test do
+    desc 'Load the development schema in to the test keyspace'
+    task :prepare => :configure do
+      schema_dump :development
+      schema_load :test
+    end
+  end
+
+  desc 'Retrieves the current schema version number'
+  task :version => :set_keyspace do
+    version = ActiveColumn::Migrator.current_version
+    puts "Current version: #{version}"
+  end
+
+  private
+
+  def current_root
+    return Rails.root.to_s if defined? ::Rails
+    '.'
+  end
+
+  def configure
+    @configs = YAML.load_file("#{current_root}/config/cassandra.yml")
+    @config = @configs[ActiveColumn::Helpers.current_env]
+    ActiveColumn.connect @config
+  end
+
+  def schema_dump(env = ActiveColumn::Helpers.current_env)
+    ks = set_keyspace env
+    File.open "#{current_root}/ks/schema.json", 'w' do |file|
+      basic_json = ks.schema_dump.to_json
+      formatted_json = JSON.pretty_generate(JSON.parse(basic_json))
+      file.puts formatted_json
+    end
+  end
+
+  def schema_load(env = ActiveColumn::Helpers.current_env)
+    ks = set_keyspace env
+    File.open "#{current_root}/ks/schema.json", 'r' do |file|
+      hash = JSON.parse(file.read(nil))
+      ks.schema_load ActiveColumn::Tasks::Keyspace.parse(hash)
+    end
+  end
+
+  def set_keyspace(env = ActiveColumn::Helpers.current_env)
+    config = @configs[env.to_s || 'development']
+    ks = ActiveColumn::Tasks::Keyspace.new
+    keyspace = config['keyspace']
+    unless ks.exists? keyspace
+      puts "Keyspace '#{keyspace}' does not exist - Try 'rake ks:create'"
+      exit 1
+    end
+    ks.set keyspace
+    ks
+  end
+
+end

data/lib/active_column/version.rb

@@ -1,3 +1,3 @@
 module ActiveColumn
-  VERSION = "0.1.1"
+  VERSION = "0.2"
 end

data/spec/active_column/migration_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'mocha'
+
+describe ActiveColumn::Migration do
+  describe '.create_column_family' do
+
+    context 'given a block' do
+      before do
+        ActiveColumn.connection.expects(:add_column_family).with() do |cf|
+          cf.name == 'foo' && cf.comment = 'some comment'
+        end
+      end
+
+      it 'sends the settings to cassandra' do
+        ActiveColumn::Migration.create_column_family :foo do |cf|
+          cf.comment = 'some comment'
+        end
+      end
+    end
+
+    context 'given no block' do
+      before do
+        ActiveColumn.connection.expects(:add_column_family).with() do |cf|
+          cf.name == 'foo' && cf.comment.nil?
+        end
+      end
+
+      it 'sends the default settings to cassandra' do
+        ActiveColumn::Migration.create_column_family :foo
+      end
+    end
+
+  end
+
+  describe '.drop_column_family' do
+    context 'given a column family' do
+      before do
+        ActiveColumn.connection.expects(:drop_column_family).with('foo')
+      end
+
+      it 'drops it' do
+        ActiveColumn::Migration.drop_column_family :foo
+      end
+    end
+  end
+
+  describe '.rename_column_family' do
+    context 'given a column family and a new name' do
+      before do
+        ActiveColumn.connection.expects(:rename_column_family).with('old_foo', 'new_foo')
+      end
+
+      it 'renames it' do
+        ActiveColumn::Migration.rename_column_family :old_foo, :new_foo
+      end
+    end
+  end
+end

data/spec/active_column/tasks/column_family_spec.rb

@@ -1,8 +1,10 @@
 require 'spec_helper'
 
 def translated_comparator(given)
-  cf = ActiveColumn::Tasks::ColumnFamily.new
-  cf.send(:post_process_options, { :comparator_type => given })[:comparator_type]
+  cf_tasks = ActiveColumn.column_family_tasks
+  cf = Cassandra::ColumnFamily.new
+  cf.comparator_type = given
+  cf_tasks.send(:post_process_column_family, cf).comparator_type
 end
 
 describe ActiveColumn::Tasks::ColumnFamily do

data/spec/active_column/tasks/keyspace_spec.rb

@@ -3,27 +3,36 @@ require 'spec_helper'
 describe ActiveColumn::Tasks::Keyspace do
 
   before do
-    @ks = ActiveColumn::Tasks::Keyspace.new
+    @ks = ActiveColumn.keyspace_tasks
   end
 
-  describe ".create" do
+  describe "#create" do
     context "given a keyspace" do
       before do
         @ks.drop :ks_create_test if @ks.exists?(:ks_create_test)
-        @ks.create :ks_create_test
+        @keyspace = @ks.create :ks_create_test
+        @no_keyspace = @ks.create :ks_create_test
       end
 
       it "creates the keyspace" do
         @ks.exists?(:ks_create_test).should be
       end
 
+      it 'returns the keyspace' do
+        @keyspace.should be
+      end
+
+      it 'does not create duplicate keyspaces' do
+        @no_keyspace.should_not be
+      end
+
       after do
         @ks.drop :ks_create_test
       end
     end
   end
 
-  describe '.drop' do
+  describe '#drop' do
     context 'given a keyspace' do
       before do
         @ks.create :ks_drop_test unless @ks.exists?(:ks_drop_test)
@@ -33,6 +42,97 @@ describe ActiveColumn::Tasks::Keyspace do
       it 'drops the keyspace' do
         @ks.exists?(:ks_drop_test).should_not be
       end
+
+      it 'gracefully does not drop the keyspace again' do
+        @ks.drop :ks_drop_test
+      end
+    end
+  end
+
+  describe '.parse' do
+    context 'given a keyspace schema as a hash' do
+      before do
+        @hash = { 'name' => 'ks1',
+                  'cf_defs' => [ { 'name' => 'cf1', 'comment' => 'foo' },
+                                 { 'name' => 'cf2', 'comment' => 'bar' } ] }
+        @schema = ActiveColumn::Tasks::Keyspace.parse @hash
+        @cfdefs = @schema.cf_defs.sort { |a,b| a.name <=> b.name }
+      end
+
+      it 'returns a keyspace schema' do
+        @schema.should be_a(Cassandra::Keyspace)
+        @schema.name.should == 'ks1'
+      end
+
+      it 'returns all column families' do
+        @cfdefs.collect(&:name).should == [ 'cf1', 'cf2' ]
+        @cfdefs.collect(&:comment).should == [ 'foo', 'bar' ]
+      end
+    end
+  end
+
+  describe '#schema_dump' do
+    context 'given a keyspace' do
+      before do
+        @ks.drop :ks_schema_dump_test if @ks.exists?(:ks_schema_dump_test)
+        @ks.create :ks_schema_dump_test
+        @ks.set :ks_schema_dump_test
+        cf_tasks = ActiveColumn::Tasks::ColumnFamily.new :ks_schema_dump_test
+        cf_tasks.create(:cf1) { |cf| cf.comment = 'foo' }
+        cf_tasks.create(:cf2) { |cf| cf.comment = 'bar' }
+        @schema = @ks.schema_dump
+        @cfdefs = @schema.cf_defs.sort { |a,b| a.name <=> b.name }
+      end
+
+      it 'dumps the keyspace schema' do
+        @schema.should be
+        @schema.name.should == 'ks_schema_dump_test'
+      end
+
+      it 'dumps all column families' do
+        @cfdefs.collect(&:name).should == [ 'cf1', 'cf2' ]
+        @cfdefs.collect(&:comment).should == [ 'foo', 'bar' ]
+      end
+
+      after do
+        @ks.drop :ks_schema_dump_test
+      end
+    end
+  end
+
+  describe '#schema_load' do
+    context 'given a keyspace schema' do
+      before do
+        @ks.drop :ks_schema_load_test if @ks.exists?(:ks_schema_load_test)
+        @ks.create :ks_schema_load_test
+        @ks.set :ks_schema_load_test
+        cf_tasks = ActiveColumn::Tasks::ColumnFamily.new :ks_schema_load_test
+        cf_tasks.create(:cf1) { |cf| cf.comment = 'foo' }
+        cf_tasks.create(:cf2) { |cf| cf.comment = 'bar' }
+        schema = @ks.schema_dump
+
+        @ks.drop :ks_schema_load_test2 if @ks.exists?(:ks_schema_load_test2)
+        @ks.create :ks_schema_load_test2
+        @ks.set :ks_schema_load_test2
+        @ks.schema_load schema
+        @schema2 = @ks.schema_dump
+        @cfdefs2 = @schema2.cf_defs.sort { |a,b| a.name <=> b.name }
+      end
+
+      it 'loads the keyspace' do
+        @schema2.should be
+        @schema2.name.should == 'ks_schema_load_test2'
+      end
+
+      it 'loads all column families' do
+        @cfdefs2.collect(&:name).should == [ 'cf1', 'cf2' ]
+        @cfdefs2.collect(&:comment).should == [ 'foo', 'bar' ]
+      end
+
+      after do
+        @ks.drop :ks_schema_load_test
+        @ks.drop :ks_schema_load_test2
+      end
     end
   end
 end