dbgeni 0.10.0

data/lib/dbgeni/file_converter.rb

@@ -0,0 +1,44 @@
+module DBGeni
+
+  class FileConverter
+
+    def self.convert(directory, file, config)
+      fc = new(directory, file, config)
+      fc.convert
+    end
+
+    def initialize(directory, file, config)
+      @directory = directory
+      @file      = file
+      @config    = config
+      create_temp
+    end
+
+    def convert
+      original_file = File.join(@directory, @file)
+      output_file   = File.join(@temp_dir, @file)
+      begin
+        of = File.open(output_file, 'w')
+        File.foreach(original_file) do |line|
+          # remove potential \r\n from dos files. isql chokes on these on linux
+          # but not on windows.
+          line.chomp!
+          of.print line
+          of.print "\n"
+        end
+      ensure
+        of.close
+      end
+      output_file
+    end
+
+    private
+
+    def create_temp
+      @temp_dir = File.join(@config.base_directory, 'log', 'temp')
+      FileUtils.mkdir_p(@temp_dir)
+    end
+
+  end
+
+end

data/lib/dbgeni/initializers/initializer.rb

@@ -0,0 +1,44 @@
+module DBGeni
+  module Initializer
+
+    def self.initialize(db_connection, config)
+      required_module = setup(config.db_type)
+      begin
+        required_method = required_module.method("initialize")
+      rescue NameError
+        raise DBGeni::InvalidInitializerForDBType, config.db_type
+      end
+      required_method.call(db_connection, config)
+    end
+
+    def self.initialized?(db_connection, config)
+      required_module = setup(config.db_type)
+      begin
+        required_method = required_module.method("initialized?")
+      rescue NameError
+        raise DBGeni::InvalidInitializerForDBType, config.db_type
+      end
+      required_method.call(db_connection, config)
+    end
+
+    private
+
+    def self.setup(db_type)
+      begin
+        require "dbgeni/initializers/#{db_type}"
+      rescue
+        raise DBGeni::NoInitializerForDBType, db_type
+      end
+
+      required_module = nil
+      if Initializer.const_defined?(db_type.capitalize)
+        required_module = Initializer.const_get(db_type.capitalize)
+      else
+        raise raise DBGeni::NoInitializerForDBType, db_type
+      end
+      required_module
+    end
+
+  end
+end
+

data/lib/dbgeni/initializers/mysql.rb

