schema-evolution-manager 0.9.24

data/bin/sem-config

@@ -0,0 +1 @@
+load File.join(File.dirname(__FILE__), '../lib/schema-evolution-manager.rb')

data/bin/sem-dist

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+# == Creates a tarball containing SQL scripts that might need to be
+#    applied to a specific postgresql database. This tarball can then
+#    be uploaded, unpacked, and schema changes applied using
+#    schema-evolution-manager scripts
+#
+# == Usage
+#  sem-dist [--artifact_name <tag> --tag <tag>]
+#
+#    name
+#      Optional artifact_name - defaults to the current directory name. Used in the
+#      actual artifact name which has the format <artifact_name>-<tag>.tar.gz
+#
+#    tag
+#      Optional tag - if specified, we create a distribution file for this tag.
+#      If not specified, we create a new tag.
+#
+# == Example
+#  sem-dist
+#    Creates a new tag and generates the distribution file
+#
+#  sem-dist --tag 0.0.1
+#    Creates a distribution file for the specified tag
+#
+
+load File.join(File.dirname(__FILE__), 'sem-config')
+SchemaEvolutionManager::Library.set_verbose(true)
+
+args = SchemaEvolutionManager::Args.from_stdin(:optional => ['artifact_name', 'tag'])
+
+# On MAC OS X, use gnutar to avoid warnings like
+#   Ignoring unknown extended header keyword `SCHILY.ino'
+tar_cmd = `which gnutar 2> /dev/null`.strip
+if tar_cmd == ""
+  tar_cmd = "tar"
+end
+
+if args.tag
+  tag = args.tag
+else
+  if latest = SchemaEvolutionManager::Library.latest_tag
+    suggested_tag = latest.next_micro.to_version_string
+  else
+    suggested_tag = "0.0.1"
+  end
+
+  tag = SchemaEvolutionManager::Ask.for_string("Version:", :default => suggested_tag)
+  if !SchemaEvolutionManager::Library.tag_exists?(tag)
+    SchemaEvolutionManager::Library.git_create_tag(tag)
+  end
+end
+SchemaEvolutionManager::Library.git_assert_tag_exists(tag)
+
+changes = SchemaEvolutionManager::Library.git_changes(:tag => tag)
+repo_path = SchemaEvolutionManager::Library.normalize_path(`pwd`.strip)
+
+if args.artifact_name
+  artifact_name = args.artifact_name
+else
+  artifact_name = File.basename(repo_path)
+end
+
+filename = "%s-%s" % [artifact_name, tag]
+
+dist_dir = File.join(repo_path, "dist")
+SchemaEvolutionManager::Library.ensure_dir!(dist_dir)
+tarball = File.join(dist_dir, "#{filename}.tar")
+
+SchemaEvolutionManager::Library.with_temp_file do |tmp|
+  tmpdir = File.join(tmp, filename)
+  SchemaEvolutionManager::Library.ensure_dir!(tmpdir)
+
+  SchemaEvolutionManager::Library.system_or_error("cp -R %s %s" % [File.join(repo_path, "scripts"), File.join(tmpdir, "scripts")])
+  File.open(File.join(tmpdir, "CHANGES"), "w") { |out| out << changes }
+
+  Dir.chdir(tmp) do
+    SchemaEvolutionManager::Library.system_or_error("#{tar_cmd} cf #{filename}.tar #{filename}")
+    FileUtils.cp("#{filename}.tar", tarball)
+  end
+end
+
+gzip_file = "#{tarball}.gz"
+if File.exists?(gzip_file)
+  puts "Removing old gzip file at #{gzip_file}"
+  FileUtils.rm(gzip_file)
+end
+
+command = "gzip #{tarball}"
+SchemaEvolutionManager::Library.system_or_error(command)
+
+puts ""
+puts "Created distribution file at #{gzip_file}"

