fotonauts-capistrano 2.5.2

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

@@ -0,0 +1,44 @@
+require 'capistrano/recipes/deploy/local_dependency'
+require 'capistrano/recipes/deploy/remote_dependency'
+
+module Capistrano
+  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/capistrano/recipes/deploy/local_dependency.rb

@@ -0,0 +1,54 @@
+module Capistrano
+  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)
+        suffixes = self.class.on_windows? ? self.class.windows_executable_extensions : [""]
+
+        path.each do |dir|
+          suffixes.each do |sfx|
+            file = File.join(dir, utility + sfx)
+            return true if File.executable?(file)
+          end
+        end
+
+        false
+      end
+
+      def self.on_windows?
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def self.windows_executable_extensions
+        %w(.exe .bat .com .cmd)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'capistrano/errors'
+
+module Capistrano
+  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 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 Capistrano::CommandError => e
+        @success = false
+        @hosts = e.hosts.join(', ')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Capistrano
+  module Deploy
+    module SCM
+      def self.new(scm, config={})
+        scm_file = "capistrano/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 Capistrano::Error, "could not find `#{name}::#{scm_const}' in `#{scm_file}'"
+        end
+      rescue LoadError
+        raise Capistrano::Error, "could not find any SCM named `#{scm}'"
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/scm/accurev.rb

