switchtower 0.10.0 → 1.0.0

data/lib/switchtower/scm/base.rb

@@ -53,8 +53,8 @@ module SwitchTower
         def logging_commands(directory = nil)
           log = "#{configuration.deploy_to}/revisions.log"
 
-          "echo `date +\"%Y-%m-%d %H:%M:%S\"` $USER #{configuration.revision} #{directory} >> #{log} && " +
-          "chmod 666 #{log};"
+          "(test -e #{log} || touch #{log} && chmod 666 #{log}) && " +
+          "echo `date +\"%Y-%m-%d %H:%M:%S\"` $USER #{configuration.revision} #{directory} >> #{log};"
         end
     end
 

data/lib/switchtower/scm/baz.rb

@@ -0,0 +1,118 @@
+require 'switchtower/scm/base'
+
+module SwitchTower
+  module SCM
+
+    # An SCM module for using Bazaar as your source control tool. This
+    # module is used by default, but you can explicitly specify it by
+    # placing the following line in your configuration:
+    #
+    #   set :scm, :baz
+    #
+    # Also, this module accepts a <tt>:baz</tt> configuration variable,
+    # which (if specified) will be used as the full path to the svn
+    # executable on the remote machine:
+    #
+    #   set :baz, "/opt/local/bin/baz"
+    #
+    # Set the version you wish to deploy as the repository variable, 
+    # for example:
+    #
+    #   set :repository, "you@example.com--dev/yourstuff--trunk--1.0"
+    #
+    # Ensure that you have already registered the archive on the target
+    # machines.
+    #
+    # As bazaar keeps a great deal of extra information on a checkout,
+    # you will probably want to use export instead:
+    #
+    #   set :checkout, "export"
+    #
+    # TODO: provide setup recipe to register archive
+    class Baz < Base
+      # Return an integer identifying the last known revision in the baz
+      # repository. (This integer is currently the revision number.)
+      def latest_revision
+        `#{baz} revisions #{configuration.repository}`.split.last =~ /\-(\d+)$/
+        $1
+      end
+
+      # Return the number of the revision currently deployed.
+      def current_revision(actor)
+        latest = actor.releases.last
+        grep = %(grep " #{latest}$" #{configuration.deploy_to}/revisions.log)
+        result = ""
+        actor.run(grep, :once => true) do |ch, str, out|
+          result << out if str == :out
+          raise "could not determine current revision" if str == :err
+        end
+
+        date, time, user, rev, dir = result.split
+        raise "current revision not found in revisions.log" unless dir == latest
+        rev.to_i
+      end
+
+      # Return a string containing the diff between the two revisions. +from+
+      # and +to+ may be in any format that bzr recognizes as a valid revision
+      # identifier. If +from+ is +nil+, it defaults to the last deployed
+      # revision. If +to+ is +nil+, it defaults to the last developed revision.
+      def diff(actor, from=nil, to=nil)
+        from ||= current_revision(actor)
+        to ||= latest_revision
+        from = baz_revision_name(from)
+        to = baz_revision_name(to)
+        `#{baz} delta --diffs -A #{baz_archive} #{baz_version}--#{from} #{baz_version}--#{to}`
+      end
+
+      # Check out (on all servers associated with the current task) the latest
+      # revision. Uses the given actor instance to execute the command.
+      def checkout(actor)
+        op = configuration[:checkout] || "get"
+        from = baz_revision_name(configuration.revision)
+        command = "#{baz} #{op} #{configuration.repository}--#{from} #{actor.release_path} &&"
+        run_checkout(actor, command, &baz_stream_handler(actor)) 
+      end
+
+      def update(actor)
+        command = "cd #{actor.current_path} && #{baz} update &&"
+        run_update(actor, command, &baz_stream_handler(actor)) 
+      end
+
+      private
+        def baz
+          configuration[:baz] || "baz"
+        end
+
+        def baz_revision_name(number)
+          if number.to_i == 0 then
+            "base-0"
+          else
+            "patch-#{number}"
+          end
+        end
+
+        def baz_archive
+          configuration[:repository][/(.*)\//, 1]
+        end
+
+        def baz_version
+          configuration[:repository][/\/(.*)$/, 1]
+        end
+
+        def baz_stream_handler(actor)
+          Proc.new do |ch, stream, out|
+            prefix = "#{stream} :: #{ch[:host]}"
+            actor.logger.info out, prefix
+            if out =~ /\bpassword.*:/i
+              actor.logger.info "baz is asking for a password", prefix
+              ch.send_data "#{actor.password}\n"
+            elsif out =~ %r{passphrase}
+              message = "baz needs your key's passphrase, sending empty string"
+              actor.logger.info message, prefix
+              ch.send_data "\n"
+            end
+          end
+        end
+    end
+  end
+end

data/lib/switchtower/scm/bzr.rb

@@ -0,0 +1,70 @@
+require 'switchtower/scm/base'
+
+module SwitchTower
+  module SCM
+
+    # An SCM module for using Bazaar-NG (bzr) as your source control tool.
+    # You can use it by placing the following line in your configuration:
+    #
+    #   set :scm, :bzr
+    #
+    # Also, this module accepts a <tt>:bzr</tt> configuration variable,
+    # which (if specified) will be used as the full path to the bzr
+    # executable on the remote machine:
+    #
+    #   set :bzr, "/opt/local/bin/bzr"
+    class Bzr < Base
+      # Return an integer identifying the last known revision in the bzr
+      # repository. (This integer is currently the revision number.) 
+      def latest_revision
+        `#{bzr} revno #{configuration.repository}`.to_i
+      end
+
+      # Return the number of the revision currently deployed.
+      def current_revision(actor)
+        command = "#{bzr} revno #{actor.release_path} &&"        
+        run_update(actor, command, &bzr_stream_handler(actor)) 
+      end
+
+      # Return a string containing the diff between the two revisions. +from+
+      # and +to+ may be in any format that bzr recognizes as a valid revision
+      # identifier. If +from+ is +nil+, it defaults to the last deployed
+      # revision. If +to+ is +nil+, it defaults to the last developed revision.
+      # Pay attention to the fact that as of now bzr does NOT support
+      # diff on remote locations.
+      def diff(actor, from=nil, to=nil)
+        from ||= current_revision(actor)
+        to ||= ""
+        `#{bzr} diff -r #{from}..#{to} #{configuration.repository}`
+      end
+
+      # Check out (on all servers associated with the current task) the latest
+      # revision. Uses the given actor instance to execute the command. If
+      # bzr asks for a password this will automatically provide it (assuming
+      # the requested password is the same as the password for logging into the
+      # remote server.)
+      def checkout(actor)
+        op = configuration[:checkout] || "branch"
+        command = "#{bzr} #{op} -r#{configuration.revision} #{configuration.repository} #{actor.release_path} &&"
+        run_checkout(actor, command, &bzr_stream_handler(actor)) 
+      end
+
+      def update(actor)
+        command = "cd #{actor.current_path} && #{bzr} pull -q &&"
+        run_update(actor, command, &bzr_stream_handler(actor)) 
+      end
+      
+      private
+        def bzr
+          configuration[:bzr] || "bzr"
+        end
+
+        def bzr_stream_handler(actor)
+          Proc.new do |ch, stream, out|
+            prefix = "#{stream} :: #{ch[:host]}"
+            actor.logger.info out, prefix
+          end
+        end
+    end
+  end
+end

data/lib/switchtower/scm/cvs.rb

@@ -19,10 +19,27 @@ module SwitchTower
     # the revisions, etc.) via the <tt>:local</tt> variable, which defaults to
     # ".".
     #
+    # You may also specify a <tt>:branch</tt> configuration variable,
+    # which (if specified) will be used in the '-r' option to the cvs
+    # check out command.  If it is not set, the module will determine if a
+    # branch is being used in the CVS sandbox relative to
+    # <tt>:local</tt> and act accordingly.   
+    #
+    #   set :branch, "prod-20060124"
+    #
     # Also, you can specify the CVS_RSH variable to use on the remote machine(s)
     # via the <tt>:cvs_rsh</tt> variable. This defaults to the value of the
     # CVS_RSH environment variable locally, or if it is not set, to "ssh".
     class Cvs < Base
+      def initialize(configuration)
+        super(configuration)
+        if not configuration.respond_to?(:branch) then
+          configuration.set(:branch) { self.current_branch }
+        else
+          @current_branch = configuration[:branch]
+        end
+     end
+
       # Return a string representing the date of the last revision (CVS is
       # seriously retarded, in that it does not give you a way to query when
       # the last revision was made to the repository, so this is a fairly
@@ -30,22 +47,37 @@ module SwitchTower
       def latest_revision
         return @latest_revision if @latest_revision
         configuration.logger.debug "querying latest revision..."
-        @latest_revision = cvs_log(configuration.local).
+        @latest_revision = cvs_log(cvs_local, configuration.branch).
           split(/\r?\n/).
-          grep(/^date: (.*?);/) { Time.parse($1).strftime("%F %T") }.
+          grep(/^date: (.*?);/) { Time.parse($1).strftime("%Y-%m-%d %H:%M:%S") }.
           sort.
           last
       end
 
+      # Return a string representing the branch that the sandbox
+      # relative to <tt>:local</tt> contains.
+      def current_branch 
+        return @current_branch if @current_branch
+        configuration.logger.debug "determining current_branch..."
+        @current_branch = cvs_branch(cvs_local)
+      end
+
       # Check out (on all servers associated with the current task) the latest
-      # revision. Uses the given actor instance to execute the command.
+      # revision, using a branch if necessary. Uses the given actor instance 
+      # to execute the command.
       def checkout(actor)
         cvs = configuration[:cvs] || "cvs"
         cvs_rsh = configuration[:cvs_rsh] || ENV['CVS_RSH'] || "ssh"
 
+        if "HEAD" == configuration.branch then
+            branch_option = ""
+        else
+            branch_option = "-r #{configuration.branch}"
+        end
+
         command = <<-CMD
           cd #{configuration.releases_path};
-          CVS_RSH="#{cvs_rsh}" #{cvs} -d #{configuration.repository} -Q co -D "#{configuration.revision}" -d #{File.basename(actor.release_path)} #{actor.application};
+          CVS_RSH="#{cvs_rsh}" #{cvs} -d #{configuration.repository} -Q co -D "#{configuration.revision}" #{branch_option} -d #{File.basename(actor.release_path)} #{actor.application};
         CMD
 
         run_checkout(actor, command) do |ch, stream, out|
@@ -64,8 +96,27 @@ module SwitchTower
 
       private
 
-        def cvs_log(path)
-          `cd #{path || "."} && cvs -q log -N -rHEAD`
+        # Look for a 'CVS/Tag' file in the path.  If this file exists
+        # and contains a Line starting with 'T' then this CVS sandbox is
+        # 'tagged' with a branch.  In the default case return 'HEAD'
+        def cvs_branch(path)
+          branch = "HEAD"
+          branch_file = File.join(path || ".", "CVS", "Tag")
+          if File.exists?(branch_file) then
+            File.open(branch_file) do |f|
+              possible_branch = f.find { |l| l =~ %r{^T} }
+              branch = possible_branch.strip[1..-1] if possible_branch
+            end
+          end
+          branch
+        end
+
+        def cvs_log(path,branch)
+          `cd #{path || "."} && cvs -q log -N -r#{branch}`
+        end
+
+        def cvs_local
+          configuration.local || "."
         end
     end
 

data/lib/switchtower/scm/perforce.rb

@@ -0,0 +1,139 @@
+require 'switchtower/scm/base'
+
+module SwitchTower
+  module SCM
+
+    # An SCM module for using perforce as your source control tool. 
+    # This module can explicitly selected by placing the following line 
+    # in your configuration:
+    #
+    #   set :scm, :perforce
+    #
+    # Also, this module accepts a <tt>:p4</tt> configuration variable,
+    # which (if specified) will be used as the full path to the p4
+    # executable on the remote machine:
+    #
+    #   set :p4, "/usr/local/bin/p4"
+    #
+    # This module accepts another <tt>:p4sync_flags</tt> configuration 
+    # variable, which (if specified) can add extra options. This setting
+    # defaults to the value "-f" which forces resynchronization.
+    #
+    #   set :p4sync_flags, "-f"        
+    #
+    # This module accepts another <tt>:p4client_root</tt> configuration 
+    # variable to handle mapping adjustments.  Perforce doesn't have the 
+    # ability to sync to a specific directory (e.g. the release_path); the
+    # location being synced to is defined by the client-spec. As such, we 
+    # sync the client-spec (defined by <tt>p4client</tt> and then copy from 
+    # the determined root of the client-spec mappings to the release_path.
+    # In the unlikely event that your client-spec mappings introduces 
+    # directory structure above the rails structure, you can override the
+    # may need to specify the directory
+    #
+    #   set :p4client_root, "/user/rmcmahon/project1/code"            
+    #
+    # Finally, the module accepts a <tt>p4diff2_options</tt> configuration
+    # variable. This can be used to manipulate the output when running a
+    # diff between what is deployed, and another revision. This option
+    # defaults to "-u". Run 'p4 help diff2' for other options.
+    #
+    class Perforce < Base
+
+      def latest_revision
+        configuration.logger.debug "querying latest revision..." unless @latest_revision
+        @latest_revision = `#{local_p4} counter change`.strip
+        @latest_revision
+      end
+      
+      # Return the number of the revision currently deployed.
+      def current_revision(actor)
+        latest = actor.releases.last
+        grep = %(grep " #{latest}$" #{configuration.deploy_to}/revisions.log)
+        result = ""
+        actor.run(grep, :once => true) do |ch, str, out|
+          result << out if str == :out
+          raise "could not determine current revision" if str == :err
+        end
+
+        date, time, user, rev, dir = result.split
+        raise "current revision not found in revisions.log" unless dir == latest
+        rev.to_i
+      end
+      
+      # Return a string containing the diff between the two revisions. +from+
+      # and +to+ may be in any format that p4 recognizes as a valid revision
+      # identifiers. If +from+ is +nil+, it defaults to the last deployed
+      # revision. If +to+ is +nil+, it defaults to #head.
+      def diff(actor, from=nil, to=nil)
+        from ||= "@#{current_revision(actor)}"
+        to ||= "#head"
+        p4client = configuration[:p4client]
+        p4diff2_options = configuration[:p4diff2_options]||"-u -db"
+        `#{local_p4} diff2 #{p4diff2_options} //#{p4client}/...#{from} //#{p4client}/...#{to}`
+      end      
+      
+      # Syncronizes (on all servers associated with the current task) the head
+      # revision of the code. Uses the given actor instance to execute the command. 
+      #
+      def checkout(actor)
+        p4sync_flags = configuration[:p4sync_flags] || "-f"
+        p4client_root = configuration[:p4client_root] || "`#{remote_p4} client -o | grep ^Root | cut -f2`"
+        command = "#{remote_p4} sync #{p4sync_flags} && cp -rf #{p4client_root} #{actor.release_path};"
+        run_checkout(actor, command, &p4_stream_handler(actor)) 
+      end
+
+      def update(actor)
+        raise "#{self.class} doesn't support update(actor)"
+      end
+
+      private
+
+        def local_p4	  
+          add_standard_p4_options('p4')
+        end
+
+        def remote_p4	  
+          p4_cmd = configuration[:p4] || 'p4'
+          add_standard_p4_options(p4_cmd)
+        end
+	
+        def add_standard_p4_options(p4_location)
+          check_settings
+          p4_cmd = p4_location	  
+          p4_cmd = "#{p4_cmd} -p #{configuration[:p4port]}" if configuration[:p4port]
+          p4_cmd = "#{p4_cmd} -u #{configuration[:p4user]}" if configuration[:p4user]
+          p4_cmd = "#{p4_cmd} -P #{configuration[:p4passwd]}" if configuration[:p4passwd]
+          p4_cmd = "#{p4_cmd} -c #{configuration[:p4client]}" if configuration[:p4client]
+          p4_cmd	
+        end
+
+        def check_settings
+          check_setting(:p4port, "Add set :p4port, <your perforce server details e.g. my.p4.server:1666> to deploy.rb")
+          check_setting(:p4user, "Add set :p4user, <your production build username> to deploy.rb")
+          check_setting(:p4passwd, "Add set :p4passwd, <your build user password> to deploy.rb")
+          check_setting(:p4client, "Add set :p4client, <your client-spec name> to deploy.rb")
+        end
+	
+        def check_setting(p4setting, message)
+          raise "#{p4setting} is not configured. #{message}" unless configuration[p4setting]
+        end
+	
+        def p4_stream_handler(actor)
+          Proc.new do |ch, stream, out|
+            prefix = "#{stream} :: #{ch[:host]}"
+            actor.logger.info out, prefix
+            if out =~ /\(P4PASSWD\) invalid or unset\./i
+	            raise "p4passwd is incorrect or unset"
+            elsif out =~ /Can.t create a new user.*/i
+	            raise "p4user is incorrect or unset"
+            elsif out =~ /Perforce client error\:/i	      
+	            raise "p4port is incorrect or unset"
+            elsif out =~ /Client \'[\w\-\_\.]+\' unknown.*/i
+	            raise "p4client is incorrect or unset"
+            end	    
+          end
+        end	
+    end
+  end
+end

data/lib/switchtower/scm/subversion.rb

@@ -68,7 +68,8 @@ module SwitchTower
       # remote server.)
       def checkout(actor)
         op = configuration[:checkout] || "co"
-        command = "#{svn} #{op} -q -r#{configuration.revision} #{configuration.repository} #{actor.release_path} &&"
+        username = configuration[:svn_username] ? "--username #{configuration[:svn_username]}" : ""
+        command = "#{svn} #{op} #{username} -q -r#{configuration.revision} #{configuration.repository} #{actor.release_path} &&"
         run_checkout(actor, command, &svn_stream_handler(actor)) 
       end
 
@@ -88,14 +89,18 @@ module SwitchTower
         def svn_log(path)
           `svn log -q -rhead #{path}`
         end
-        
+
+        def svn_password
+          configuration[:svn_password] || configuration[:password]
+        end
+
         def svn_stream_handler(actor)
           Proc.new do |ch, stream, out|
             prefix = "#{stream} :: #{ch[:host]}"
             actor.logger.info out, prefix
             if out =~ /\bpassword.*:/i
               actor.logger.info "subversion is asking for a password", prefix
-              ch.send_data "#{actor.password}\n"
+              ch.send_data "#{svn_password}\n"
             elsif out =~ %r{\(yes/no\)}
               actor.logger.info "subversion is asking whether to connect or not",
                 prefix