xmigra 1.0.1 → 1.1.0

data/lib/xmigra/schema_manipulator.rb

@@ -0,0 +1,39 @@
+
+module XMigra
+  class SchemaManipulator
+    DBINFO_FILE = 'database.yaml'
+    PERMISSIONS_FILE = 'permissions.yaml'
+    ACCESS_SUBDIR = 'access'
+    INDEXES_SUBDIR = 'indexes'
+    STRUCTURE_SUBDIR = 'structure'
+    VERINC_FILE = 'branch-upgrade.yaml'
+    
+    def initialize(path)
+      @path = Pathname.new(path)
+      @db_info = YAML.load_file(@path + DBINFO_FILE)
+      raise TypeError, "Expected Hash in #{DBINFO_FILE}" unless Hash === @db_info
+      @db_info = Hash.new do |h, k|
+        raise Error, "#{DBINFO_FILE} missing key #{k.inspect}"
+      end.update(@db_info)
+      
+      db_system = @db_info['system']
+      extend(
+        @db_specifics = DatabaseSupportModules.find {|m|
+          m::SYSTEM_NAME == db_system
+        } || NoSpecifics
+      )
+      
+      extend(
+        @vcs_specifics = VersionControlSupportModules.find {|m|
+          m.manages(path)
+        } || NoSpecifics
+      )
+    end
+    
+    attr_reader :path
+    
+    def branch_upgrade_file
+      @path.join(STRUCTURE_SUBDIR, VERINC_FILE)
+    end
+  end
+end

data/lib/xmigra/schema_updater.rb