data/bin/sem-info

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# Usage
+#
+#  sem-info command [arg1...]
+#
+#  sem-info tag exists 1.2.3
+#    Returns true if the specified tag exists,
+#    false otherwise
+#
+#  sem-info tag latest
+#    Display the latest tag
+#
+#  sem-info version
+#    Display the version of schema-evolution-manager
+#
+#  sem-info tag next [major|minor|micro]
+#    Output information on the next tag. Defaults to micro
+#    version increment from latest tag
+#
+# Description
+#
+#   Utility script to pull information from the schema-evolution-manager
+#   libraries. Initially designed to help with wrapper scripts that
+#   needed information (like the next minor tag)
+#
+
+load File.join(File.dirname(__FILE__), 'sem-config')
+
+command = ARGV.shift.to_s.strip
+
+if command == "tag"
+  puts SchemaEvolutionManager::SemInfo.tag(ARGV)
+
+elsif command == "version"
+  puts SchemaEvolutionManager::SemInfo.version(ARGV)
+
+else
+  if command != ""
+    puts "ERROR: Unrecognized command[%s]" % command
+    puts ""
+  end
+  SchemaEvolutionManager::RdocUsage.printAndExit(1)
+end

data/bin/sem-init

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+# == Initializes an existing git repository to support schema evolutions managed
+#    by schema-evolution-manager
+#
+# == Usage
+#  sem-init --dir <dir> --url <url>
+#  or
+#  sem-init --dir <dir> --host <database host> --user <db user> --name <db name>
+#
+#   dir: The directory containing a git repository that will contain the schema evolution files
+#   url: The connection string for the psql database
+#
+# == Example
+#  git init /tmp/example_repo
+#  bin/sem-init --dir /tmp/example_repo --url postgresql://username@localhost/sample
+#
+
+load File.join(File.dirname(__FILE__), 'sem-config')
+SchemaEvolutionManager::Library.set_verbose(true)
+
+args = SchemaEvolutionManager::Args.from_stdin(:required => %w(dir), :optional => %w(url host port name user))
+SchemaEvolutionManager::Preconditions.check_state(File.directory?(args.dir), "Dir[%s] does not exist" % args.dir)
+
+if args.url.nil? && args.name.nil?
+  puts "Must specify either url or name"
+  exit(1)
+end
+
+db = SchemaEvolutionManager::Db.from_args(args)
+
+def copy_file(source, target, substitutions)
+  template = SchemaEvolutionManager::Template.new
+  substitutions.each do |name, value|
+    template.add(name, value)
+  end
+  final = template.parse(IO.read(source))
+  File.open(target, "w") do |os|
+    os << final
+  end
+end
+
+template_dir = File.join(SchemaEvolutionManager::Library.base_dir, "template")
+SchemaEvolutionManager::Preconditions.check_state(File.directory?(template_dir),
+                                                  "Could not find schema-evolution-manager/template subdir. Expected it at[%s]" % [template_dir])
+
+subs = {
+  "url" => db.url,
+  "add_script_path" => File.join(SchemaEvolutionManager::Library.base_dir, "bin/sem-add")
+}
+
+puts "chdir %s" % args.dir
+Dir.chdir(args.dir) do
+
+  wrappers = []
+  Dir.glob("#{template_dir}/*").each do |path|
+    wrapper = File.basename(path)
+    if !File.exists?(wrapper)
+      puts "Creating wrapper script #{wrapper}"
+      copy_file(path, wrapper, subs)
+      SchemaEvolutionManager::Library.system_or_error("chmod +x #{wrapper}")
+      SchemaEvolutionManager::Library.system_or_error("git add #{wrapper}")
+      wrappers << wrapper
+    end
+  end
+  if !wrappers.empty?
+    SchemaEvolutionManager::Library.system_or_error("git commit -m 'Add schema-evolution-manager wrapper scripts' #{wrappers.join(" ")}")
+  end
+
+  readme = "README.md"
+  if !File.exists?(readme)
+    puts "Creating #{readme}"
+    copy_file("schema-evolution-manager/template/README.md", "README.md", subs)
+    SchemaEvolutionManager::Library.system_or_error("git add #{readme}")
+    SchemaEvolutionManager::Library.system_or_error("git commit -m 'Adding README.md' README.md")
+  end
+
+  if !File.exists?("scripts")
+    SchemaEvolutionManager::Library.system_or_error("mkdir scripts")
+    SchemaEvolutionManager::Library.system_or_error("touch scripts/.exists")
+    SchemaEvolutionManager::Library.system_or_error("git add scripts/.exists")
+    SchemaEvolutionManager::Library.system_or_error("git commit -m 'Adding scripts directory' scripts/.exists")
+  end
+
+  # Create the first git tag if necessary
+  tags = SchemaEvolutionManager::Library.system_or_error("git tag -l")
+  if tags.nil? || tags == ""
+    puts "Creating initial git tag (0.0.1)"
+    SchemaEvolutionManager::Library.git_create_tag("0.0.1")
+  end
+
+  if SchemaEvolutionManager::Library.git_has_remote?
+    SchemaEvolutionManager::Library.system_or_error("git push origin master")
+  end
+
+end