@@ -0,0 +1,169 @@
+require 'capistrano/recipes/deploy/scm/base'
+require 'rexml/xpath'
+require 'rexml/document'
+
+module Capistrano
+  module Deploy
+    module SCM
+      # Accurev bridge for use by Capistrano. This implementation does not
+      # implement all features of a Capistrano SCM module. The ones that are
+      # left out are either exceedingly difficult to implement with Accurev
+      # or are considered bad form.
+      #
+      # When using this module in a project, the following variables are used:
+      #  * :repository - This should match the depot that code lives in. If your code
+      #                  exists in a subdirectory, you can append the path depot.
+      #                  eg. foo-depot/bar_dir
+      #  * :stream - The stream in the depot that code should be pulled from. If 
+      #              left blank, the depot stream will be used
+      #  * :revision - Should be in the form 'stream/transaction'. 
+      class Accurev < Base
+        include REXML
+        default_command 'accurev'
+
+        # Defines pseudo-revision value for the most recent changes to be deployed.
+        def head
+          "#{stream}/highest"
+        end
+
+        # Given an Accurev revision identifier, this method returns an identifier that
+        # can be used for later SCM calls. This returned identifier will not
+        # change as a result of further SCM activity.
+        def query_revision(revision)
+          internal_revision = InternalRevision.parse(revision)
+          return revision unless internal_revision.psuedo_revision?
+
+          logger.debug("Querying for real revision for #{internal_revision}")
+          rev_stream = internal_revision.stream
+
+          logger.debug("Determining what type of stream #{rev_stream} is...")
+          stream_xml = yield show_streams_for(rev_stream)
+          stream_doc = Document.new(stream_xml)
+          type = XPath.first(stream_doc, '//streams/stream/@type').value
+
+          case type
+          when 'snapshot'
+            InternalRevision.new(rev_stream, 'highest').to_s
+          else
+            logger.debug("Getting latest transaction id in #{rev_stream}")
+            # Doing another yield for a second Accurev call. Hopefully this is ok.
+            hist_xml = yield scm(:hist, '-ftx', '-s', rev_stream, '-t', 'now.1')
+            hist_doc = Document.new(hist_xml)
+            transaction_id = XPath.first(hist_doc, '//AcResponse/transaction/@id').value
+            InternalRevision.new(stream, transaction_id).to_s
+          end
+        end
+
+        # Pops a copy of the code for the specified Accurev revision identifier. 
+        # The revision identifier is represented as a stream & transaction ID combo.
+        # Accurev can only pop a particular transaction if a stream is created on the server
+        # with a time basis of that transaction id. Therefore, we will create a stream with 
+        # the required criteria and pop that.
+        def export(revision_id, destination)
+          revision = InternalRevision.parse(revision_id)
+          logger.debug("Exporting #{revision.stream}/#{revision.transaction_id} to #{destination}")
+
+          commands = [
+            change_or_create_stream("#{revision.stream}-capistrano-deploy", revision),
+            "mkdir -p #{destination}",
+            scm_quiet(:pop, "-Rv #{stream}", "-L #{destination}", "'/./#{subdir}'")
+          ]
+          if subdir
+            commands.push(
+              "mv #{destination}/#{subdir}/* #{destination}",
+              "rm -rf #{File.join(destination, subdir)}"
+            )
+          end
+          commands.join(' && ')
+        end
+
+        # Returns the command needed to show the changes that exist between the two revisions.
+        def log(from, to=head)
+          logger.info("Getting transactions between #{from} and #{to}")
+          from_rev = InternalRevision.parse(from)
+          to_rev = InternalRevision.parse(to)
+
+          [
+            scm(:hist, '-s', from_rev.stream, '-t', "#{to_rev.transaction_id}-#{from_rev.transaction_id}"),
+            "sed -e '/transaction #{from_rev.transaction_id}/ { Q }'"
+          ].join(' | ')
+        end
+
+        # Returns the command needed to show the diff between what is deployed and what is 
+        # pending. Because Accurev can not do this task without creating some streams,
+        # two time basis streams will be created for the purposes of doing the diff.
+        def diff(from, to=head)
+          from = InternalRevision.parse(from)
+          to = InternalRevision.parse(to)
+
+          from_stream = "#{from.stream}-capistrano-diff-from"
+          to_stream = "#{to.stream}-capistrano-diff-to"
+
+          [
+            change_or_create_stream(from_stream, from),
+            change_or_create_stream(to_stream, to),
+            scm(:diff, '-v', from_stream, '-V', to_stream, '-a')
+          ].join(' && ')
+        end
+
+        private
+        def depot
+          repository.split('/')[0]
+        end
+
+        def stream
+          variable(:stream) || depot
+        end
+
+        def subdir
+          repository.split('/')[1..-1].join('/') unless repository.index('/').nil?
+        end
+
+        def change_or_create_stream(name, revision)
+          [
+            scm_quiet(:mkstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id),
+            scm_quiet(:chstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id)
+          ].join('; ')
+        end
+
+        def show_streams_for(stream)
+          scm :show, '-fx', '-s', stream, :streams
+        end
+
+        def scm_quiet(*args)
+          scm(*args) + (variable(:scm_verbose) ? '' : '&> /dev/null')
+        end
+
+        class InternalRevision
+          attr_reader :stream, :transaction_id
+
+          def self.parse(string)
+            match = /([^\/]+)(\/(.+)){0,1}/.match(string)
+            raise "Unrecognized revision identifier: #{string}" unless match
+
+            stream = match[1]
+            transaction_id = match[3] || 'highest'
+            InternalRevision.new(stream, transaction_id)
+          end
+
+          def initialize(stream, transaction_id)
+            @stream = stream
+            @transaction_id = transaction_id
+          end
+
+          def psuedo_revision?
+            @transaction_id == 'highest'
+          end
+
+          def to_s
+            "#{stream}/#{transaction_id}" 
+          end
+
+          def ==(other)
+            (stream == other.stream) && (transaction_id == other.transaction_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+module Capistrano
+  module Deploy
+    module SCM
+
+      # The ancestor class for all Capistrano 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 Capistrano 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)
+            if local? && configuration.exists?("local_#{name}".to_sym)
+              return configuration["local_#{name}".to_sym]
+            else
+              configuration[name]
+            end
+          end
+
+          # A reference to a Logger instance that the SCM can use to log
+          # activity.
+          def logger
+            @logger ||= variable(:logger) || Capistrano::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
+            variable(:scm_arguments)
+          end
+      end
+
+    end
+  end
+end