Class: CassandraObject::Schema::Migrator

Inherits:
Object
  • Object
show all
Defined in:
lib/cassandra_object/schema/migrator.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(direction, migrations_path, target_version = nil) ⇒ Migrator

Returns a new instance of Migrator.



80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/cassandra_object/schema/migrator.rb', line 80

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'
    end
  end

  @direction, @migrations_path, @target_version = direction, migrations_path, target_version
end

Class Method Details

.column_family_tasks ⇒ Object 



46
47
48
49
 
# File 'lib/cassandra_object/schema/migrator.rb', line 46

def self.column_family_tasks
  cas = CassandraObject::Base.connection
  Tasks::ColumnFamily.new(cas.keyspace)
end

.current_version ⇒ Object 



56
57
58
59
60
61
62
63
 
# File 'lib/cassandra_object/schema/migrator.rb', line 56

def self.current_version
  sm_cf = schema_migrations_column_family
  if column_family_tasks.exists?(sm_cf)
    get_all_versions.max || 0
  else
    0
  end
end

.down(migrations_path, target_version = nil) ⇒ Object 



30
31
32
 
# File 'lib/cassandra_object/schema/migrator.rb', line 30

def self.down(migrations_path, target_version = nil)
  new(:down, migrations_path, target_version).migrate
end

.forward(migrations_path, steps = 1) ⇒ Object 



22
23
24
 
# File 'lib/cassandra_object/schema/migrator.rb', line 22

def self.forward(migrations_path, steps = 1)
  move(:up, migrations_path, steps)
end

.get_all_versions ⇒ Object 



51
52
53
54
 
# File 'lib/cassandra_object/schema/migrator.rb', line 51

def self.get_all_versions
  cas = CassandraObject::Base.connection
  cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
end

.migrate(migrations_path, target_version = nil) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/cassandra_object/schema/migrator.rb', line 6

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)
  end
end

.migrations_path ⇒ Object 



38
39
40
 
# File 'lib/cassandra_object/schema/migrator.rb', line 38

def self.migrations_path
  'ks/migrate'
end

.rollback(migrations_path, steps = 1) ⇒ Object 



18
19
20
 
# File 'lib/cassandra_object/schema/migrator.rb', line 18

def self.rollback(migrations_path, steps = 1)
  move(:down, migrations_path, steps)
end

.run(direction, migrations_path, target_version) ⇒ Object 



34
35
36
 
# File 'lib/cassandra_object/schema/migrator.rb', line 34

def self.run(direction, migrations_path, target_version)
  new(direction, migrations_path, target_version).run
end

.schema_migrations_column_family ⇒ Object 



42
43
44
 
# File 'lib/cassandra_object/schema/migrator.rb', line 42

def self.schema_migrations_column_family
  :schema_migrations
end

.up(migrations_path, target_version = nil) ⇒ Object 



26
27
28
 
# File 'lib/cassandra_object/schema/migrator.rb', line 26

def self.up(migrations_path, target_version = nil)
  new(:up, migrations_path, target_version).migrate
end

Instance Method Details

#current_migration ⇒ Object 



96
97
98
 
# File 'lib/cassandra_object/schema/migrator.rb', line 96

def current_migration
  migrations.detect { |m| m.version == current_version }
end

#current_version ⇒ Object 



92
93
94
 
# File 'lib/cassandra_object/schema/migrator.rb', line 92

def current_version
  migrated.last || 0
end

#migrate ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/cassandra_object/schema/migrator.rb', line 109

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)
  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)
  end
end

#migrated ⇒ Object 



176
177
178
 
# File 'lib/cassandra_object/schema/migrator.rb', line 176

def migrated
  @migrated_versions ||= self.class.get_all_versions
end

#migrations ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/cassandra_object/schema/migrator.rb', line 141

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

#pending_migrations ⇒ Object 



171
172
173
174
 
# File 'lib/cassandra_object/schema/migrator.rb', line 171

def pending_migrations
  already_migrated = migrated
  migrations.reject { |m| already_migrated.include?(m.version.to_i) }
end

#run ⇒ Object

Raises:



100
101
102
103
104
105
106
107
 
# File 'lib/cassandra_object/schema/migrator.rb', line 100

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)
  end
end