dk-abdeploy 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA512: 
-  data.tar.gz: e68d988dd930229c983f361d1cd75ef9c7addd22029082bdf4c9535e1790b7eb05e4ca9ef6fc72a3b6cace056bd4a2ead6c9ac4319acb02d30e7fe880efb96b2
-  metadata.gz: 4b68931c278d1b5d7cefc95c7ddec5b816237432733e4f4fd712f27439e1e6d7a21b042aa8600db653f69bfc5624211afcbb603e7f5ee6576b5680e0c38ca6af
+  data.tar.gz: f3ce66fba1bb1953197ff2dab9dbe0108fbf608041f8870c6990f48006a6e44f68e142bee666207379539b3ed8a5591a2ed09a12dbcabea90040d6ef08cff635
+  metadata.gz: bfaa114075d524c5f51b334e799f1a388079582040bfdc0ec643d6286773f8c743637177dcb58b1fcf6ff99709907be5df17c20140bab2433ebe59d300020d8a
 SHA1: 
-  data.tar.gz: 95fa2def0135c8e828f944c2a1f796df7fe9eb92
-  metadata.gz: 151800353f028be1d8d7f8a4988248586eed4d0a
+  data.tar.gz: e00eb0f3da66b17a199f313bead21ab34940271c
+  metadata.gz: 3888b89935192e1a09c3f6520b5cbe179bcc58c3

data/README.md

@@ -1,29 +1,102 @@
 # Dk::ABDeploy
 