data/lib/schema-evolution-manager.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+require 'pathname'
+
+dir = File.dirname(__FILE__)
+lib_dir = File.join(dir, "schema-evolution-manager")
+
+load File.join(lib_dir, 'preconditions.rb')
+load File.join(lib_dir, 'rdoc_usage.rb')
+load File.join(lib_dir, 'library.rb')
+
+# Need to set base_dir early - version.rb depends on dir being set
+SchemaEvolutionManager::Library.set_base_dir(File.join(dir, '..'))
+
+load File.join(lib_dir, 'sem_version.rb')
+load File.join(lib_dir, 'ask.rb')
+load File.join(lib_dir, 'version.rb')
+load File.join(lib_dir, 'args.rb')
+load File.join(lib_dir, 'scripts.rb')
+load File.join(lib_dir, 'db.rb')
+load File.join(lib_dir, 'apply_util.rb')
+load File.join(lib_dir, 'baseline_util.rb')
+load File.join(lib_dir, 'template.rb')
+load File.join(lib_dir, 'install_template.rb')
+load File.join(lib_dir, 'script_error.rb')
+load File.join(lib_dir, 'sem_info.rb')
+load File.join(lib_dir, 'migration_file.rb')

data/lib/schema-evolution-manager/apply_util.rb

@@ -0,0 +1,60 @@
+module SchemaEvolutionManager
+
+  class ApplyUtil
+
+    def initialize(db, opts={})
+      @dry_run = opts.delete(:dry_run)
+      if @dry_run.nil?
+        @dry_run = true
+      end
+
+      @db = Preconditions.assert_class(db, Db)
+      @scripts = Scripts.new(@db, Scripts::SCRIPTS)
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    # Applies scripts in order, returning number of scripts applied
+    def apply!(dir)
+      Preconditions.check_state(File.directory?(dir),
+                                "Dir[%s] does not exist" % dir)
+
+      count = 0
+      @scripts.each_pending(dir) do |filename, path|
+        count += 1
+        if @dry_run
+          puts "[DRY RUN] Applying #{filename}"
+          apply_dry_run(filename, path)
+        else
+          puts "Applying #{filename}"
+          apply_real(filename, path)
+        end
+      end
+      count
+    end
+
+    private
+    def apply_dry_run(filename, path)
+      puts path
+      puts ""
+    end
+
+    def apply_real(filename, path)
+      have_error = true
+      begin
+        @db.psql_file(path)
+        have_error = false
+      ensure
+        if have_error
+          raise ScriptError.new(@db, filename)
+        end
+      end
+
+      @scripts.record_as_run!(filename)
+    end
+
+  end
+
+end

data/lib/schema-evolution-manager/args.rb

