minestrone 0.0.1

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'minestrone/recipes/deploy/scm/base'
+
+module Minestrone
+  module Deploy
+    module SCM
+
+      # An SCM module for using Git as your source control tool.
+      #
+      # Assumes you are using a shared Git repository.
+      #
+      # Parts of this plugin borrowed from Scott Chacon's version, which I
+      # found on the Minestrone mailing list but failed to be able to get
+      # working.
+      #
+      # FEATURES:
+      #
+      #   * Very simple, only requiring 2 lines in your deploy.rb.
+      #   * Can deploy different branches, tags, or any SHA1 easily.
+      #   * Supports prompting for password / passphrase upon checkout.
+      #     (I am amazed at how some plugins don't do this)
+      #   * Supports :scm_command, :scm_passphrase Minestrone directives.
+      #
+      # CONFIGURATION
+      # -------------
+      #
+      # Use this plugin by adding the following line in your config/deploy.rb:
+      #
+      #   set :scm, :git
+      #
+      # Set <tt>:repository</tt> to the path of your Git repo:
+      #
+      #   set :repository, "someuser@somehost:/home/myproject"
+      #
+      # The above two options are required to be set, the ones below are
+      # optional.
+      #
+      # You may set <tt>:branch</tt>, which is the reference to the branch, tag,
+      # or any SHA1 you are deploying, for example:
+      #
+      #   set :branch, "master"
+      #
+      # Otherwise, HEAD is assumed.  I strongly suggest you set this.  HEAD is
+      # not always the best assumption.
+      #
+      # You may also set <tt>:remote</tt>, which will be used as a name for remote
+      # tracking of repositories. This option is intended for use with the
+      # <tt>:remote_cache</tt> strategy in a distributed git environment.
+      #
+      # For example in the projects <tt>config/deploy.rb</tt>:
+      #
+      #   set :repository, "#{scm_user}@somehost:~/projects/project.git"
+      #   set :remote, "#{scm_user}"
+      #
+      # Then each person with deploy priveledges can add the following to their
+      # local <tt>~/.caprc</tt> file:
+      #
+      #   set :scm_user, 'someuser'
+      #
+      # Now any time a person deploys the project, their repository will be
+      # setup as a remote git repository within the cached repository.
+      #
+      # The <tt>:scm_command</tt> configuration variable, if specified, will
+      # be used as the full path to the git executable on the *remote* machine:
+      #
+      #   set :scm_command, "/opt/local/bin/git"
+      #
+      # <tt>:scm_passphrase</tt> is supported for the public key passphrase.
+      #
+      # The remote cache strategy is also supported.
+      #
+      #   set :repository_cache, "git_master"
+      #   set :deploy_via, :remote_cache
+      #
+      # For faster clone, you can also use shallow cloning.  This will set the
+      # '--depth' flag using the depth specified.  This *cannot* be used
+      # together with the :remote_cache strategy
+      #
+      #   set :git_shallow_clone, 1
+      #
+      # To deploy from a local repository:
+      #
+      #   set :repository, "file://."
+      #   set :deploy_via, :copy
+      #
+      # AUTHORS
+      # -------
+      #
+      # Garry Dolley http://scie.nti.st
+      # Contributions by Geoffrey Grosenbach http://topfunky.com
+      #              Scott Chacon http://jointheconversation.org
+      #                          Alex Arnell http://twologic.com
+      #                                   and Phillip Goldenburg
+
+      class Git < Base
+        # Sets the default command name for this SCM on your *local* machine.
+        # Users may override this by setting the :scm_command variable.
+        default_command "git"
+
+        # When referencing "head", use the branch we want to deploy or, by
+        # default, Git's reference of HEAD (the latest changeset in the default
+        # branch, usually called "master").
+        def head
+          variable(:branch) || 'HEAD'
+        end
+
+        def origin
+          variable(:remote) || 'origin'
+        end
+
+        # Performs a clone on the remote machine, then checkout on the branch
+        # you want to deploy.
+        def checkout(revision, destination)
+          git    = command
+          remote = origin
+
+          args = []
+
+          # Add an option for the branch name so :git_shallow_clone works with branches
+          args << "-b #{variable(:branch)}" unless variable(:branch).nil? || variable(:branch) == revision
+          args << "-o #{remote}" unless remote == 'origin'
+
+          if depth = variable(:git_shallow_clone)
+            args << "--depth #{depth}"
+          end
+
+          execute = []
+          execute << "#{git} clone #{verbose} #{args.join(' ')} #{variable(:repository)} #{destination}"
+
+          # checkout into a local branch rather than a detached HEAD
+          execute << "cd #{destination} && #{git} checkout #{verbose} -b deploy #{revision}"
+
+          if variable(:git_enable_submodules)
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} sync"
+
+            if variable(:git_submodules_recursive) == false
+              execute << "#{git} submodule #{verbose} update --init"
+            else
+              execute << %Q(export GIT_RECURSIVE=$([ ! "`#{git} --version`" \\< "git version 1.6.5" ] && echo --recursive))
+              execute << "#{git} submodule #{verbose} update --init $GIT_RECURSIVE"
+            end
+          end
+
+          execute.compact.join(" && ").gsub(/\s+/, ' ')
+        end
+
+        # An expensive export. Performs a checkout as above, then
+        # removes the repo.
+        def export(revision, destination)
+          checkout(revision, destination) << " && rm -Rf #{destination}/.git"
+        end
+
+        # Merges the changes to 'head' since the last fetch, for remote_cache
+        # deployment strategy
+        def sync(revision, destination)
+          git     = command
+          remote  = origin
+
+          execute = []
+          execute << "cd #{destination}"
+
+          # Use git-config to setup a remote tracking branches. Could use
+          # git-remote but it complains when a remote of the same name already
+          # exists, git-config will just silenty overwrite the setting every
+          # time. This could cause wierd-ness in the remote cache if the url
+          # changes between calls, but as long as the repositories are all
+          # based from each other it should still work fine.
+
+          if remote != 'origin'
+            execute << "#{git} config remote.#{remote}.url #{variable(:repository)}"
+            execute << "#{git} config remote.#{remote}.fetch +refs/heads/*:refs/remotes/#{remote}/*"
+          end
+
+          # since we're in a local branch already, just reset to specified revision rather than merge
+          execute << "#{git} fetch #{verbose} #{remote} && #{git} fetch --tags #{verbose} #{remote} && #{git} reset #{verbose} --hard #{revision}"
+
+          if variable(:git_enable_submodules)
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} sync"
+
+            if variable(:git_submodules_recursive) == false
+              execute << "#{git} submodule #{verbose} update --init"
+            else
+              execute << %Q(export GIT_RECURSIVE=$([ ! "`#{git} --version`" \\< "git version 1.6.5" ] && echo --recursive))
+              execute << "#{git} submodule #{verbose} update --init $GIT_RECURSIVE"
+            end
+          end
+
+          # Make sure there's nothing else lying around in the repository (for
+          # example, a submodule that has subsequently been removed).
+          execute << "#{git} clean #{verbose} -d -x -f"
+
+          execute.join(" && ")
+        end
+
+        # Returns a string of diffs between two revisions
+        def diff(from, to = nil)
+          if to
+            scm :diff, "#{from}..#{to}"
+          else
+            scm :diff, from
+          end
+        end
+
+        # Returns a log of changes between the two revisions (inclusive).
+        def log(from, to = nil)
+          scm :log, "#{from}..#{to}"
+        end
+
+        # Getting the actual commit id, in case we were passed a tag
+        # or partial sha or something - it will return the sha if you pass a sha, too
+        def query_revision(revision)
+          raise ArgumentError, "Deploying remote branches is no longer supported.  Specify the remote branch as a local branch for the git repository you're deploying from (ie: '#{revision.gsub('origin/', '')}' rather than '#{revision}')." if revision =~ /^origin\//
+
+          return revision if revision =~ /^[0-9a-f]{40}$/
+
+          command = scm('ls-remote', repository, revision)
+          result = yield(command)
+          revdata = result.split(/[\t\n]/)
+          newrev = nil
+
+          revdata.each_slice(2) do |refs|
+            rev, ref = *refs
+            if ref.sub(/refs\/.*?\//, '').strip == revision.to_s
+              newrev = rev
+              break
+            end
+          end
+
+          return newrev if newrev =~ /^[0-9a-f]{40}$/
+
+          # If sha is not found on remote, try expanding from local repository
+          command = scm('rev-parse --revs-only', origin + '/' + revision)
+          newrev = yield(command).to_s.strip
+
+          # fallback for expected legacy default functionality
+          unless newrev =~ /^[0-9a-f]{40}$/
+            command = scm('rev-parse --revs-only', revision)
+            newrev = yield(command).to_s.strip
+          end
+
+          raise "Unable to resolve revision for '#{revision}' on repository '#{repository}'." unless newrev =~ /^[0-9a-f]{40}$/
+          return newrev
+        end
+
+        # Determines what the response should be for a particular bit of text
+        # from the SCM. Password prompts, connection requests, passphrases,
+        # etc. are handled here.
+        def handle_data(state, stream, text)
+          host = state[:channel][:host]
+          logger.info "[#{host} :: #{stream}] #{text}"
+          case text
+          when /\bpassword.*:/i
+            # git is prompting for a password
+            pass = Minestrone::CLI.password_prompt
+            %("#{pass}"\n)
+          when %r{\(yes/no\)}
+            # git is asking whether or not to connect
+            "yes\n"
+          when /passphrase/i
+            # git is asking for the passphrase for the user's key
+            unless pass = variable(:scm_passphrase)
+              pass = Minestrone::CLI.password_prompt
+            end
+            %("#{pass}"\n)
+          when /accept \(t\)emporarily/
+            # git is asking whether to accept the certificate
+            "t\n"
+          end
+        end
+
+        private
+
+        # If verbose output is requested, return nil, otherwise return the
+        # command-line switch for "quiet" ("-q").
+        def verbose
+          variable(:scm_verbose) ? nil : "-q"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'minestrone/recipes/deploy/scm/base'
+
+module Minestrone
+  module Deploy
+    module SCM
+
+      # A trivial SCM wrapper for representing the current working directory
+      # as a repository. Obviously, not all operations are available for this
+      # SCM, but it works sufficiently for use with the "copy" deployment
+      # strategy.
+      #
+      # Use of this module is _not_ recommended; in general, it is good
+      # practice to use some kind of source code management even for anything
+      # you are wanting to deploy. However, this module is provided in
+      # acknowledgement of the cases where trivial deployment of your current
+      # working directory is desired.
+      #
+      #   set :repository, "."
+      #   set :scm, :none
+      #   set :deploy_via, :copy
+      #
+      #   Dereference symbolic links. Copy files instead. Handy when you
+      #   reference files and directory outside of your deployment root.
+      #   set :copy_dereference_symlink, true
+
+      class None < Base
+
+        # No versioning, thus, no head. Returns the empty string.
+        def head
+          ""
+        end
+
+        # Simply does a copy from the :repository directory to the :destination directory.
+        def checkout(revision, destination)
+          "cp -R#{configuration[:copy_dereference_symlink] ? 'L' : ''} #{repository} #{destination}"
+        end
+
+        alias_method :export, :checkout
+
+        # No versioning, so this just returns the argument, with no modification.
+        def query_revision(revision)
+          revision
+        end
+
+        # log: There's no log, so it just echos from and to.
+        def log(from = "", to = "")
+          "No SCM: #{from} - #{to}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Minestrone
+  module Deploy
+    module SCM
+      def self.new(scm, config = {})
+        scm_file = "minestrone/recipes/deploy/scm/#{scm}"
+        require(scm_file)
+
+        scm_const = scm.to_s.capitalize.gsub(/_(.)/) { $1.upcase }
+
+        if const_defined?(scm_const)
+          const_get(scm_const).new(config)
+        else
+          raise Minestrone::Error, "could not find `#{name}::#{scm_const}' in `#{scm_file}'"
+        end
+      rescue LoadError
+        raise Minestrone::Error, "could not find any SCM named `#{scm}'"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'minestrone/recipes/deploy/dependencies'
+
+module Minestrone
+  module Deploy
+    module Strategy
+
+      # This class defines the abstract interface for all Minestrone
+      # deployment strategies. Subclasses must implement at least the
+      # #deploy! method.
+
+      class Base
+        attr_reader :configuration
+
+        # Instantiates a strategy with a reference to the given configuration.
+        def initialize(config = {})
+          @configuration = config
+        end
+
+        # Executes the necessary commands to deploy the revision of the source
+        # code identified by the +revision+ variable. Additionally, this
+        # should write the value of the +revision+ variable to a file called
+        # REVISION, in the base of the deployed revision. This file is used by
+        # other tasks, to perform diffs and such.
+
+        def deploy!
+          raise NotImplementedError, "`deploy!' is not implemented by #{self.class.name}"
+        end
+
+        # Performs a check on the remote hosts to determine whether everything
+        # is setup such that a deploy could succeed.
+
+        def check!
+          Dependencies.new(configuration) do |d|
+            d.remote.directory(configuration[:releases_path])
+              .or("`#{configuration[:releases_path]}' does not exist. Please run `min deploy:setup'.")
+            d.remote.writable(configuration[:deploy_to])
+              .or("You do not have permissions to write to `#{configuration[:deploy_to]}'.")
+            d.remote.writable(configuration[:releases_path])
+              .or("You do not have permissions to write to `#{configuration[:releases_path]}'.")
+          end
+        end
+
+
+        protected
+
+        # This is to allow helper methods like "run" and "put" to be more
+        # easily accessible to strategy implementations.
+        def method_missing(sym, *args, &block)
+          if configuration.respond_to?(sym)
+            configuration.send(sym, *args, &block)
+          else
+            super
+          end
+        end
+
+        # A wrapper for Kernel#system that logs the command being executed.
+        def system(*args)
+          cmd = args.join(' ')
+          result = nil
+          logger.trace "executing locally: #{cmd}"
+
+          elapsed = Benchmark.realtime do
+            result = super
+          end
+
+          logger.trace "command finished in #{(elapsed * 1000).round}ms"
+          result
+        end
+
+
+        private
+
+        def logger
+          @logger ||= configuration.logger || Minestrone::Logger.new(:output => STDOUT)
+        end
+
+        # The revision to deploy. Must return a real revision identifier, and not a pseudo-id.
+        def revision
+          configuration[:real_revision]
+        end
+      end
+    end
+  end
+end