-[Dk](https://github.com/redding/dk) tasks that implement the A/B deploy pattern.
+[Dk](https://github.com/redding/dk) tasks that implement the A/B deploy scheme.
 
 ## Deploy scheme design
 
 Two release dirs, A and B, each have a clone of the app's git repo.  On deploy, whichever release dir is not current is fetched and reset to the deploy commit.  After the source is updated and ready, the current pointer is updated to the new release dir.
 
-This allows for the current running processes to remain running against the previous source while the new source is updated, migrated, built, etc.  Once the new source is ready, the point is updated and everything can be restarted.
+This allows for the current running processes to remain running against the previous source while the new source is updated, migrated, built, etc.  Once the new source is ready, the pointer is updated and everything can be restarted.
 
-This has a few advantages over a more tradition Cap deploy (for example):
+This has a few advantages over a more tradition single-clone deploy scheme:
 
-* This removes the need to copy the entire source tree after a single common repo has been updated.
+* This removes the need to copy the entire source tree after the single common repo has been updated.
 * There is no need to calculate release dir names with dates/etc and manage them (ie clean out previous old release dirs)
-* This works will with branch deploys as there is no need for any complex rollback logic - just deploy a previous commit to rollback.
+* This works well with branch deploys as there is no need for any complex rollback logic - just deploy a previous commit to rollback.
 * You retain all the benefits of a current pointer that is set to the previous deploy source while the new source is being built/setup.
 
 ## Usage
 
-TODO: Write code samples and usage instructions here
+Here is an example "deploy" task that uses dk-abdeploy tasks to compose it's logic:
+
+```ruby
+# in config/dk.rb or whatever
+require 'dk'
+require 'dk-abdeploy'
+
+class MyDeployTask
+  incude Dk::Task
+
+  desc "deploy my code"
+
+  ssh_hosts 'my_servers'
+
+  def run!
+    # set any required dk-abdeploy params before validating
+    set_param(Dk::ABDeploy::ROOT_PARAM_NAME, params['deploy_dir'])
+    set_param(Dk::ABDeploy::REPO_PARAM_NAME, params['repo_url'])
+    set_param(Dk::ABDeploy::REF_PARAM_NAME,  'origin/master')
+    set_param(
+      Dk::ABDeploy::PRIMARY_SSH_HOST_PARAM_NAME,
+      ssh_hosts('my_servers').first
+    )
+
+    # validate the deploy params, config, etc (safe to run on each deploy)
+    run_task Dk::ABDeploy::Validate
+
+    # do post-validate custom logic (like maybe setting more friendly param names?)
+    set_param('shared_dir',  params[Dk::ABDeploy::SHARED_DIR_PARAM_NAME])
+    set_param('current_dir', params[Dk::ABDeploy::CURRENT_DIR_PARAM_NAME])
+
+    # setup the deploy dirs, etc (safe to run on each deploy)
+    run_task Dk::ABDeploy::Setup
+
+    # update the source in either the A or B release dir (whichever is not current)
+    run_task Dk::ABDeploy::Update
+
+    # do any custom post-source-update logic like:
+    # - set more "friendly" param names
+    # - bundle
+    # - build assets
+    # - etc
+    set_param('deploy_release_dir', release_dir)
+
+    # symlink the release dir that was just updated as the "current"
+    run_task Dk::ABDeploy::Link
+
+    # do any post-symlink logic like (restarting processes, etc)
+
+    # cleanup the deploy
+    # (gets the non-updated release dir on the same commit as the updated release dir)
+    run_task Dk::ABDeploy::Cleanup
+  end
+
+end
+
+Dk.configure do
+  task 'deploy', MyDeployTask
+
+  set_param 'repo_url',   'some-repo-rul'
+  set_param 'deploy_dir', '/path/to/my/code'
+
+  ssh_hosts 'my_servers', 'myhost1.example.com',
+                          'myhost2.example.com'
+end
+```
+
+then...
+
+```
+$ dk -T
+deploy     # deploy my code
+$ dk deploy
+```
 
 ## Notes
 
-The scope of the tasks provided here are fairly limited.  This makes no assumptions about your app ie. whether it is Rails or not, whether it is a web app or not, what subdirs it has, etc.  This just covers the basics of setting up the pattern, updating the source and resetting the current pointer.  That's it.
+The scope of the tasks provided here is fairly limited.  This makes no assumptions about your app ie. whether it is Rails or not, whether it is a web app or not, what subdirs it has, etc.  This just covers the basics of setting up the scheme, updating the source and resetting the current pointer.  That's it.
 
-Layer these tasks as callbacks in your app's specific deploy scheme and do all app-specific logic in those tasks.
+Layer these tasks in your app's specific deploy scheme as callbacks and do all app-specific logic in those tasks.
 
 ## Installation
 

data/dk-abdeploy.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version     = Dk::ABDeploy::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.summary     = "Dk tasks that implement the A/B deploy pattern"
-  gem.description = "Dk tasks that implement the A/B deploy pattern"
+  gem.summary     = "Dk tasks that implement the A/B deploy scheme"
+  gem.description = "Dk tasks that implement the A/B deploy scheme"
   gem.homepage    = "https://github.com/redding/dk-abdeploy"
   gem.license     = 'MIT'
 
@@ -18,6 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.16.1"])
+  gem.add_development_dependency("assert", ["~> 2.16.3"])
+
+  gem.add_dependency("dk",          ["~> 0.1.0"])
+  gem.add_dependency("much-plugin", ["~> 0.2.0"])
 
 end

data/lib/dk-abdeploy.rb

@@ -1,5 +1,9 @@
 require "dk-abdeploy/version"
+require "dk-abdeploy/constants"
 
-module Dk; end
-module Dk::ABDeploy
-end
+# require the tasks for convenience
+require 'dk-abdeploy/cleanup'
+require 'dk-abdeploy/link'
+require 'dk-abdeploy/update'
+require 'dk-abdeploy/setup'
+require 'dk-abdeploy/validate'

data/lib/dk-abdeploy/cleanup.rb

@@ -0,0 +1,40 @@
+require 'much-plugin'
+require 'dk/task'
+require "dk-abdeploy/constants"
+require "dk-abdeploy/update"
+require 'dk-abdeploy/validate'
+
+module Dk::ABDeploy
+
+  class Cleanup
+    include Dk::Task
+
+    desc "(dk-abdeploy) update the non-deploy release's source post-update"
+
+    before Validate
+
+    ssh_hosts SSH_HOSTS_GROUP_NAME
+
+    def run!
+      # current release dir is the one that was current pre-update - the
+      # non-deploy release dir
+      if params[CURRENT_RELEASE_DIR_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{CURRENT_RELEASE_DIR_PARAM_NAME.inspect} param set"
+      end
+      if params[REF_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{REF_PARAM_NAME.inspect} param set"
+      end
+
+      # reset the non-deploy release git repo
+      ssh! git_reset_cmd_str(params[CURRENT_RELEASE_DIR_PARAM_NAME], params[REF_PARAM_NAME])
+    end
+
+    private
+
+    def git_reset_cmd_str(repo_dir, ref)
+      Update.git_reset_cmd_str(repo_dir, ref)
+    end
+
+  end
+
+end

data/lib/dk-abdeploy/constants.rb

@@ -0,0 +1,25 @@
+module Dk; end
+module Dk::ABDeploy
+
+  SHARED_DIR_NAME    = 'shared'.freeze
+  RELEASES_DIR_NAME  = 'releases'.freeze
+  RELEASE_A_DIR_NAME = 'A'.freeze
+  RELEASE_B_DIR_NAME = 'B'.freeze
+  CURRENT_LINK_NAME  = 'current'.freeze
+
+  ROOT_PARAM_NAME                = 'dk_abdeploy_root'.freeze
+  SHARED_DIR_PARAM_NAME          = 'dk_abdeploy_shared_dir'.freeze
+  CURRENT_DIR_PARAM_NAME         = 'dk_abdeploy_current_dir'.freeze
+  RELEASES_DIR_PARAM_NAME        = 'dk_abdeploy_releases_dir'.freeze
+  RELEASE_A_DIR_PARAM_NAME       = 'dk_abdeploy_release_a_dir'.freeze
+  RELEASE_B_DIR_PARAM_NAME       = 'dk_abdeploy_release_b_dir'.freeze
+  CURRENT_RELEASE_DIR_PARAM_NAME = 'dk_abdeploy_current_release_dir'.freeze
+  DEPLOY_RELEASE_DIR_PARAM_NAME  = 'dk_abdeploy_deploy_release_dir'.freeze
+  REPO_PARAM_NAME                = 'dk_abdeploy_repo'.freeze
+  REF_PARAM_NAME                 = 'dk_abdeploy_ref'.freeze
+  PRIMARY_SSH_HOST_PARAM_NAME    = 'dk_abdeploy_primary_ssh_host'.freeze
+
+  SSH_HOSTS_GROUP_NAME = 'dk_abdeploy_servers'.freeze
+
+end
+

data/lib/dk-abdeploy/link.rb

@@ -0,0 +1,30 @@
+require 'dk/task'
+require "dk-abdeploy/constants"
+require 'dk-abdeploy/validate'
+
+module Dk::ABDeploy
+
+  class Link
+    include Dk::Task
+
+    desc "(dk-abdeploy) link the deploy release dir as the current dir"
+
+    before Validate
+
+    ssh_hosts SSH_HOSTS_GROUP_NAME
+
+    def run!
+      # validate required params are set
+      if params[DEPLOY_RELEASE_DIR_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{DEPLOY_RELEASE_DIR_PARAM_NAME.inspect} param set"
+      end
+
+      # link the deploy release dir as the current dir
+      curr_dir    = params[CURRENT_DIR_PARAM_NAME]
+      release_dir = params[DEPLOY_RELEASE_DIR_PARAM_NAME]
+      ssh! "rm -f #{curr_dir} && ln -s #{release_dir} #{curr_dir}"
+    end
+
+  end
+
+end

data/lib/dk-abdeploy/setup.rb

@@ -0,0 +1,43 @@
+require 'dk/task'
+require "dk-abdeploy/constants"
+require 'dk-abdeploy/validate'
+
+module Dk::ABDeploy
+
+  class Setup
+    include Dk::Task
+
+    desc "(dk-abdeploy) create the dirs and clone the repos for the A/B deploy scheme"
+
+    before Validate
+
+    ssh_hosts SSH_HOSTS_GROUP_NAME
+
+    def run!
+      # make the expected dirs if not already made
+      mkdirs = [
+        params[ROOT_PARAM_NAME].to_s,
+        params[SHARED_DIR_PARAM_NAME],
+        params[RELEASES_DIR_PARAM_NAME],
+        params[RELEASE_A_DIR_PARAM_NAME],
+        params[RELEASE_B_DIR_PARAM_NAME]
+      ]
+      ssh! "mkdir -p #{mkdirs.join(' ')}"
+
+      # clone the A/B release repos if not already cloned
+      ssh! clone_cmd_str(params[REPO_PARAM_NAME], params[RELEASE_A_DIR_PARAM_NAME])
+      ssh! clone_cmd_str(params[REPO_PARAM_NAME], params[RELEASE_B_DIR_PARAM_NAME])
+    end
+
+    private
+
+    def clone_cmd_str(repo, release_dir)
+      "if [ -d #{release_dir}/.git ]; " \
+      "then echo 'repo already cloned'; " \
+      "else git clone -q  #{repo} #{release_dir}; " \
+      "fi"
+    end
+
+  end
+
+end

data/lib/dk-abdeploy/update.rb

@@ -0,0 +1,90 @@
+require 'much-plugin'
+require 'dk/task'
+require "dk-abdeploy/constants"
+require 'dk-abdeploy/validate'
+
+module Dk::ABDeploy
+
+  class Update
+    include Dk::Task
+
+    desc "(dk-abdeploy) update the non-current release's source"
+
+    before Validate
+
+    ssh_hosts SSH_HOSTS_GROUP_NAME
+
+    def self.readlink_cmd_str(link)
+      "readlink #{link}"
+    end
+
+    def self.git_reset_cmd_str(repo_dir, ref)
+      "cd #{repo_dir} && " \
+      "git fetch -q origin && " \
+      "git reset -q --hard #{ref} && " \
+      "git clean -q -d -x -f"
+    end
+
+    def run!
+      # validate required params are set
+      if params[REF_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{REF_PARAM_NAME.inspect} param set"
+      end
+      if params[PRIMARY_SSH_HOST_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{PRIMARY_SSH_HOST_PARAM_NAME.inspect} param set"
+      end
+
+      # lookup the current release dir; set current/deploy release dir params
+      release_dirs = [
+        params[RELEASE_A_DIR_PARAM_NAME],
+        params[RELEASE_B_DIR_PARAM_NAME]
+      ]
+
+      rl_ssh = ssh(readlink_cmd_str(params[CURRENT_DIR_PARAM_NAME]), {
+        :hosts => params[PRIMARY_SSH_HOST_PARAM_NAME]
+      })
+      current_dir = (o = rl_ssh.stdout.strip).empty? ? release_dirs.last : o
+      set_param(CURRENT_RELEASE_DIR_PARAM_NAME, current_dir)
+
+      release_dirs.delete(params[CURRENT_RELEASE_DIR_PARAM_NAME])
+      set_param(DEPLOY_RELEASE_DIR_PARAM_NAME, release_dirs.first)
+
+      # reset the deploy release git repo
+      ssh! git_reset_cmd_str(params[DEPLOY_RELEASE_DIR_PARAM_NAME], params[REF_PARAM_NAME])
+    end
+
+    private
+
+    def readlink_cmd_str(link)
+      self.class.readlink_cmd_str(link)
+    end
+
+    def git_reset_cmd_str(repo_dir, ref)
+      self.class.git_reset_cmd_str(repo_dir, ref)
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include Dk::Task::TestHelpers
+        include Dk::ABDeploy::Validate::TestHelpers
+
+        setup do
+          release_dirs = [
+            @params[Dk::ABDeploy::RELEASE_A_DIR_PARAM_NAME],
+            @params[Dk::ABDeploy::RELEASE_B_DIR_PARAM_NAME]
+          ]
+
+          @params[Dk::ABDeploy::CURRENT_RELEASE_DIR_PARAM_NAME] ||= release_dirs.sample
+          release_dirs.delete(@params[Dk::ABDeploy::CURRENT_RELEASE_DIR_PARAM_NAME])
+          @params[Dk::ABDeploy::DEPLOY_RELEASE_DIR_PARAM_NAME] ||= release_dirs.first
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/dk-abdeploy/utils/current_git_branch.rb

@@ -0,0 +1,24 @@
+module Dk; end
+module Dk::ABDeploy; end
+module Dk::ABDeploy::Utils
+
+  module CurrentGitBranch
+
+    def self.new(&block)
+      git_cmd_str = "git symbolic-ref HEAD"
+
+      # returns the cmd str if no block given
+      return git_cmd_str if block.nil?
+
+      # to get the value pass a block that runs the yielded cmd_str cmd, ex:
+      # current_branch_name = CurrentGitBranch.new do |cmd_str|
+      #   log_info "Fetching current git branch from HEAD"
+      #   cmd! cmd_str
+      # end
+      cmd = block.call(git_cmd_str)
+      cmd.stdout.split('/').last.strip
+    end
+
+  end
+
+end

data/lib/dk-abdeploy/validate.rb

@@ -0,0 +1,87 @@
+require 'much-plugin'
+require 'pathname'
+require 'dk/task'
+require "dk-abdeploy/constants"
+
+module Dk::ABDeploy
+
+  class Validate
+    include Dk::Task
+
+    desc "(dk-abdeploy) validate the required dk-abdeploy params"
+
+    run_only_once true
+
+    def run!
+      # validate required params are set
+      if params[ROOT_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{ROOT_PARAM_NAME.inspect} param set"
+      end
+      if params[REPO_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{REPO_PARAM_NAME.inspect} param set"
+      end
+
+      # make sure the hosts group has been set
+      if (h = ssh_hosts(SSH_HOSTS_GROUP_NAME)).nil? || h.empty?
+        raise ArgumentError, "no #{SSH_HOSTS_GROUP_NAME.inspect} have been set"
+      end
+
+      # set common required params for downstream tasks
+      deploy_root = Pathname.new(params[ROOT_PARAM_NAME])
+      set_param(SHARED_DIR_PARAM_NAME,  deploy_root.join(SHARED_DIR_NAME).to_s)
+      set_param(CURRENT_DIR_PARAM_NAME, deploy_root.join(CURRENT_LINK_NAME).to_s)
+
+      releases_dir = deploy_root.join(RELEASES_DIR_NAME)
+      set_param(RELEASES_DIR_PARAM_NAME,  releases_dir.to_s)
+      set_param(RELEASE_A_DIR_PARAM_NAME, releases_dir.join(RELEASE_A_DIR_NAME).to_s)
+      set_param(RELEASE_B_DIR_PARAM_NAME, releases_dir.join(RELEASE_B_DIR_NAME).to_s)
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include Dk::Task::TestHelpers
+
+        setup do
+          @dk_abdeploy_root ||= Factory.path
+          @dk_abdeploy_repo ||= Factory.string
+
+          @dk_abdeploy_shared ||= File.join(
+            @dk_abdeploy_root,
+            Dk::ABDeploy::SHARED_DIR_NAME
+          )
+          @dk_abdeploy_current ||= File.join(
+            @dk_abdeploy_root,
+            Dk::ABDeploy::CURRENT_LINK_NAME
+          )
+          @dk_abdeploy_releases ||= File.join(
+            @dk_abdeploy_root,
+            Dk::ABDeploy::RELEASES_DIR_NAME
+          )
+          @dk_abdeploy_release_a ||= File.join(
+            @dk_abdeploy_releases,
+            Dk::ABDeploy::RELEASE_A_DIR_NAME
+          )
+          @dk_abdeploy_release_b ||= File.join(
+            @dk_abdeploy_releases,
+            Dk::ABDeploy::RELEASE_B_DIR_NAME
+          )
+
+          @params ||= {}
+          @params[Dk::ABDeploy::ROOT_PARAM_NAME]          ||= @dk_abdeploy_root
+          @params[Dk::ABDeploy::REPO_PARAM_NAME]          ||= @dk_abdeploy_repo
+          @params[Dk::ABDeploy::SHARED_DIR_PARAM_NAME]    ||= @dk_abdeploy_shared
+          @params[Dk::ABDeploy::CURRENT_DIR_PARAM_NAME]   ||= @dk_abdeploy_current
+          @params[Dk::ABDeploy::RELEASES_DIR_PARAM_NAME]  ||= @dk_abdeploy_releases
+          @params[Dk::ABDeploy::RELEASE_A_DIR_PARAM_NAME] ||= @dk_abdeploy_release_a
+          @params[Dk::ABDeploy::RELEASE_B_DIR_PARAM_NAME] ||= @dk_abdeploy_release_b
+        end
+
+      end
+
+    end
+
+  end
+
+end