@@ -0,0 +1,159 @@
+module SchemaEvolutionManager
+
+  # Container for common args, mainly to have stricter validation on
+  # inputs. Tried to use GetoptLong but could not write solid unit
+  # tests around it... so we have our own internal simple implementation.
+  class Args
+
+    if !defined?(FLAGS_WITH_ARGUMENTS)
+      FLAGS_WITH_ARGUMENTS = {
+        :artifact_name => "Specifies the name of the artifact. Tag will be appeneded to this name",
+        :user => "Connect to the database as this username instead of the default",
+        :host => "Specifies the host name of the machine on which the server is running",
+        :port => "Specifies the port on which the server is running",
+        :name => "Specifies the name of the database to which to connect",
+        :url => "Connect to the database as this username instead of the default",
+        :dir => "Path to a directory",
+        :tag => "A git tag (e.g. 0.0.1)",
+        :prefix => "Configure installer to use this prefix"
+      }
+
+      FLAGS_NO_ARGUMENTS = {
+        :dry_run => "Include flag to echo commands that will run without actually executing them",
+        :help => "Display help",
+        :verbose => "Enable verbose logging of all system calls",
+      }
+    end
+
+    attr_reader :artifact_name, :host, :port, :name, :prefix, :url, :user, :dir, :dry_run, :tag
+
+    # args: Actual string arguments
+    # :required => list of parameters that are required
+    # :optional => list of parameters that are optional
+    def initialize(args, opts={})
+      Preconditions.assert_class_or_nil(args, String)
+      required = (opts.delete(:required) || []).map { |flag| format_flag(flag) }
+      optional = (opts.delete(:optional) || []).map { |flag| format_flag(flag) }
+      Preconditions.assert_class(required, Array)
+      Preconditions.assert_class(optional, Array)
+      Preconditions.assert_empty_opts(opts)
+      Preconditions.check_state(optional.size + required.size > 0,
+                                "Must have at least 1 optional or required parameter")
+
+      if !optional.include?(:help)
+        optional << :help
+      end
+      if !optional.include?(:verbose)
+        optional << :verbose
+      end
+
+      found_arguments = parse_string_arguments(args)
+      missing = required.select { |field| blank?(found_arguments[field]) }
+
+      @artifact_name = found_arguments.delete(:artifact_name)
+      @host = found_arguments.delete(:host)
+      @port = found_arguments.delete(:port) 
+      @name = found_arguments.delete(:name)
+      @prefix = found_arguments.delete(:prefix)
+      @url = found_arguments.delete(:url)
+      @user = found_arguments.delete(:user)
+      @dir = found_arguments.delete(:dir)
+      @tag = found_arguments.delete(:tag)
+
+      @dry_run = found_arguments.delete(:dry_run)
+      @help = found_arguments.delete(:help)
+      @verbose = found_arguments.delete(:verbose)
+
+      Preconditions.check_state(found_arguments.empty?,
+                                "Did not handle all flags: %s" % found_arguments.keys.join(" "))
+
+      if @help
+        RdocUsage.printAndExit(0)
+      end
+
+      if @verbose
+        Library.set_verbose(true)
+      end
+
+      if !missing.empty?
+        missing_fields_error(required, optional, missing)
+      end
+    end
+
+    # Hack to minimize bleeding from STDIN. Returns an instance of Args class
+    def Args.from_stdin(opts)
+      values = ARGV.join(" ")
+      Args.new(values, opts)
+    end
+
+    private
+    def blank?(value)
+      value.to_s.strip == ""
+    end
+
+    def missing_fields_error(required, optional, fields)
+      Preconditions.assert_class(fields, Array)
+      Preconditions.check_state(!fields.empty?, "Missing fields cannot be empty")
+
+      title = fields.size == 1 ? "Missing parameter" : "Missing parameters"
+      sorted = fields.sort_by { |f| f.to_s }
+
+      puts "**************************************************"
+      puts "ERROR: #{title}: #{sorted.join(", ")}"
+      puts "**************************************************"
+      puts help_parameters("Required parameters", required)
+      puts help_parameters("Optional parameters", optional)
+      exit(1)
+    end
+
+    def help_parameters(title, parameters)
+      docs = []
+      if !parameters.empty?
+        docs << ""
+        docs << title
+        docs << "-------------------"
+        parameters.each do |flag|
+          documentation = FLAGS_WITH_ARGUMENTS[flag] || FLAGS_NO_ARGUMENTS[flag]
+          Preconditions.check_not_null(documentation, "No documentation found for flag[%s]" % flag)
+          docs << "  --#{flag}"
+          docs <<  "    " + documentation
+          docs <<  ""
+        end
+      end
+      docs.join("\n")
+    end
+
+
+    def parse_string_arguments(args)
+      Preconditions.assert_class_or_nil(args, String)
+      found = {}
+      index = 0
+      values = args.to_s.strip.split(/\s+/)
+      while index < values.length do
+        flag = format_flag(values[index])
+        index += 1
+
+        if FLAGS_WITH_ARGUMENTS.has_key?(flag)
+          found[flag] = values[index]
+          index += 1
+
+        elsif FLAGS_NO_ARGUMENTS.has_key?(flag)
+          found[flag] = true
+
+        else
+          raise "Unknown flag[%s]" % flag
+        end
+
+      end
+      found
+    end
+
+    # Strip leading dashes and convert to symbol
+    def format_flag(flag)
+      Preconditions.assert_class(flag, String)
+      flag.sub(/^\-\-/, '').to_sym
+    end
+
+  end
+
+end