capistrano-patch 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.bundle
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.8.7

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    capistrano-patch (0.0.1)
+      capistrano (>= 2.5.5)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    capistrano (2.9.0)
+      highline
+      net-scp (>= 1.0.0)
+      net-sftp (>= 2.0.0)
+      net-ssh (>= 2.0.14)
+      net-ssh-gateway (>= 1.1.0)
+    highline (1.6.2)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-sftp (2.0.5)
+      net-ssh (>= 2.0.9)
+    net-ssh (2.2.1)
+    net-ssh-gateway (1.1.0)
+      net-ssh (>= 1.99.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  capistrano-patch!

data/README.md

@@ -0,0 +1,162 @@
+# Capistrano patch recipes
+
+## Concept
+
+Usual deployment procedure is pretty good. 
+But real project are big and offen have several megabytes of code. So standard deployment is not so fast.
+You need chekout new code, prepare all symplinks, etc ... It takes the time.
+
+Sometimes you need to *quickly* apply hostfix that fixes critical bug. 
+Usually such fix is small and may contain only several lines of code.
+Doing it manual it's not good from any point of view.
+
+So that's why *capistrano patch recipes* appears. They are extracted from real big project.
+
+It's automated solution for safely code patching on any stage.
+
+Depending on patch strategy `cap patch` :
+
+* creates patch file
+* delivers patch file to all application servers
+* checks patch
+* applies patch
+* updates REVISION
+
+If something went wrong your also able to quickly revert patch with `cap patch:revert`. See recipes below.
+
+
+## Installation
+
+    gem install capistrano-patch
+
+Add to `Capfile`
+
+    # load standard capistrano recipes
+    load 'deploy' 
+
+    # load patch recipes
+    require 'capistrano/patch' 
+
+## Configuration
+
+* *:patch_via* - patch strategy (default `:git`)
+* *:patch_repository* - SCM repository that will be using for generating diffs (default `.git`)
+* *:patch_directory* - directory for storing generated patches (default `.`)
+* *:patch_base_url* - base url for patch download ( default `nil`)
+* *:patch_server_host* - server host for patch generating ( default `nil`)
+* *:patch_server_options* -server host options ( default `{}`)
+
+## Patch strategies
+
+Patch strategy is about how to process code patching on stage. It also depends on patch source (or scm).
+
+Currently implemented patch strategies:
+
+* git
+* git_server
+
+## Git strategy
+
+It's simple strategy that is suitable for almost all git projects.
+
+### Integrated deployment
+
+When you use capistrano directly into your application you need zero configuration.
+
+### Separated deployment
+
+When you have separated deployment repository you need to specify patch repository and directory.
+
+Example:
+
+    set(:patch_repository) { "../#{application}.git" }
+    set(:patch_directory)  { "/tmp/patches/#{application}" }
+
+## GitServer strategy
+
+For big projects offen is required to generate patch using some certain or origin repository and store generated patch in some directory there. Thus patch can be accessible from directory server via http and delivered to application servers from the same host where repository is located.
+
+Example:
+
+    set :patch_via, :git_server
+
+    set(:patch_repository) { "/var/git/repositories/#{application}.git" }
+    set(:patch_directory)  { "/var/www/patches/#{application}" }
+    set(:patch_base_url)   { "http://scm.example.com/patches/#{application}" }  
+
+    set :patch_server_host, "scm.example.com"
+
+### Extra options
+
+Patch server is not in global capistrano servers list.
+So any other task will not affect your server. And this is good.
+But offen you need to specify different options to patch server instead of global values.
+
+When you want to specify just another `user` or `port` you can do it in `patch_server_host` variable:
+
+    set :patch_server_host, "USER@scm.example.com:PORT"
+
+or using `patch_server_options` variable:
+
+    set :patch_server_options, {
+      :user => 'patcher',
+      :port => 2222
+    }
+
+Also you are able to specify another ssh keys:
+
+    set :patch_server_options, {
+      :ssh_options => { :auth_methods => %w(publickey), :keys => %w(keys/patcher.pem) }
+    }
+
+## Recipes
+
+### Create deliver and apply patch
+
+    $ cap patch FROM=v0.0.1 TO=v0.0.2
+
+or
+
+    $ cap patch PATCH=v0.0.1-v0.0.2
+
+or
+
+    $ cap patch FROM=development TO=master
+
+
+* It will create patch file like `sha1-sha2.patch`
+* It will deliver patch file to all application servers
+* It will check patch before applying
+* It will apply check
+* It will update REVISION after applying
+
+
+### Create patch
+
+    $ cap patch:create FROM=v0.0.1 TO=v0.0.2
+
+Create file like: `6c5923863a288b089a6a2bc11e560f0d28dabfb6-92e018dbda8a91c442e40257b81097ceeb150876.patch`
+
+### Deliver patch
+
+If patch file is missing on some server you can manualy deliver it with
+
+    $ cap patch:deliver FROM=v0.0.1 TO=v0.0.2 HOSTFILTER='app1'
+
+### Apply patch
+
+If may manualy apply patch on some server:
+
+    $ cap patch:apply FROM=v0.0.1 TO=v0.0.2 HOSTFILTER='app1'
+
+### Revert patch
+
+
+If something went bad you may revert patch
+
+    $ cap patch:revert FROM=v0.0.1 TO=v0.0.2
+    # or
+    $ cap patch:revert PATCH=v0.0.1-v0.0.2
+    # or
+    $ cap patch:revert PATCH=6c5923863a288b089a6a2bc11e560f0d28dabfb6-92e018dbda8a91c442e40257b81097ceeb150876.patch
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/capistrano-patch.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "capistrano/patch/version"
+
+Gem::Specification.new do |s|
+  s.name        = "capistrano-patch"
+  s.version     = Capistrano::Patch::VERSION
+  s.authors     = ["Andriy Yanko"]
+  s.email       = ["andriy.yanko@gmail.com"]
+  s.homepage    = "https://github.com/railsware/capistrano-patch"
+  s.summary     = %q{Capistrano patch recipes}
+
+  s.rubyforge_project = "capistrano-patch"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "capistrano", ">=2.5.5"
+end

data/lib/capistrano/patch.rb

@@ -0,0 +1,44 @@
+require 'capistrano/patch/strategy'
+
+Capistrano::Configuration.instance.load do
+
+  set(:patch_strategy) { Capistrano::Patch::Strategy.new(fetch(:patch_via, scm), self) }
+
+  namespace :patch do
+
+    desc "Create, deliver and apply patch"
+    task :default, :except => { :no_release => true } do
+      top.patch.create
+      top.patch.deliver
+      top.patch.apply
+    end
+
+    desc "Create patch"
+    task :create, :except => { :no_release => true }  do
+      patch_strategy.create
+      Capistrano::CLI.ui.say "Patch location: #{patch_strategy.patch_location}"
+      abort unless Capistrano::CLI.ui.ask("Is created patch ok? (y/n)") == 'y'
+    end
+
+    desc "Deliver patch"
+    task :deliver, :except => { :no_release => true }  do
+      patch_strategy.deliver
+    end
+
+    desc "Apply patch"
+    task :apply, :except => { :no_release => true }  do
+      abort unless Capistrano::CLI.ui.ask("Apply #{patch_strategy.patch_file} ? (y/n)") == 'y'
+      patch_strategy.check_apply
+      patch_strategy.apply
+      patch_strategy.mark_apply
+    end
+
+    desc "Revert patch"
+    task :revert, :except => { :no_release => true }  do
+      abort unless Capistrano::CLI.ui.ask("Revert #{patch_strategy.patch_file} ? (y/n)") == 'y'
+      patch_strategy.check_revert
+      patch_strategy.revert
+      patch_strategy.mark_revert
+    end
+  end
+end

data/lib/capistrano/patch/strategy.rb

@@ -0,0 +1,18 @@
+module Capistrano
+  module Patch
+    module Strategy
+
+      def self.new(strategy, config = {})
+        require "capistrano/patch/strategy/#{strategy}"
+
+        strategy_const = strategy.to_s.capitalize.gsub(/_(.)/) { $1.upcase }
+
+        const_get(strategy_const).new(config)
+
+      rescue LoadError
+        raise Capistrano::Error, "could not find any strategy named `#{strategy}'"
+      end
+
+    end
+  end
+end

data/lib/capistrano/patch/strategy/base.rb

@@ -0,0 +1,94 @@
+require 'capistrano/recipes/deploy/strategy/base'
+
+module Capistrano
+  module Patch
+    module Strategy
+      class Base < Deploy::Strategy::Base
+
+        def initialize(*)
+          super
+
+          if ENV['PATCH']
+            ENV['FROM'], ENV['TO'] = File.basename(ENV['PATCH'], '.patch').split('-', 2)
+          end
+
+          ENV['FROM'] or abort "Please specify FROM revision environment variable"
+          ENV['TO']   or abort "Please specify TO revision environment variable"
+
+          @revision_from = normalize_revision(ENV['FROM'])
+          @revision_to   = normalize_revision(ENV['TO'])
+        end
+
+        #
+        # Configuration
+        #
+
+        attr_reader :revision_from, :revision_to
+
+        def patch_file
+          @patch_file ||= "#{revision_from}-#{revision_to}.patch"
+        end
+
+        def patch_directory
+          raise NotImplementedError, "`patch_directory' is not implemented by #{self.class.name}"
+        end
+
+        def patch_path
+          File.join patch_directory, patch_file
+        end
+
+        def patch_location
+          raise NotImplementedError, "`patch_location' is not implemented by #{self.class.name}"
+        end
+
+        #
+        # Actions
+        #
+
+        def create
+          raise NotImplementedError, "`create' is not implemented by #{self.class.name}"
+        end
+
+        def deliver
+          raise NotImplementedError, "`deliver' is not implemented by #{self.class.name}"
+        end
+
+        def check_apply
+          raise NotImplementedError, "`check_apply' is not implemented by #{self.class.name}"
+        end
+
+        def check_revert
+          raise NotImplementedError, "`check_revert' is not implemented by #{self.class.name}"
+        end
+
+        def apply
+          raise NotImplementedError, "`apply' is not implemented by #{self.class.name}"
+        end
+
+        def revert
+          raise NotImplementedError, "`revert' is not implemented by #{self.class.name}"
+        end
+
+        def mark_apply
+          mark(revision_to)
+        end
+
+        def mark_revert
+          mark(revision_from)
+        end
+
+        protected
+
+        def normalize_revision(revision)
+          source.local.query_revision(revision) { |cmd| run_locally(cmd) }
+        end
+
+        def mark(revision)
+          command = "echo #{revision} > #{configuration.current_path}/REVISION"
+          run(command) 
+        end
+
+      end
+    end
+  end
+end

data/lib/capistrano/patch/strategy/git.rb

@@ -0,0 +1,57 @@
+require 'capistrano/patch/strategy/base'
+
+module Capistrano
+  module Patch
+    module Strategy
+      class Git < Base
+
+        def patch_repository
+          configuration.fetch(:patch_repository, '.git')
+        end
+
+        def patch_directory
+          configuration.fetch(:patch_directory, '.')
+        end
+
+        def patch_location
+          patch_path
+        end
+
+        def create
+          command = "env GIT_DIR=#{patch_repository} "
+          command << source.local.scm('diff-tree', "--binary #{revision_from}..#{revision_to} > #{patch_path}")
+          system(command)
+        end
+
+        def deliver
+          top.upload patch_path, "#{configuration.current_path}/#{patch_file}"
+        end
+
+        def check_apply
+          command = "cd #{configuration.current_path} && "
+          command << source.scm('apply', "--binary --check #{patch_file}")
+          run(command)
+        end
+
+        def check_revert
+          command = "cd #{configuration.current_path} && "
+          command << source.scm('apply', "-R --binary --check #{patch_file}")
+          run(command)
+        end
+
+        def apply
+          command = "cd #{configuration.current_path} && "
+          command << source.scm('apply', "--binary #{patch_file}")
+          run(command)
+        end
+
+        def revert
+          command = "cd #{configuration.current_path} && "
+          command << source.scm('apply', "-R --binary #{patch_file}")
+          run(command)
+        end
+
+      end
+    end
+  end
+end

data/lib/capistrano/patch/strategy/git_server.rb

@@ -0,0 +1,40 @@
+require 'capistrano/patch/strategy/git'
+
+module Capistrano
+  module Patch
+    module Strategy
+      class GitServer < Git
+
+        def patch_location
+          File.join configuration.fetch(:patch_base_url), patch_file
+        end
+
+        def create
+          command = "mkdir -p #{patch_directory} && "
+          command << source.scm('diff-tree', "--binary #{revision_from}..#{revision_to} > #{patch_path}")
+
+          run(command, {
+            :hosts => [server],
+            :env => { 'GIT_DIR' => patch_repository }
+          })
+        end
+
+        def deliver
+          command = "cd #{current_path} && "
+          command << "wget -N -q #{patch_location}"
+          run(command)
+        end
+
+        protected
+
+        def server
+          ServerDefinition.new(
+            configuration.fetch(:patch_server_host),
+            configuration.fetch(:patch_server_options, {})
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/capistrano/patch/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module Patch
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: capistrano-patch
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andriy Yanko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 2
+        - 5
+        - 5
+        version: 2.5.5
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- andriy.yanko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- capistrano-patch.gemspec
+- lib/capistrano/patch.rb
+- lib/capistrano/patch/strategy.rb
+- lib/capistrano/patch/strategy/base.rb
+- lib/capistrano/patch/strategy/git.rb
+- lib/capistrano/patch/strategy/git_server.rb
+- lib/capistrano/patch/version.rb
+homepage: https://github.com/railsware/capistrano-patch
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: capistrano-patch
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Capistrano patch recipes
+test_files: []
+