minestrone 0.0.1

data/lib/minestrone/recipes/deploy/assets.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'json'
+
+load 'deploy' unless defined?(_cset)
+
+_cset :asset_env, "RAILS_GROUPS=assets"
+_cset :assets_prefix, "assets"
+_cset :shared_assets_prefix, "assets"
+_cset :expire_assets_after, (3600 * 24 * 7)
+_cset(:asset_manifest_prefix) { (`sprockets -v`.chomp < "3.0" ? "manifest" : ".sprockets-manifest") rescue "manifest" }
+
+_cset :normalize_asset_timestamps, false
+
+before 'deploy:finalize_update',   'deploy:assets:symlink'
+after  'deploy:update_code',       'deploy:assets:precompile'
+before 'deploy:assets:precompile', 'deploy:assets:update_asset_mtimes'
+after  'deploy:cleanup',           'deploy:assets:clean_expired'
+after  'deploy:rollback:revision', 'deploy:assets:rollback'
+
+def shared_manifest_path
+  @shared_manifest_path ||= capture("ls #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}*").strip
+end
+
+# Parses manifest and returns array of uncompressed and compressed asset filenames with and without digests
+# "Intelligently" determines format of string - supports YAML and JSON
+def parse_manifest(str)
+  assets_hash = str[0,1] == '{' ? JSON.parse(str)['assets'] : YAML.load(str)
+
+  assets_hash.to_a.flatten.map {|a| [a, "#{a}.gz"] }.flatten
+end
+
+namespace :deploy do
+  namespace :assets do
+    desc <<-DESC
+      [internal] This task will set up a symlink to the shared directory \
+      for the assets directory. Assets are shared across deploys to avoid \
+      mid-deploy mismatches between old application html asking for assets \
+      and getting a 404 file not found error. The assets cache is shared \
+      for efficiency. If you customize the assets path prefix, override the \
+      :assets_prefix variable to match. If you customize shared assets path \
+      prefix, override :shared_assets_prefix variable to match.
+    DESC
+    task :symlink do
+      run <<-CMD.compact
+        rm -rf #{latest_release}/public/#{assets_prefix} &&
+        mkdir -p #{latest_release}/public &&
+        mkdir -p #{shared_path}/#{shared_assets_prefix} &&
+        ln -s #{shared_path}/#{shared_assets_prefix} #{latest_release}/public/#{assets_prefix}
+      CMD
+    end
+
+    desc <<-DESC
+      Run the asset precompilation rake task. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :precompile do
+      run <<-CMD.compact
+        cd -- #{latest_release} && 
+        RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} #{rake} assets:precompile
+      CMD
+
+      if capture("ls -1 #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* | wc -l").to_i > 1
+        raise "More than one asset manifest file was found in '#{shared_path.shellescape}/#{shared_assets_prefix}'.  If you are upgrading a Rails 3 application to Rails 4, follow these instructions: http://github.com/minestrone/minestrone/wiki/Upgrading-to-Rails-4#asset-pipeline"
+      end
+
+      # Sync manifest filenames if our manifest has a random filename
+      if shared_manifest_path =~ /#{asset_manifest_prefix}-.+\./
+        run <<-CMD.compact
+          [ -e #{shared_manifest_path.shellescape} ] || mv -- #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* #{shared_manifest_path.shellescape}
+        CMD
+      end
+
+      # Copy manifest to release root (for clean_expired task)
+      run <<-CMD.compact
+        cp -- #{shared_manifest_path.shellescape} #{current_release.to_s.shellescape}/assets_manifest#{File.extname(shared_manifest_path)}
+      CMD
+    end
+
+    desc <<-DESC
+      [internal] Updates the mtimes for assets that are required by the current release.
+      This task runs before assets:precompile.
+    DESC
+    task :update_asset_mtimes do
+      # Fetch assets/manifest contents.
+      manifest_content = capture("[ -e '#{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}*' ] && cat #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* || echo").strip
+
+      if manifest_content != ""
+        current_assets = parse_manifest(manifest_content)
+        logger.info "Updating mtimes for ~#{current_assets.count} assets..."
+        put current_assets.map{|a| "#{shared_path}/#{shared_assets_prefix}/#{a}" }.join("\n"), "#{deploy_to}/TOUCH_ASSETS", :via => :scp
+        run <<-CMD.compact
+          cat #{deploy_to.shellescape}/TOUCH_ASSETS | while read asset; do
+            touch -c -- "$asset";
+          done &&
+          rm -f -- #{deploy_to.shellescape}/TOUCH_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Run the asset clean rake task. Use with caution, this will delete \
+      all of your compiled assets. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :clean do
+      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:clean"
+    end
+
+    desc <<-DESC
+      Clean up any assets that haven't been deployed for more than :expire_assets_after seconds.
+      Default time to keep old assets is one week. Set the :expire_assets_after variable
+      to change the assets expiry time. Assets will only be deleted if they are not required by
+      an existing release.
+    DESC
+    task :clean_expired do
+      # Fetch all assets_manifest contents.
+      manifests_output = capture <<-CMD.compact
+        for manifest in #{releases_path.shellescape}/*/assets_manifest.*; do
+          cat -- "$manifest" 2> /dev/null && printf ':::' || true;
+        done
+      CMD
+      manifests = manifests_output.split(':::')
+
+      if manifests.empty?
+        logger.info "No manifests in #{releases_path}/*/assets_manifest.*"
+      else
+        logger.info "Fetched #{manifests.count} manifests from #{releases_path}/*/assets_manifest.*"
+        current_assets = Set.new
+        manifests.each do |content|
+          current_assets += parse_manifest(content)
+        end
+        current_assets += [File.basename(shared_manifest_path), "sources_manifest.yml"]
+
+        # Write the list of required assets to server.
+        logger.info "Writing required assets to #{deploy_to}/REQUIRED_ASSETS..."
+        escaped_assets = current_assets.sort.join("\n").gsub("\"", "\\\"") << "\n"
+        put escaped_assets, "#{deploy_to}/REQUIRED_ASSETS", :via => :scp
+
+        # Finds all files older than X minutes, then removes them if they are not referenced
+        # in REQUIRED_ASSETS.
+        expire_after_mins = (expire_assets_after.to_f / 60.0).to_i
+        logger.info "Removing assets that haven't been deployed for #{expire_after_mins} minutes..."
+        # LC_COLLATE=C tells the `sort` and `comm` commands to sort files in byte order.
+        run <<-CMD.compact
+          cd -- #{deploy_to.shellescape}/ &&
+          LC_COLLATE=C sort REQUIRED_ASSETS -o REQUIRED_ASSETS &&
+          cd -- #{shared_path.shellescape}/#{shared_assets_prefix}/ &&
+          for f in $(
+            find * -mmin +#{expire_after_mins.to_s.shellescape} -type f | LC_COLLATE=C sort |
+            LC_COLLATE=C comm -23 -- - #{deploy_to.shellescape}/REQUIRED_ASSETS
+          ); do
+            echo "Removing unneeded asset: $f";
+            rm -f -- "$f";
+          done;
+          rm -f -- #{deploy_to.shellescape}/REQUIRED_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Rolls back assets to the previous release by symlinking the release's manifest
+      to shared/assets/manifest, and finally recompiling or regenerating nondigest assets.
+    DESC
+    task :rollback do
+      previous_manifest = capture("ls #{previous_release.shellescape}/assets_manifest.*").strip
+
+      if capture("[ -e #{previous_manifest.shellescape} ] && echo true || echo false").strip != 'true'
+        puts "#{previous_manifest} is missing! Cannot roll back assets. " <<
+             "Please run deploy:assets:precompile to update your assets when the rollback is finished."
+      else
+        restored_manifest_path = shared_manifest_path
+
+        run <<-CMD.compact
+          cd -- #{previous_release.shellescape} &&
+          cp -f -- #{previous_manifest.shellescape} #{restored_manifest_path.shellescape} &&
+          [ -z "$(#{rake} -P | grep assets:precompile:nondigest)" ] || #{rake} RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} assets:precompile:nondigest
+        CMD
+      end
+    end
+  end
+end

data/lib/minestrone/recipes/deploy/bundler.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Based on:
+# https://github.com/ruby/rubygems/blob/master/bundler/lib/bundler/minestrone.rb
+# and https://github.com/minestrone/bundler
+
+load 'deploy' unless defined?(_cset)
+
+_cset :bundle_env, ''
+_cset :bundle_cmd, 'bundle'
+_cset(:bundle_path) { "#{shared_path}/bundle" }
+_cset :bundle_without, [:development, :test]
+_cset :bundle_flags, '--quiet'
+
+set(:rake) { "#{bundle_cmd} exec rake" }
+
+before "deploy:finalize_update", "bundle:install"
+before "bundle:install", "bundle:config"
+
+namespace :bundle do
+  desc <<-DESC
+    Sets up the Bundler configuration appropriate for a production environment.
+    You can customize the settings using the following variables:
+
+      set :bundle_cmd,     'bundle'   # e.g. '/usr/local/bin/bundle
+      set(:bundle_path)    { shared_path + "/bundle" }
+      set :bundle_without, [:development, :test]
+  DESC
+
+  task :config do    
+    bundle_cmd = fetch(:bundle_cmd)
+    bundle_path = fetch(:bundle_path)
+
+    without = fetch(:bundle_without)
+    without = [without] unless without.is_a?(Array)
+
+    settings = [
+      ['deployment', 'true'],
+      ['path', bundle_path],
+      ['without', without.map(&:to_s).join(' ')],
+    ]
+
+    settings.each do |key, value|
+      run "cd #{release_path} && #{bundle_cmd} config set --local #{key} '#{value}'"
+    end
+  end
+
+  desc <<-DESC
+    Installs the gems required by the app. By default, gems are installed to
+    \"\#{shared_path}/bundle\", with :development and :test groups skipped.
+
+    You can customize the settings using the following variables:
+
+      set :bundle_env,     ''         # e.g. 'SOME_LIBRARY_PATH=/usr/local' 
+      set :bundle_cmd,     'bundle'   # e.g. '/usr/local/bin/bundle
+      set(:bundle_path)    { shared_path + "/bundle" }
+      set :bundle_without, [:development, :test]
+      set :bundle_flags,   '--quiet'
+  DESC
+
+  task :install do
+    bundle_env = fetch(:bundle_env)
+    bundle_cmd = fetch(:bundle_cmd)
+    bundle_flags = fetch(:bundle_flags)
+
+    bundle_env += " " unless bundle_env.to_s.empty?
+
+    run "cd #{release_path} && #{bundle_env}#{bundle_cmd} install #{bundle_flags}"
+  end
+
+  desc <<-DESC
+    Cleans up older versions of gems in the shared bundle folder. This removes all
+    gems that aren't currently referenced by the Gemfile.lock.
+  DESC
+
+  task :clean do
+    bundle_cmd = fetch(:bundle_cmd, "bundle")
+
+    run "cd #{current_path} && #{bundle_cmd} clean"
+  end
+end

data/lib/minestrone/recipes/deploy/dependencies.rb

@@ -0,0 +1,44 @@
+require 'minestrone/recipes/deploy/local_dependency'
+require 'minestrone/recipes/deploy/remote_dependency'
+
+module Minestrone
+  module Deploy
+    class Dependencies
+      include Enumerable
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @dependencies = []
+        yield self if block_given?
+      end
+
+      def check
+        yield self
+        self
+      end
+
+      def remote
+        dep = RemoteDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def local
+        dep = LocalDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def each
+        @dependencies.each { |d| yield d }
+        self
+      end
+
+      def pass?
+        all? { |d| d.pass? }
+      end
+    end
+  end
+end

data/lib/minestrone/recipes/deploy/local_dependency.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Minestrone
+  module Deploy
+    class LocalDependency
+      attr_reader :configuration
+      attr_reader :message
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+      end
+
+      def command(command)
+        @message ||= "`#{command}' could not be found in the path on the local host"
+        @success = find_in_path(command)
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+      private
+
+      # Searches the path, looking for the given utility. If an executable
+      # file is found that matches the parameter, this returns true.
+      def find_in_path(utility)
+        path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+
+        path.each do |dir|
+          file = File.join(dir, utility)
+          return true if File.executable?(file)
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/minestrone/recipes/deploy/remote_dependency.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'minestrone/errors'
+
+module Minestrone
+  module Deploy
+    class RemoteDependency
+      attr_reader :configuration
+      attr_reader :hosts
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+        @hosts = nil
+      end
+
+      def directory(path, options = {})
+        @message ||= "`#{path}' is not a directory"
+        try("test -d #{path}", options)
+        self
+      end
+
+      def file(path, options = {})
+        @message ||= "`#{path}' is not a file"
+        try("test -f #{path}", options)
+        self
+      end
+
+      def writable(path, options = {})
+        @message ||= "`#{path}' is not writable"
+        try("test -w #{path}", options)
+        self
+      end
+
+      def command(command, options = {})
+        @message ||= "`#{command}' could not be found in the path"
+        try("which #{command}", options)
+        self
+      end
+
+      def gem(name, version, options = {})
+        @message ||= "gem `#{name}' #{version} could not be found"
+        gem_cmd = configuration.fetch(:gem_command, "gem")
+        try("#{gem_cmd} specification --version '#{version}' #{name} 2>&1 | awk 'BEGIN { s = 0 } /^name:/ { s = 1; exit }; END { if(s == 0) exit 1 }'", options)
+        self
+      end
+
+      def deb(name, version, options = {})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("dpkg -s #{name} | grep '^Version: #{version}'", options)
+        self
+      end
+
+      def rpm(name, version, options = {})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("rpm -q #{name} | grep '#{version}'", options)
+        self
+      end
+
+      def match(command, expect, options = {})
+        expect = Regexp.new(Regexp.escape(expect.to_s)) unless expect.is_a?(Regexp)
+
+        output_per_server = {}
+        try("#{command} ", options) do |ch, stream, out|
+          output_per_server[ch[:server]] ||= ''
+          output_per_server[ch[:server]] += out
+        end
+
+        # It is possible for some of these commands to return a status != 0
+        # (for example, rake --version exits with a 1). For this check we
+        # just care if the output matches, so we reset the success flag.
+        @success = true
+
+        errored_hosts = []
+        output_per_server.each_pair do |server, output|
+          next if output =~ expect
+          errored_hosts << server
+        end
+
+        if errored_hosts.any?
+          @hosts = errored_hosts.join(', ')
+          output = output_per_server[errored_hosts.first]
+          @message = "the output #{output.inspect} from #{command.inspect} did not match #{expect.inspect}"
+          @success = false
+        end
+
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+      def message
+        s = @message.dup
+        s << " (#{@hosts})" if @hosts
+        s
+      end
+
+      private
+
+      def try(command, options)
+        return unless @success # short-circuit evaluation
+        configuration.invoke_command(command, options) do |ch,stream,out|
+          warn "#{ch[:server]}: #{out}" if stream == :err
+          yield ch, stream, out if block_given?
+        end
+      rescue Minestrone::CommandError => e
+        @success = false
+        @hosts = e.host.to_s
+      end
+    end
+  end
+end

data/lib/minestrone/recipes/deploy/scm/base.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Minestrone
+  module Deploy
+    module SCM
+
+      # The ancestor class for all Minestrone SCM implementations. It provides
+      # minimal infrastructure for subclasses to build upon and override.
+      #
+      # Note that subclasses that implement this abstract class only return
+      # the commands that need to be executed--they do not execute the commands
+      # themselves. In this way, the deployment method may execute the commands
+      # either locally or remotely, as necessary.
+
+      class Base
+        class << self
+          # If no parameters are given, it returns the current configured
+          # name of the command-line utility of this SCM. If a parameter is
+          # given, the defeault command is set to that value.
+          def default_command(value = nil)
+            if value
+              @default_command = value
+            else
+              @default_command
+            end
+          end
+        end
+
+        # Wraps an SCM instance and forces all messages sent to it to be
+        # relayed to the underlying SCM instance, in "local" mode. See
+        # Base#local.
+        class LocalProxy
+          def initialize(scm)
+            @scm = scm
+          end
+
+          def method_missing(sym, *args, &block)
+            @scm.local { return @scm.send(sym, *args, &block) }
+          end
+        end
+
+        # The options available for this SCM instance to reference. Should be
+        # treated like a hash.
+        attr_reader :configuration
+
+        # Creates a new SCM instance with the given configuration options.
+        def initialize(configuration = {})
+          @configuration = configuration
+        end
+
+        # Returns a proxy that wraps the SCM instance and forces it to operate
+        # in "local" mode, which changes how variables are looked up in the
+        # configuration. Normally, if the value of a variable "foo" is needed,
+        # it is queried for in the configuration as "foo". However, in "local"
+        # mode, first "local_foo" would be looked for, and only if it is not
+        # found would "foo" be used. This allows for both (e.g.) "scm_command"
+        # and "local_scm_command" to be set, if the two differ.
+        #
+        # Alternatively, it may be called with a block, and for the duration of
+        # the block, all requests on this configuration object will be
+        # considered local.
+        def local
+          if block_given?
+            begin
+              saved, @local_mode = @local_mode, true
+              yield
+            ensure
+              @local_mode = saved
+            end
+          else
+            LocalProxy.new(self)
+          end
+        end
+
+        # Returns true if running in "local" mode. See #local.
+        def local?
+          @local_mode
+        end
+
+        # Returns the string used to identify the latest revision in the
+        # repository. This will be passed as the "revision" parameter of
+        # the methods below.
+        def head
+          raise NotImplementedError, "`head' is not implemented by #{self.class.name}"
+        end
+
+        # Checkout a copy of the repository, at the given +revision+, to the
+        # given +destination+. The checkout is suitable for doing development
+        # work in, e.g. allowing subsequent commits and updates.
+        def checkout(revision, destination)
+          raise NotImplementedError, "`checkout' is not implemented by #{self.class.name}"
+        end
+
+        # Resynchronize the working copy in +destination+ to the specified
+        # +revision+.
+        def sync(revision, destination)
+          raise NotImplementedError, "`sync' is not implemented by #{self.class.name}"
+        end
+
+        # Compute the difference between the two revisions, +from+ and +to+.
+        def diff(from, to = nil)
+          raise NotImplementedError, "`diff' is not implemented by #{self.class.name}"
+        end
+
+        # Return a log of all changes between the two specified revisions,
+        # +from+ and +to+, inclusive.
+        def log(from, to = nil)
+          raise NotImplementedError, "`log' is not implemented by #{self.class.name}"
+        end
+
+        # If the given revision represents a "real" revision, this should
+        # simply return the revision value. If it represends a pseudo-revision
+        # (like Subversions "HEAD" identifier), it should yield a string
+        # containing the commands that, when executed will return a string
+        # that this method can then extract the real revision from.
+        def query_revision(revision)
+          raise NotImplementedError, "`query_revision' is not implemented by #{self.class.name}"
+        end
+
+        # Returns the revision number immediately following revision, if at
+        # all possible. A block should always be passed to this method, which
+        # accepts a command to invoke and returns the result, although a
+        # particular SCM's implementation is not required to invoke the block.
+        #
+        # By default, this method simply returns the revision itself. If a
+        # particular SCM is able to determine a subsequent revision given a
+        # revision identifier, it should override this method.
+        def next_revision(revision)
+          revision
+        end
+
+        # Should analyze the given text and determine whether or not a
+        # response is expected, and if so, return the appropriate response.
+        # If no response is expected, return nil. The +state+ parameter is a
+        # hash that may be used to preserve state between calls. This method
+        # is used to define how Minestrone should respond to common prompts
+        # and messages from the SCM, like password prompts and such. By
+        # default, the output is simply displayed.
+        def handle_data(state, stream, text)
+          logger.info "[#{stream}] #{text}"
+          nil
+        end
+
+        # Returns the name of the command-line utility for this SCM. It first
+        # looks at the :scm_command variable, and if it does not exist, it
+        # then falls back to whatever was defined by +default_command+.
+        #
+        # If scm_command is set to :default, the default_command will be
+        # returned.
+        def command
+          command = variable(:scm_command)
+          command = nil if command == :default
+          command || default_command
+        end
+
+        # A helper method that can be used to define SCM commands naturally.
+        # It returns a single string with all arguments joined by spaces,
+        # with the scm command prefixed onto it.
+        def scm(*args)
+          [command, *args].compact.join(" ")
+        end
+
+        private
+
+        # A helper for accessing variable values, which takes into
+        # consideration the current mode ("normal" vs. "local").
+        def variable(name, default = nil)
+          if local? && configuration.exists?("local_#{name}".to_sym)
+            return configuration["local_#{name}".to_sym].nil? ? default : configuration["local_#{name}".to_sym]
+          else
+            configuration[name].nil? ? default : configuration[name]
+          end
+        end
+
+        # A reference to a Logger instance that the SCM can use to log
+        # activity.
+        def logger
+          @logger ||= variable(:logger) || Minestrone::Logger.new(:output => STDOUT)
+        end
+
+        # A helper for accessing the default command name for this SCM. It
+        # simply delegates to the class' +default_command+ method.
+        def default_command
+          self.class.default_command
+        end
+
+        # A convenience method for accessing the declared repository value.
+        def repository
+          variable(:repository)
+        end
+
+        def arguments(command = :all)
+          value = variable(:scm_arguments)
+
+          if value.is_a?(Hash)
+            value = value[command]
+          end
+
+          value
+        end
+      end
+    end
+  end
+end