capistrano_deploy_lock 1.0.0 → 1.1.0

data/README.md

@@ -17,10 +17,11 @@ Add this line to your `config/deploy.rb`:
 
     require 'capistrano/deploy_lock'
 
+
 ## Usage
 
 Your deploys will now be protected by a lock. Simply run `cap deploy` as usual.
-However, if someone else trys to deploy at the same time, their deploy will abort
+However, if someone else tries to deploy at the same time, their deploy will abort
 with an error like this:
 
 ```
@@ -30,34 +31,39 @@ with an error like this:
 .../capistrano/deploy_lock.rb:132:in `block (3 levels) in <top (required)>': Capistrano::DeployLockedError (Capistrano::DeployLockedError)
 ```
 
-The default 'deploy' lock will expire after 15 minutes, assuming that your deploys will not take more time than this.
-This is so that crashed or interrupted deploys don't leave a stale lock for the next developer to deal with.
-This default expiry time can be configured with:
+The default deploy lock will expire after 15 minutes. This is so that crashed or interrupted deploys don't leave a stale lock behind.
 
-    set :default_lock_expiry, (20 * 60)   # Sets the default expiry to 20 minutes
+The following tasks will be run before deploy:
 
-Anyone can remove a lock by running:
+  * `deploy:check_lock`
+    * Checks for an existing deploy lock. Aborts deploy if a lock exists and it wasn't created by you.
+  * `deploy:refresh_lock`
+    * If you previously created a lock, this task ensures that your lock won't expire before the default expiry time
+  * `deploy:create_lock`
+    * If no locks already exist, a default lock will be created with the message: `Deploying <branch>`
 
-    cap deploy:unlock
+The following task will be run after deploy:
 
-The lock file will be created at `#{shared_path}/capistrano.lock.yml` by default. You can configure this with:
+  * `deploy:unlock`
+    * Removes any default deploy locks. If you set a custom lock, it will not be removed at this step.
+    * You can remove a custom deploy lock by running `cap deploy:unlock` by itself, or by chaining `deploy:unlock:force` at the end of the command.
 
-    set :deploy_lockfile, "path/to/deploy/lock/file"
 
+## Tasks
 
-## Manual locks
+### `deploy:with_lock`
 
-You can explicitly set a deploy lock by running:
+Deploy the latest revision with a custom deploy lock. This lock will not be removed at the end of the deploy.
 
-    cap deploy:lock
+### `deploy:lock`
 
-You will receive two prompts:
+Sets a custom deploy lock. You will receive two prompts for input:
 
-* Lock Message:
+* **Lock Message:**
 
 Type the reason for the lock. This message will be displayed to any developers who attempt to deploy.
 
-* Expire lock at? (optional):
+* **Expire lock at? (optional):**
 
 Set an expiry time for the lock. Leave this blank to make the lock last until someone removes it with `cap deploy:unlock`.
 