@@ -0,0 +1,183 @@
+
+require 'xmigra/schema_manipulator'
+
+module XMigra
+  class SchemaUpdater < SchemaManipulator
+    DEV_SCRIPT_WARNING = <<-"END_OF_TEXT"
+*********************************************************
+***                    WARNING                        ***
+*********************************************************
+
+THIS SCRIPT IS FOR USE ONLY ON DEVELOPMENT DATABASES.
+
+IF RUN ON AN EMPTY DATABASE IT WILL CREATE A DEVELOPMENT
+DATABASE THAT IS NOT GUARANTEED TO FOLLOW ANY COMMITTED
+MIGRATION PATH.
+
+RUNNING THIS SCRIPT ON A PRODUCTION DATABASE WILL FAIL.
+        END_OF_TEXT
+    
+    def initialize(path)
+      super(path)
+      
+      @file_based_groups = []
+      
+      begin
+        @file_based_groups << (@access_artifacts = AccessArtifactCollection.new(
+          @path.join(ACCESS_SUBDIR),
+          :db_specifics=>@db_specifics,
+          :filename_metavariable=>@db_info.fetch('filename metavariable', nil)
+        ))
+        @file_based_groups << (@indexes = IndexCollection.new(
+          @path.join(INDEXES_SUBDIR),
+          :db_specifics=>@db_specifics
+        ))
+        @file_based_groups << (@migrations = MigrationChain.new(
+          @path.join(STRUCTURE_SUBDIR),
+          :db_specifics=>@db_specifics
+        ))
+        
+        @branch_upgrade = BranchUpgrade.new(branch_upgrade_file)
+        @file_based_groups << [@branch_upgrade] if @branch_upgrade.found?
+      rescue Error
+        raise
+      rescue StandardError
+        raise Error, "Error initializing #{self.class} components"
+      end
+      
+      @production = false
+    end
+    
+    attr_accessor :production
+    attr_reader :migrations, :access_artifacts, :indexes, :branch_upgrade
+    
+    def inspect
+      "<#{self.class.name}: path=#{path.to_s.inspect}, db=#{@db_specifics}, vcs=#{@vcs_specifics}>"
+    end
+    
+    def in_ddl_transaction
+      yield
+    end
+    
+    def ddl_block_separator; "\n"; end
+    
+    def update_sql
+      raise XMigra::Error, "Incomplete migration chain" unless @migrations.complete?
+      raise XMigra::Error, "Unchained migrations exist" unless @migrations.includes_all?
+      if respond_to? :warning
+        @branch_upgrade.warnings.each {|w| warning(w)}
+        if @branch_upgrade.found? && !@branch_upgrade.applicable?(@migrations)
+          warning("#{branch_upgrade.file_path} does not apply to the current migration chain.")
+        end
+      end
+      
+      check_working_copy!
+      
+      intro_comment = @db_info.fetch('script comment', '')
+      intro_comment << if production
+        sql_comment_block(vcs_information || "")
+      else
+        sql_comment_block(DEV_SCRIPT_WARNING)
+      end
+      intro_comment << "\n\n"
+      
+      # If supported, wrap transactionality around modifications
+      intro_comment + in_ddl_transaction do
+        script_parts = [
+          # Check for blatantly incorrect application of script, e.g. running
+          # on master or template database.
+          :check_execution_environment_sql,
+          
+          # Create schema version control (SVC) tables if they don't exist
+          :ensure_version_tables_sql,
+          
+          # Create and fill a temporary table with migration IDs known by
+          # the script with order information
+          :create_and_fill_migration_table_sql,
+          
+          # Create and fill a temporary table with index information known by
+          # the script
+          :create_and_fill_indexes_table_sql,
+          
+          # Check that all migrations applied to the database are known to
+          # the script (as far back as the most recent "version bridge" record)
+          :check_preceding_migrations_sql,
+          
+          # Check that there are no "gaps" in the chain of migrations
+          # that have already been applied
+          :check_chain_continuity_sql,
+          
+          # Mark migrations in the temporary table that should be installed
+          :select_for_install_sql,
+          
+          # Check production configuration of database
+          :production_config_check_sql,
+          
+          # Remove all access artifacts
+          :remove_access_artifacts_sql,
+          
+          # Remove all undesired indexes
+          :remove_undesired_indexes_sql,
+          
+          # Apply a branch upgrade if indicated
+          :branch_upgrade_sql,
+          
+          # Apply selected migrations
+          :apply_migration_sql,
+          
+          # Create all access artifacts
+          :create_access_artifacts_sql,
+          
+          # Create any desired indexes that don't yet exist
+          :create_new_indexes_sql,
+          
+          # Any cleanup needed
+          :upgrade_cleanup_sql,
+        ]
+        
+        amend_script_parts(script_parts)
+        
+        script_parts.map {|mn| self.send(mn)}.flatten.compact.join(ddl_block_separator)
+      end
+    end
+    
+    def amend_script_parts(parts)
+    end
+    
+    def sql_comment_block(text)
+      text.lines.collect {|l| '-- ' + l.chomp + "\n"}.join('')
+    end
+    
+    def check_working_copy!
+      raise VersionControlError, "XMigra source not under version control" if production
+    end
+    
+    def create_access_artifacts_sql
+      scripts = []
+      @access_artifacts.each_definition_sql {|s| scripts << s}
+      return scripts unless scripts.empty?
+    end
+    
+    def apply_migration_sql
+      # Apply selected migrations
+      @migrations.collect do |m|
+        m.migration_application_sql
+      end
+    end
+    
+    def branch_upgrade_sql
+    end
+    
+    def upgrade_cleanup_sql
+    end
+    
+    def vcs_information
+    end
+    
+    def each_file_path
+      @file_based_groups.each do |group|
+        group.each {|item| yield item.file_path}
+      end
+    end
+  end
+end

data/lib/xmigra/stored_procedure.rb

@@ -0,0 +1,20 @@
+
+require 'xmigra/access_artifact'
+
+module XMigra
+  class StoredProcedure < AccessArtifact
+    OBJECT_TYPE = "PROCEDURE"
+    
+    # Construct with a hash (as if loaded from a stored procedure YAML file)
+    def initialize(sproc_info)
+      @name = sproc_info["name"].dup.freeze
+      @definition = sproc_info["sql"].dup.freeze
+    end
+    
+    attr_reader :name
+    
+    def depends_on
+      []
+    end
+  end
+end

data/lib/xmigra/vcs_support/git.rb