@@ -0,0 +1,36 @@
+module DBGeni
+  module Initializer
+    module Mysql
+
+      def self.initialize(db_connection, config)
+        raise DBGeni::DatabaseAlreadyInitialized if self.initialized?(db_connection, config)
+        db_connection.execute("create table #{config.db_table}
+                               (
+                                  sequence_or_hash varchar(100) not null,
+                                  migration_name   varchar(4000) not null,
+                                  migration_type   varchar(20)   not null,
+                                  migration_state  varchar(20)   not null,
+                                  start_dtm        datetime,
+                                  completed_dtm    datetime
+                               )")
+        db_connection.execute("create unique index #{config.db_table}_uk1 on #{config.db_table} (sequence_or_hash, migration_name(500), migration_type)")
+        db_connection.execute("create index #{config.db_table}_idx2 on #{config.db_table} (migration_name)")
+      end
+
+      def self.initialized?(db_connection, config)
+        # it is initialized if a table called dbgeni_migrations or whatever is
+        # defined in config exists
+        results = db_connection.execute("show tables like '#{config.db_table.downcase}'")
+        if 0 == results.length
+          false
+        else
+          true
+        end
+      end
+
+    end
+  end
+end
+
+
+

data/lib/dbgeni/initializers/oracle.rb

@@ -0,0 +1,38 @@
+module DBGeni
+  module Initializer
+    module Oracle
+
+      def self.initialize(db_connection, config)
+        raise DBGeni::DatabaseAlreadyInitialized if self.initialized?(db_connection, config)
+        db_connection.execute("create table #{config.db_table}
+                               (
+                                  sequence_or_hash varchar2(100) not null,
+                                  migration_name   varchar2(4000) not null,
+                                  migration_type   varchar2(20)   not null,
+                                  migration_state  varchar2(20)   not null,
+                                  start_dtm        date,
+                                  completed_dtm    date
+                               )")
+        db_connection.execute("create unique index #{config.db_table}_uk1 on #{config.db_table} (sequence_or_hash, migration_name, migration_type)")
+        db_connection.execute("create index #{config.db_table}_idx2 on #{config.db_table} (migration_name)")
+      end
+
+      def self.initialized?(db_connection, config)
+        # it is initialized if a table called dbgeni_migrations or whatever is
+        # defined in config exists
+        results = db_connection.execute("select table_name from all_tables where table_name = :t and owner = :o",
+                                        config.db_table.upcase,
+                                        config.env.install_schema ? config.env.install_schema.upcase : config.env.username.upcase)
+        if 0 == results.length
+          false
+        else
+          true
+        end
+      end
+
+    end
+  end
+end
+
+
+

data/lib/dbgeni/initializers/sqlite.rb

@@ -0,0 +1,33 @@
+module DBGeni
+  module Initializer
+    module Sqlite
+
+      def self.initialize(db_connection, config)
+        raise DBGeni::DatabaseAlreadyInitialized if self.initialized?(db_connection, config)
+        db_connection.execute("create table #{config.db_table}
+                               (
+                                  sequence_or_hash varchar2(100) not null,
+                                  migration_name   varchar2(4000) not null,
+                                  migration_type   varchar2(20)   not null,
+                                  migration_state  varchar2(20)   not null,
+                                  start_dtm        date,
+                                  completed_dtm    date
+                               )")
+        db_connection.execute("create unique index #{config.db_table}_uk1 on #{config.db_table} (sequence_or_hash, migration_name, migration_type)")
+        db_connection.execute("create index #{config.db_table}_idx2 on #{config.db_table} (migration_name)")
+      end
+
+      def self.initialized?(db_connection, config)
+        # it is initialized if a table called dbgeni_migrations or whatever is
+        # defined in config exists
+        results = db_connection.execute("SELECT name FROM sqlite_master WHERE name = :t", config.db_table.downcase)
+        if 0 == results.length
+          false
+        else
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/dbgeni/initializers/sybase.rb

@@ -0,0 +1,34 @@
+module DBGeni
+  module Initializer
+    module Sybase
+
+      def self.initialize(db_connection, config)
+        raise DBGeni::DatabaseAlreadyInitialized if self.initialized?(db_connection, config)
+        db_connection.execute("create table #{config.db_table}
+                               (
+                                  sequence_or_hash varchar(100) not null,
+                                  migration_name   varchar(1100) not null,
+                                  migration_type   varchar(20)   not null,
+                                  migration_state  varchar(20)   not null,
+                                  start_dtm        datetime      null,
+                                  completed_dtm    datetime      null
+                               )")
+        db_connection.execute("create unique index #{config.db_table}_uk1 on #{config.db_table} (sequence_or_hash, migration_name, migration_type)")
+        db_connection.execute("create index #{config.db_table}_idx2 on #{config.db_table} (migration_name)")
+      end
+
+      def self.initialized?(db_connection, config)
+        # it is initialized if a table called dbgeni_migrations or whatever is
+        # defined in config exists
+        results = db_connection.execute("select name from sysobjects where name = \?", config.db_table.downcase)
+        if 0 == results.length
+          false
+        else
+          true
+        end
+      end
+
+    end
+  end
+end
+

data/lib/dbgeni/logger.rb

@@ -0,0 +1,60 @@
+module DBGeni
+
+  class Logger
+
+    def self.instance(location=nil)
+      @@singleton_instance ||= self.new(location)
+    end
+
+    def info(msg)
+      write_msg(msg)
+    end
+
+    def error(msg)
+      write_msg("ERROR - #{msg}")
+    end
+
+    def close
+      if @fh && !@fh.closed?
+        @fh.close
+      end
+      @@singleton_instance = nil
+    end
+
+    # This could be done in the initialize block, but then even for
+    # non destructive commands, there would be a detailed log dir
+    # created, so only create the dir when the directory is asked for.
+    def detailed_log_dir
+      FileUtils.mkdir_p(File.join(@log_location, @detailed_log_dir))
+      File.join(@log_location, @detailed_log_dir)
+    end
+
+    def reset_detailed_log_dir
+      @detailed_log_dir = Time.now.strftime('%Y%m%d%H%M%S')
+    end
+
+    private
+
+    def write_msg(msg, echo=true)
+      if @fh && !@fh.closed?
+        @fh.puts "#{Time.now.strftime('%Y%m%d %H:%M:%S')} - #{msg}"
+      end
+      puts msg
+    end
+
+    def initialize(location=nil)
+      # If location is nil, then error
+      @log_location = File.expand_path(location)
+      if @log_location
+        FileUtils.mkdir_p(location)
+        @fh = File.open("#{location}/log.txt", 'a')
+        @fh.puts("\n\n\n###################################################")
+        @fh.puts("dbgeni initialized")
+        reset_detailed_log_dir
+        @fh.puts("Detailed log files will be written in #{File.join(@log_location, @detailed_log_dir)}")
+      end
+    end
+
+  end
+
+end

data/lib/dbgeni/migration.rb

@@ -0,0 +1,302 @@
+module DBGeni
+
+  class Migration
+
+    # These are all the states a migration can be in. The NEW status is never in the
+    # database, as that is the default state when it has been created as a file,
+    # but never applied to the database.
+    #
+    # PENDING - this is the state a migration goes into before the migration is runin
+    #           and while it is running.
+    # COMPLETED - after the migration completes, if it was successful it gets moved to this state
+    # FAILED    - after the migration completes, if it failed it gets moved to this state
+    # ROLLEDBACK - if a migration has been rolledback, it goes into this state.
+    NEW         = 'New'
+    PENDING     = 'Pending'
+    FAILED      = 'Failed'
+    COMPLETED   = 'Completed'
+    ROLLEDBACK  = 'Rolledback'
+    # TODO - add verified state?
+
+    attr_reader :directory, :migration_file, :rollback_file, :name, :sequence, :logfile, :error_messages
+    attr_accessor :migration_type
+
+    def self.internal_name_from_filename(filename)
+      filename =~ /^(\d{12})_(up|down)_(.+)\.sql$/
+      "#{$1}::#{$3}"
+    end
+
+    def self.filename_from_internal_name(internal_name)
+      internal_name =~ /^(\d{12})::(.+)$/
+      "#{$1}_up_#{$2}.sql"
+    end
+
+    def self.initialize_from_internal_name(directory, name)
+      self.new(directory, Migration.filename_from_internal_name(name))
+    end
+
+    def self.get_milestone_migration(directory, name)
+      migration = ''
+      begin
+        f = File.open(File.join(directory,name), 'r')
+        migration = f.readline.chomp
+      rescue EOFError
+      ensure
+        f.close if f
+      end
+      unless migration =~ /^(\d{12})_(up|down)_(.+)\.sql$/
+        raise DBGeni::MilestoneHasNoMigration, name
+      end
+      migration
+    end
+
+    def initialize(directory, migration)
+      @migration_type = 'Migration'
+      @directory      = directory
+      @migration_file = migration
+      parse_file
+      @rollback_file  = "#{sequence}_down_#{name}.sql"
+      @runnable_migration = nil
+      @runnable_rollback  = nil
+    end
+
+    def migration_file(dir='up')
+      "#{@sequence}_#{dir}_#{name}.sql"
+    end
+
+    def ==(other)
+      if other.migration_file == @migration_file and other.directory == @directory
+        true
+      else
+        false
+      end
+    end
+
+    def applied?(config, connection)
+      result = status(config, connection)
+      result == COMPLETED ? true : false
+    end
+
+    def status(config, connection)
+      set_env(config, connection)
+      results = connection.execute("select migration_state
+                                    from #{@config.db_table}
+                                    where sequence_or_hash = ?
+                                    and migration_name = ?
+                                    and migration_type = ?", @sequence, @name, @migration_type)
+      results.length == 1 ? results[0][0] : NEW
+    end
+    #"
+
+    def apply!(config, connection, force=nil)
+      set_env(config, connection)
+      if applied?(config, connection) and force != true
+        raise DBGeni::MigrationAlreadyApplied, self.to_s
+      end
+      ensure_file_exists
+      migrator = DBGeni::Migrator.initialize(config, connection)
+      convert_migration(config)
+      set_pending!
+      begin
+        migrator.apply(self, force)
+        set_completed!
+      rescue Exception => e
+        set_failed!
+        if e.class == DBGeni::MigratorCouldNotConnect
+          raise e
+        else
+          raise DBGeni::MigrationApplyFailed, self.to_s
+        end
+      ensure
+        @logfile        = migrator.logfile
+        @error_messages = migrator.migration_errors
+      end
+    end
+
+    def rollback!(config, connection, force=nil)
+      set_env(config, connection)
+      if [NEW, ROLLEDBACK].include? status(config, connection) and force != true
+        raise DBGeni::MigrationNotApplied, self.to_s
+      end
+      ensure_file_exists('down')
+      migrator = DBGeni::Migrator.initialize(config, connection)
+      convert_rollback(config)
+      set_pending!
+      begin
+        migrator.rollback(self, force)
+        set_rolledback!()
+
+      rescue Exception => e
+        set_failed!
+        if e.class == DBGeni::MigratorCouldNotConnect
+          raise e
+        else
+          raise DBGeni::MigrationApplyFailed, self.to_s
+        end
+      ensure
+        @logfile        = migrator.logfile
+        @error_messages = migrator.migration_errors
+      end
+    end
+
+    def verify!(config, connection)
+    end
+
+    def set_pending(config, connection)
+      set_env(config, connection)
+      set_pending!
+    end
+
+    def set_completed(config, connection)
+      set_env(config, connection)
+      set_completed!
+    end
+
+    def set_failed(config, connection)
+      set_env(config, connection)
+      set_failed!
+    end
+
+    def set_rolledback(config, connection)
+      set_env(config, connection)
+      set_rolledback!
+    end
+
+    def to_s
+      "#{@sequence}::#{@name}"
+    end
+
+    def convert_migration(config)
+      @runnable_migration = FileConverter.convert(@directory, @migration_file, config)
+    end
+
+    def convert_rollback(config)
+      @runnable_rollback = FileConverter.convert(@directory, @rollback_file, config)
+    end
+
+    def runnable_migration
+      if @runnable_migration
+        @runnable_migration
+      else
+        File.join(@directory, @migration_file)
+      end
+    end
+
+    def runnable_rollback
+      if @runnable_rollback
+        @runnable_rollback
+      else
+        File.join(@directory, @rollback_file)
+      end
+    end
+
+
+    private
+
+    def set_pending!
+      insert_or_set_state(PENDING)
+    end
+
+    def set_completed!
+      insert_or_set_state(COMPLETED)
+    end
+
+    def set_failed!
+      insert_or_set_state(FAILED)
+    end
+
+    def set_rolledback!
+      insert_or_set_state(ROLLEDBACK)
+    end
+
+    def set_env(config, connection)
+      @config     = config
+      @connection = connection
+    end
+
+    def insert_or_set_state(state)
+      results = existing_db_record
+      if results.length == 0 then
+        add_db_record(state)
+      else
+        update_db_state(state)
+      end
+    end
+
+    def existing_db_record
+      results = @connection.execute("select sequence_or_hash, migration_name, migration_type, migration_state, start_dtm, completed_dtm
+                                    from #{@config.db_table}
+                                    where sequence_or_hash = ?
+                                    and migration_name = ?
+                                    and migration_type = ?", @sequence, @name, @migration_type)
+    end
+#"
+
+    def add_db_record(state)
+      results = @connection.execute("insert into #{@config.db_table}
+                                    (
+                                       sequence_or_hash,
+                                       migration_name,
+                                       migration_type,
+                                       migration_state,
+                                       start_dtm
+                                    )
+                                    values
+                                    (
+                                       ?,
+                                       ?,
+                                       ?,
+                                       ?,
+                                       #{@connection.date_placeholder('sdtm')}
+                                    )", @sequence, @name, @migration_type, state, @connection.date_as_string(Time.now))
+    end
+
+
+    def update_db_state(state)
+      # What to set the dates to?  If going to PENDING, then you want to make
+      # completed_dtm null and reset start_dtm to now.
+      #
+      # If going to anything else, then set completed_dtm to now
+      if state == PENDING
+        results = @connection.execute("update #{@config.db_table}
+                                       set migration_state = ?,
+                                           completed_dtm   = null,
+                                           start_dtm       = #{@connection.date_placeholder('sdtm')}
+                                       where sequence_or_hash = ?
+                                    and   migration_name   = ?
+                                    and   migration_type   = ?", state, @connection.date_as_string(Time.now), @sequence, @name, @migration_type)
+      else
+        results = @connection.execute("update #{@config.db_table}
+                                    set migration_state = ?,
+                                        completed_dtm   = #{@connection.date_placeholder('sdtm')}
+                                    where sequence_or_hash = ?
+                                    and   migration_name   = ?
+                                    and   migration_type   = ?", state, @connection.date_as_string(Time.now), @sequence, @name, @migration_type)
+      end
+    end
+
+
+    def parse_file
+      # filename is made up of 3 parts
+      # Sequence - YYYYMMDDHH(24)MI - ie datestamp down to minute
+      # Operation - allowed are up, down, verify
+      # Migration_name - any amount of text
+      # eg
+      #     201107011644_up_my_shiny_new_table.sql
+      #
+      unless @migration_file =~ /^(\d{12})_up_(.+)\.sql$/
+        raise DBGeni::MigrationFilenameInvalid, self.migration_file
+      end
+      @sequence = $1
+      @name     = $2
+    end
+
+    def ensure_file_exists(dir='up')
+      unless File.exists? File.join(@directory, self.migration_file(dir))
+        raise DBGeni::MigrationFileNotExist, File.join(@directory, migration_file(dir))
+      end
+    end
+
+  end
+
+end