@@ -65,7 +71,36 @@ If the [chronic](https://github.com/mojombo/chronic) gem is available, you can t
 natural language times like `2 hours`, or `tomorrow at 6am`. If not, you must type times in a format that `DateTime.parse()` can handle,
 such as `06:30:00` or `2012-12-12 00:00:00`.
 
-The `cap deploy:check_lock` task will automatically delete any expired locks.
+### `deploy:unlock`
+
+Removes the deploy lock. Will not remove a custom deploy lock when it is chained after `deploy:lock`.
+
+### `deploy:unlock:force`
+
+Removes any deploy lock, even when chained after `deploy:lock`.
+
+### `deploy:check_lock`
+
+Check if server is locked. If the deploy lock was not created by you, an error will be raised and the deploy will abort.
+If the lock **was** created by you, the deploy will pause for 4 seconds, which gives you time to press `Ctrl+C` to cancel the deploy.
+
+This task is also responsible for deleting any expired locks.
+
+### `deploy:refresh_lock`
+
+Refreshes the current lock's expiry time if it is less than the default time.
+
+
+## Configuration
+
+If your deploys usually take longer than 15 minutes, you can configure the default expiry time with:
+
+    set :default_lock_expiry, (20 * 60)   # Sets the default expiry to 20 minutes
+
+The lock file will be created at `#{shared_path}/capistrano.lock.yml` by default. You can configure this with:
+
+    set :deploy_lockfile, "path/to/deploy/lock/file"
+
 
 ## Thanks
 

data/bin/cap_deploy_lock_msg

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+if ARGV.size != 3
+  puts "Usage: cap_deploy_lock_msg <application_name> <stage> <path/to/lock_file.yml>"
+else
+  $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+  require 'rubygems'
+  require 'yaml'
+  require 'capistrano/deploy_lock'
+
+  application, stage, lock_file = *ARGV
+  if File.exists?(lock_file)
+    deploy_lock = YAML.load_file(lock_file)
+
+    # Only show lock message if lock hasn't expired
+    if deploy_lock[:expire_at] && deploy_lock[:expire_at] > Time.now
+      puts Capistrano::DeployLock.message(application, stage, deploy_lock)
+      exit
+    end
+  end
+
+  puts "No deploy locks for #{application} (#{stage})"
+end

data/lib/capistrano/date_helper.rb

@@ -0,0 +1,7 @@
+module Capistrano
+  class DateHelper
+    class << self
+      include ActionView::Helpers::DateHelper
+    end
+  end
+end

data/lib/capistrano/deploy_lock.rb

@@ -9,130 +9,39 @@ begin; require 'chronic'; rescue LoadError; end
 begin
   # Use Rails distance_of_time_in_words_to_now helper if available
   require 'action_view'
-  module Capistrano
-    class DateHelper
-      class << self
-        include ActionView::Helpers::DateHelper
-      end
-    end
-  end
+  require 'capistrano/date_helper'
 rescue LoadError
 end
 
-Capistrano::DeployLockedError = Class.new(StandardError)
-
-Capistrano::Configuration.instance(:must_exist).load do
-  before "deploy", "deploy:check_lock"
-  before "deploy", "deploy:create_lock"
-  after  "deploy", "deploy:unlock"
-
-  # Default lock expiry of 15 minutes (in case deploy crashes or is interrupted)
-  _cset :default_lock_expiry, (15 * 60)
-  _cset(:deploy_lockfile) { "#{shared_path}/capistrano.lock.yml" }
-
-  # Show lock message as bright red
-  log_formatter(:match => /Deploy locked/, :color => :red, :style => :bright, :priority => 20)
-
-  namespace :deploy do
-    # Set deploy lock with a custom lock message and expiry time
-    task :lock do
-      set :lock_message, Capistrano::CLI.ui.ask("Lock Message: ")
-
-      while self[:lock_expiry].nil?
-        expiry_str = Capistrano::CLI.ui.ask("Expire lock at? (optional): ")
-        if expiry_str == ""
-          # Never expire an explicit lock if no time given
-          set :lock_expiry, false
-        else
-          parsed_expiry = nil
-          if defined?(Chronic)
-            parsed_expiry = (Chronic.parse(expiry_str) || Chronic.parse("#{expiry_str} from now"))
-          else
-            if dt = (DateTime.parse(expiry_str) rescue nil)
-              parsed_expiry = dt.to_time
-            end
-          end
-
-          if parsed_expiry
-            set :lock_expiry, parsed_expiry.utc
-          else
-            logger.info "'#{expiry_str}' could not be parsed. Please try again."
-          end
-        end
+module Capistrano
+  DeployLockedError = Class.new(StandardError)
+
+  module DeployLock
+    def self.message(application, stage, deploy_lock)
+      message = "#{application} (#{stage}) was locked"
+      if defined?(Capistrano::DateHelper)
+        locked_ago = Capistrano::DateHelper.distance_of_time_in_words_to_now deploy_lock[:created_at].localtime
+        message << " #{locked_ago} ago"
+      else
+        message << " at #{deploy_lock[:created_at].localtime}"
       end
+      message << " by '#{deploy_lock[:username]}'\nMessage: #{deploy_lock[:message]}"
 
-      create_lock
-    end
-
-    desc "Creates a lock file, so that futher deploys will be prevented."
-    task :create_lock do
-      if self[:lock_message].nil?
-        set :lock_message, "Deploying #{branch} branch"
-      end
-      if self[:lock_expiry].nil?
-        set :lock_expiry, (Time.now + default_lock_expiry).utc
-      end
-
-      lock = {
-        :created_at => Time.now.utc,
-        :username   => ENV['USER'],
-        :expire_at  => self[:lock_expiry],
-        :message    => self[:lock_message]
-      }
-      put lock.to_yaml, deploy_lockfile, :mode => 0777
-    end
-
-    desc "Unlocks the server for deployment."
-    task :unlock do
-      run "rm -f #{deploy_lockfile}"
-    end
-
-    desc "Checks for a deploy lock. If present, deploy is aborted and message is displayed. Any expired locks are deleted."
-    task :check_lock do
-      lock_file = capture("[ -e #{deploy_lockfile} ] && cat #{deploy_lockfile} || true").strip
-
-      if lock_file != ""
-        lock = YAML.load(lock_file)
-
-        if lock[:expire_at] && lock[:expire_at] < Time.now
-          logger.info "Deleting expired deploy lock..."
-          unlock
+      if deploy_lock[:expire_at]
+        if defined?(Capistrano::DateHelper)
+          expires_in = Capistrano::DateHelper.distance_of_time_in_words_to_now deploy_lock[:expire_at].localtime
+          message << "\nExpires in #{expires_in}"
         else
-          if defined?(Capistrano::DateHelper)
-            locked_ago = Capistrano::DateHelper.distance_of_time_in_words_to_now lock[:created_at].localtime
-            message = "Deploy locked #{locked_ago} ago"
-          else
-            message = "Deploy locked at #{lock[:created_at].localtime}"
-          end
-
-          message << " by '#{lock[:username]}'\nMessage: #{lock[:message]}"
-
-          if lock[:expire_at]
-            if defined?(Capistrano::DateHelper)
-              expires_in = Capistrano::DateHelper.distance_of_time_in_words_to_now lock[:expire_at].localtime
-              message << "\nExpires in #{expires_in}"
-            else
-              message << "\nExpires at #{lock[:expire_at].localtime.strftime("%H:%M:%S")}"
-            end
-          else
-            message << "\nLock must be manually removed with: cap #{stage} deploy:unlock"
-          end
-
-          logger.important message
-
-          # Don't raise exception if current user owns the lock.
-          # Just sleep so they have a chance to Ctrl-C
-          if lock[:username] == ENV['USER']
-            4.downto(1) do |i|
-              Kernel.print "\rDeploy lock was created by you (#{ENV['USER']}). Continuing deploy in #{i}..."
-              sleep 1
-            end
-            puts
-          else
-            raise Capistrano::DeployLockedError
-          end
+          message << "\nExpires at #{deploy_lock[:expire_at].localtime.strftime("%H:%M:%S")}"
         end
+      else
+        message << "\nLock must be manually removed with: cap #{stage} deploy:unlock"
       end
     end
   end
 end
+
+# Load recipe if required from deploy script
+if defined?(Capistrano::Configuration) && Capistrano::Configuration.instance
+  require 'capistrano/recipes/deploy_lock'
+end

data/lib/capistrano/recipes/deploy_lock.rb

@@ -0,0 +1,156 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  before "deploy", "deploy:check_lock"
+  before "deploy", "deploy:refresh_lock"
+  before "deploy", "deploy:create_lock"
+  after  "deploy", "deploy:unlock"
+
+  # Default lock expiry of 15 minutes (in case deploy crashes or is interrupted)
+  _cset :default_lock_expiry, (15 * 60)
+  _cset(:deploy_lockfile) { "#{shared_path}/capistrano.lock.yml" }
+
+  # Show lock message as bright red
+  log_formatter(:match => /was locked/, :color => :red, :style => :bright, :priority => 20)
+
+  namespace :deploy do
+    # Fetch the deploy lock unless already cached
+    def fetch_deploy_lock
+      if self[:deploy_lock].nil?
+        lock_file = capture("[ -e #{deploy_lockfile} ] && cat #{deploy_lockfile} || true").strip
+        if lock_file != ""
+          set :deploy_lock, YAML.load(lock_file)
+        else
+          set :deploy_lock, false
+        end
+      end
+    end
+
+    def write_deploy_lock(deploy_lock)
+      put deploy_lock.to_yaml, deploy_lockfile, :mode => 0777
+    end
+
+    desc "Deploy with a custom deploy lock"
+    task :with_lock do
+      lock
+      deploy.default
+    end
+
+    desc "Set deploy lock with a custom lock message and expiry time"
+    task :lock do
+      set :lock_message, Capistrano::CLI.ui.ask("Lock Message: ")
+
+      while self[:lock_expiry].nil?
+        expiry_str = Capistrano::CLI.ui.ask("Expire lock at? (optional): ")
+        if expiry_str == ""
+          # Never expire an explicit lock if no time given
+          set :lock_expiry, false
+        else
+          parsed_expiry = nil
+          if defined?(Chronic)
+            parsed_expiry = Chronic.parse(expiry_str) || Chronic.parse("#{expiry_str} from now")
+          elsif dt = (DateTime.parse(expiry_str) rescue nil)
+            parsed_expiry = dt.to_time
+          end
+
+          if parsed_expiry
+            set :lock_expiry, parsed_expiry.utc
+          else
+            logger.info "'#{expiry_str}' could not be parsed. Please try again."
+          end
+        end
+      end
+
+      create_lock
+      set :custom_deploy_lock, true
+    end
+
+    desc "Creates a lock file, so that futher deploys will be prevented"
+    task :create_lock do
+      if self[:custom_deploy_lock]
+        logger.info 'Custom deploy lock already created.'
+        next
+      end
+
+      if self[:lock_message].nil?
+        set :lock_message, "Deploying #{branch} branch"
+      end
+      if self[:lock_expiry].nil?
+        set :lock_expiry, (Time.now + default_lock_expiry).utc
+      end
+
+      deploy_lock = {
+        :created_at => Time.now.utc,
+        :username   => ENV['USER'],
+        :expire_at  => self[:lock_expiry],
+        :message    => self[:lock_message]
+      }
+      write_deploy_lock(deploy_lock)
+    end
+
+    namespace :unlock do
+      desc "Unlocks the server for deployment"
+      task :default do
+        # Don't automatically remove custom deploy locks created by deploy:lock task
+        if self[:custom_deploy_lock]
+          logger.info 'Not removing custom deploy lock.'
+        else
+          force
+        end
+      end
+
+      task :force do
+        run "rm -f #{deploy_lockfile}"
+      end
+    end
+
+    desc "Checks for a deploy lock. If present, deploy is aborted and message is displayed. Any expired locks are deleted."
+    task :check_lock do
+      # Don't check the lock if we just created it
+      next if self[:custom_deploy_lock]
+
+      fetch_deploy_lock
+      # Return if no lock
+      next unless self[:deploy_lock]
+
+      if deploy_lock[:expire_at] && deploy_lock[:expire_at] < Time.now
+        logger.info "Deleting expired deploy lock..."
+        unlock
+        next
+      end
+
+      # Unexpired lock is present, so display the lock message
+      logger.important Capistrano::DeployLock.message(application, stage, deploy_lock)
+
+      # Don't raise exception if current user owns the lock.
+      # Just sleep so they have a chance to Ctrl-C
+      if deploy_lock[:username] == ENV['USER']
+        4.downto(1) do |i|
+          Kernel.print "\rDeploy lock was created by you (#{ENV['USER']}). Continuing deploy in #{i}..."
+          sleep 1
+        end
+        puts
+      else
+        raise Capistrano::DeployLockedError
+      end
+    end
+
+    desc "Refreshes an existing deploy lock's expiry time, if it is less than the default time"
+    task :refresh_lock do
+      # Don't refresh custom locks
+      next if self[:custom_deploy_lock]
+
+      fetch_deploy_lock
+      next unless self[:deploy_lock]
+
+      # Refresh lock expiry time if it's going to expire soon
+      if deploy_lock[:expire_at] && deploy_lock[:expire_at] < (Time.now + default_lock_expiry)
+        logger.info "Resetting lock expiry to default..."
+        deploy_lock[:expire_at] = (Time.now + default_lock_expiry).utc
+
+        write_deploy_lock(deploy_lock)
+      end
+
+      # Set the deploy_lock_created flag so that the lock isn't automatically removed after deploy
+      set :custom_deploy_lock, true
+    end
+  end
+end

data/lib/capistrano_deploy_lock/version.rb

@@ -1,3 +1,3 @@
 module CapistranoDeployLock
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano_deploy_lock
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,13 +9,14 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-15 00:00:00.000000000 Z
+date: 2012-12-16 00:00:00.000000000 Z
 dependencies: []
 description: Lock a server during deploy, to prevent people from deploying at the
   same time.
 email:
 - nathan.f77@gmail.com
-executables: []
+executables:
+- cap_deploy_lock_msg
 extensions: []
 extra_rdoc_files: []
 files:
@@ -24,8 +25,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/cap_deploy_lock_msg
 - capistrano_deploy_lock.gemspec
+- lib/capistrano/date_helper.rb
 - lib/capistrano/deploy_lock.rb
+- lib/capistrano/recipes/deploy_lock.rb
 - lib/capistrano_deploy_lock.rb
 - lib/capistrano_deploy_lock/version.rb
 homepage: https://github.com/ndbroadbent/capistrano_deploy_lock
@@ -43,7 +47,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1879672784853574210
+      hash: -2094697491794115315
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -52,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1879672784853574210
+      hash: -2094697491794115315
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24