@@ -0,0 +1,275 @@
+
+module XMigra
+  module GitSpecifics
+    VersionControlSupportModules << self
+    
+    MASTER_HEAD_ATTRIBUTE = 'xmigra-master'
+    MASTER_BRANCH_SUBDIR = 'xmigra-master'
+    
+    class << self
+      def manages(path)
+        run_git(:status, :check_exit=>true)
+      end
+      
+      def run_git(subcmd, *args)
+        options = (Hash === args[-1]) ? args.pop : {}
+        check_exit = options.fetch(:check_exit, false)
+        no_result = !options.fetch(:get_result, true)
+        
+        cmd_parts = ["git", subcmd.to_s]
+        cmd_parts.concat(
+          args.flatten.collect {|a| '""'.insert(1, a.to_s)}
+        )
+        case PLATFORM
+        when :unix
+          cmd_parts << "2>/dev/null"
+        end if options[:quiet]
+        
+        cmd_str = cmd_parts.join(' ')
+        
+        output = `#{cmd_str}`
+        return ($?.success? ? output : nil) if options[:get_result] == :on_success
+        return $?.success? if check_exit
+        raise(VersionControlError, "Git command failed with exit code #{$?.exitstatus}") unless $?.success?
+        return output unless no_result
+      end
+      
+      def attr_values(attr, path, options={})
+        value_list = run_git('check-attr', attr, '--', path).each_line.map do |line|
+          line.chomp.split(/: /, 3)[2]
+        end
+        return value_list unless options[:single]
+        raise VersionControlError, options[:single] + ' ambiguous' if value_list.length > 1
+        if (value_list.empty? || value_list == ['unspecified']) && options[:required]
+          raise VersionControlError, options[:single] + ' undefined'
+        end
+        return value_list[0]
+      end
+    end
+    
+    def git(*args)
+      Dir.chdir(self.path) do |pwd|
+        GitSpecifics.run_git(*args)
+      end
+    end
+    
+    def check_working_copy!
+      return unless production
+      
+      file_paths = Array.from_generator(method(:each_file_path))
+      unversioned_files = git(
+        'diff-index',
+        %w{-z --no-commit-id --name-only HEAD},
+        '--',
+        self.path
+      ).split("\000").collect do |path|
+        File.expand_path(self.path + path)
+      end
+      
+      # Check that file_paths and unversioned_files are disjoint
+      unless (file_paths & unversioned_files).empty?
+        raise VersionControlError, "Some source files differ from their committed versions"
+      end
+      
+      git_fetch_master_branch
+      migrations.each do |m|
+        # Check that the migration has not changed in the currently checked-out branch
+        fpath = m.file_path
+        
+        history = git(:log, %w{--format=%H --}, fpath).split
+        if history[1]
+          raise VersionControlError, "'#{fpath}' has been modified in the current branch of the repository since its introduction"
+        end
+      end
+      
+      # Since a production script was requested, warn if we are not generating
+      # from a production branch
+      if branch_use != :production
+        raise VersionControlError, "The working tree is not a commit in the master history."
+      end
+    end
+    
+    def vcs_information
+      return [
+        "Branch: #{branch_identifier}",
+        "Path: #{git_internal_path}",
+        "Commit: #{git_schema_commit}"
+      ].join("\n")
+    end
+    
+    def branch_identifier
+      return (if self.production
+        self.git_branch_info[0]
+      else
+        return @git_branch_identifier if defined? @git_branch_identifier
+        
+        @git_branch_identifier = (
+          self.git_master_head(:required=>false) ||
+          self.git_local_branch_identifier(:note_modifications=>true)
+        )
+      end)
+    end
+    
+    def branch_use(commit=nil)
+      if commit
+        self.git_fetch_master_branch
+        
+        # If there are no commits between the master head and *commit*, then
+        # *commit* is production-ish
+        return (self.git_commits_in? self.git_master_local_branch..commit) ? :development : :production
+      end
+      
+      return nil unless self.git_master_head(:required=>false)
+      
+      return self.git_branch_info[1]
+    end
+    
+    def vcs_move(old_path, new_path)
+      git(:mv, old_path, new_path, :get_result=>false)
+    end
+    
+    def vcs_remove(path)
+      git(:rm, path, :get_result=>false)
+    end
+    
+    def production_pattern
+      ".+"
+    end
+    
+    def production_pattern=(pattern)
+      raise VersionControlError, "Under version control by git, XMigra does not support production patterns."
+    end
+    
+    def get_conflict_info
+      structure_dir = Pathname.new(self.path) + SchemaManipulator::STRUCTURE_SUBDIR
+      head_file = structure_dir + MigrationChain::HEAD_FILE
+      stage_numbers = []
+      git('ls-files', '-uz', '--', head_file).split("\000").each {|ref|
+        if m = /[0-7]{6} [0-9a-f]{40} (\d)\t\S*/.match(ref)
+          stage_numbers |= [m[1].to_i]
+        end
+      }
+      return nil unless stage_numbers.sort == [1, 2, 3]
+      
+      chain_head = lambda do |stage_number|
+        return YAML.parse(
+          git(:show, ":#{stage_number}:#{head_file}")
+        ).transform
+      end
+      
+      # Ours (2) before theirs (3)...
+      heads = [2, 3].collect(&chain_head)
+      # ... unless merging from upstream
+      if self.git_merging_from_upstream?
+        heads.reverse!
+      end
+      
+      branch_point = chain_head.call(1)[MigrationChain::LATEST_CHANGE]
+      
+      conflict = MigrationConflict.new(structure_dir, branch_point, heads)
+      
+      # Standard git usage never commits directly to the master branch, and
+      # there is no effective way to tell if this is happening.
+      conflict.branch_use = :development
+      
+      tool = self
+      conflict.after_fix = proc {tool.resolve_conflict!(head_file)}
+      
+      return conflict
+    end
+    
+    def resolve_conflict!(path)
+      git(:add, '--', path, :get_result=>false)
+    end
+    
+    def git_master_head(options={})
+      options = {:required=>true}.merge(options)
+      return @git_master_head if defined? @git_master_head
+      master_head = GitSpecifics.attr_values(
+        MASTER_HEAD_ATTRIBUTE,
+        self.path + SchemaManipulator::DBINFO_FILE,
+        :single=>'Master branch',
+        :required=>options[:required]
+      )
+      return nil if master_head.nil?
+      return @git_master_head = master_head
+    end
+    
+    def git_branch
+      return @git_branch if defined? @git_branch
+      return @git_branch = git('rev-parse', %w{--abbrev-ref HEAD}).chomp
+    end
+    
+    def git_schema_commit
+      return @git_commit if defined? @git_commit
+      reported_commit = git(:log, %w{-n1 --format=%H --}, self.path).chomp
+      raise VersionControlError, "Schema not committed" if reported_commit.empty?
+      return @git_commit = reported_commit
+    end
+    
+    def git_branch_info
+      return @git_branch_info if defined? @git_branch_info
+      
+      self.git_fetch_master_branch
+      
+      # If there are no commits between the master head and HEAD, this working
+      # copy is production-ish
+      return (@git_branch_info = if self.branch_use('HEAD') == :production
+        [self.git_master_head, :production]
+      else
+        [self.git_local_branch_identifier, :development]
+      end)
+    end
+    
+    def git_local_branch_identifier(options={})
+      host = `hostname`
+      path = git('rev-parse', '--show-toplevel')
+      return "#{git_branch} of #{path} on #{host} (commit #{git_schema_commit})"
+    end
+    
+    def git_fetch_master_branch
+      return if @git_master_branch_fetched
+      master_url, remote_branch = self.git_master_head.split('#', 2)
+      
+      git(:fetch, '-f', master_url, "#{remote_branch}:#{git_master_local_branch}", :get_result=>false, :quiet=>true)
+      @git_master_branch_fetched = true
+    end
+    
+    def git_master_local_branch
+      "#{MASTER_BRANCH_SUBDIR}/#{git_branch}"
+    end
+    
+    def git_internal_path
+      return @git_internal_path if defined? @git_internal_path
+      path_prefix = git('rev-parse', %w{--show-prefix}).chomp[0..-2]
+      internal_path = '.'
+      if path_prefix.length > 0
+        internal_path += '/' + path_prefix
+      end
+      return @git_internal_path = internal_path
+    end
+    
+    def git_merging_from_upstream?
+      upstream = git('rev-parse', '@{u}', :get_result=>:on_success, :quiet=>true)
+      return false if upstream.nil?
+      
+      # Check if there are any commits in #{upstream}..MERGE_HEAD
+      begin
+        return !(self.git_commits_in? upstream..'MERGE_HEAD')
+      rescue VersionControlError
+        return false
+      end
+    end
+    
+    def git_commits_in?(range, path=nil)
+      git(
+        :log,
+        '--pretty=format:%H',
+        '-1',
+        "#{range.begin.strip}..#{range.end.strip}",
+        '--',
+        path || self.path
+      ) != ''
+    end
+  end
+end