fast_git_deploy 0.2.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'capistrano'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    fast_git_deploy (0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    capistrano (2.13.5)
+      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.15)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-sftp (2.0.5)
+      net-ssh (>= 2.0.9)
+    net-ssh (2.6.2)
+    net-ssh-gateway (1.1.0)
+      net-ssh (>= 1.99.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  capistrano
+  fast_git_deploy!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2009-2013 Scott Taylor
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,36 @@
+= fast_git_deploy
+
+Before (with fast_remote_cache deploy strategy):
+
+  $ time cap staging deploy:update
+
+  ...
+
+  real	1m56.811s
+  user	0m0.560s
+  sys	0m0.118s
+
+
+After:
+
+  $ time cap staging deploy:update
+
+  ...
+
+  real	0m19.987s
+  user	0m0.538s
+  sys	0m0.110s
+
+== Install it into your rails app:
+
+  gem 'fast_git_deploy'
+
+== Switch an existing project:
+
+  cap deploy:warm
+
+== Setup a new project:
+
+  cap deploy:setup
+  cap deploy:cold
+  cap deploy

data/fast_git_deploy.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fast_git_deploy/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "fast_git_deploy"
+  gem.version       = FastGitDeploy::VERSION::STRING
+  gem.authors       = ["Scott Taylor"]
+  gem.email         = ["scott@railsnewbie.com"]
+  gem.description   = %q{The Fast Git Deploy Method - just a git reset --hard to update code}
+  gem.summary       = <<-HERE
+Amazingly fast git deploys by using only a current directory (using git as the version the control history).
+
+It's the same technique github uses at their company.
+HERE
+  gem.homepage      = "http://github.com/smtlaissezfaire/fast_git_deploy"
+  gem.files         = `git ls-files`.split($/)
+  gem.require_paths = ["lib"]
+end

data/lib/fast_git_deploy.rb

@@ -0,0 +1,15 @@
+
+if defined?(Capistrano) &&
+  Capistrano::Configuration.respond_to?(:instance) &&
+  instance = Capistrano::Configuration.instance
+
+  require File.dirname(__FILE__) + "/fast_git_deploy/recipes/fast_git_deploy"
+  require File.dirname(__FILE__) + "/fast_git_deploy/recipes/fast_git_deploy/rollback"
+  require File.dirname(__FILE__) + "/fast_git_deploy/recipes/fast_git_deploy/setup"
+
+  FastGitDeploy::Main.load_into(instance)
+  FastGitDeploy::Rollback.load_into(instance)
+  FastGitDeploy::Setup.load_into(instance)
+end
+
+

data/lib/fast_git_deploy/recipes/fast_git_deploy.rb

@@ -0,0 +1,161 @@
+module FastGitDeploy
+  module Main
+    def self.load_into(configuration)
+      configuration.load do
+        current_dir = File.expand_path(File.dirname(__FILE__))
+
+        set :scm,            "git"
+        set :scm_command,    "git"
+        set(:revision_log)   { "#{deploy_to}/revisions.log" }
+        set(:version_file)   { "#{current_path}/REVISION" }
+        set :migrate_target, :current
+        set :releases,       ['current']
+        set(:release_path)   { File.join(releases_path, "current") }
+        set(:releases_path)  { File.join(deploy_to) }
+
+        # set :branch, "master"
+
+        namespace :deploy do
+          desc <<-DESC
+            Deploy a "cold" application (deploy the app for the first time).
+          DESC
+          task :cold do
+            fast_git_setup.cold
+          end
+
+          desc <<-DESC
+            Deploy a "warm" application - one which is already running, but was
+            setup with deploy:cold provided by capistrano's default tasks
+          DESC
+          task :warm do
+            fast_git_setup.warm
+          end
+
+          desc <<-DESC
+            Deploy and run pending migrations. This will work similarly to the
+            `deploy' task, but will also run any pending migrations (via the
+            `deploy:migrate' task) prior to updating the symlink. Note that the
+            update in this case it is not atomic, and transactions are not used,
+            because migrations are not guaranteed to be reversible.
+          DESC
+          task :migrations do
+            set :migrate_target, :current
+            update_code
+            symlink
+            migrate
+            restart
+          end
+
+          desc "Just like deploy:migrations, but puts up the maintenance page while migrating"
+          task :long do
+            set :migrate_target, :current
+            deploy.web.disable
+            update_code
+            symlink
+            migrate
+            restart
+            deploy.web.enable
+          end
+
+          desc "Updates code in the repos by fetching and resetting to the latest in the branch"
+          task :update_code, :except => { :no_release => true } do
+            run [
+              "cd #{current_path}",
+              "#{scm_command} fetch",
+              "#{scm_command} reset --hard origin/#{branch}"
+            ].join(" && ")
+
+            set_revisions
+            finalize_update
+          end
+
+          desc <<-DESC
+            [internal] Touches up the released code. This is called by update_code
+            after the basic deploy finishes. It assumes a Rails project was deployed,
+            so if you are deploying something else, you may want to override this
+            task with your own environment's requirements.
+
+            This will touch all assets in public/images,
+            public/stylesheets, and public/javascripts so that the times are
+            consistent (so that asset timestamping works).  This touch process
+            is only carried out if the :normalize_asset_timestamps variable is
+            set to true, which is the default.
+          DESC
+          task :finalize_update, :except => { :no_release => true } do
+            if fetch(:normalize_asset_timestamps, true)
+              stamp = Time.now.utc.strftime("%Y%m%d%H%M.%S")
+              asset_paths = %w(images stylesheets javascripts).map { |p| "#{current_path}/public/#{p}" }.join(" ")
+              run "find #{asset_paths} -exec touch -t #{stamp} {} ';'; true", :env => { "TZ" => "UTC" }
+            end
+          end
+
+          desc "Symlink system files & set revision info"
+          task :symlink, :except => { :no_release => true } do
+            symlink_system_files
+          end
+
+          desc "Symlink system files"
+          task :symlink_system_files, :except => { :no_release => true } do
+            run [
+              "rm -rf #{current_path}/log #{current_path}/public/system #{current_path}/tmp/pids",
+              "mkdir -p #{current_path}/public",
+              "mkdir -p #{current_path}/tmp",
+              "ln -s #{shared_path}/log    #{current_path}/log",
+              "ln -s #{shared_path}/system #{current_path}/public/system",
+              "ln -s #{shared_path}/pids   #{current_path}/tmp/pids"
+            ].join(" && ")
+          end
+
+          desc "Set the revisions file.  This allows us to go back to previous versions."
+          task :set_revisions, :except => { :no_release => true } do
+            set_version_file
+            update_revisions_log
+          end
+
+          task :set_version_file, :except => { :no_release => true } do
+            run [
+              "cd #{current_path}",
+              "#{scm_command} rev-list HEAD | head -n 1 > #{version_file}"
+            ].join(" && ")
+          end
+
+          task :update_revisions_log, :except => { :no_release => true } do
+            run "echo `date +\"%Y-%m-%d %H:%M:%S\"` $USER $(cat #{version_file}) >> #{deploy_to}/revisions.log"
+          end
+
+          desc "Do nothing (since we have no releases directory)"
+          task :cleanup do
+          end
+
+          desc "Do nothing (No need to create a symlink)"
+          task :create_symlink do
+          end
+
+          desc <<-DESC
+            Prepares one or more servers for deployment. Before you can use any \
+            of the Capistrano deployment tasks with your project, you will need to \
+            make sure all of your servers have been prepared with `cap deploy:setup'. When \
+            you add a new server to your cluster, you can easily run the setup task \
+            on just that server by specifying the HOSTS environment variable:
+
+              $ cap HOSTS=new.server.com deploy:setup
+
+            It is safe to run this task on servers that have already been set up; it \
+            will not destroy any deployed revisions or data.
+          DESC
+          task :setup, :except => { :no_release => true } do
+            dirs = [deploy_to, shared_path]
+            dirs += shared_children.map { |d| File.join(shared_path, d) }
+            dir_names = dirs.join(' ')
+
+            run [
+             "#{try_sudo} mkdir -p #{dir_names}",
+             "#{try_sudo} chown -R #{user}:#{user} #{dir_names}",
+             "#{try_sudo} chmod g+w #{dir_names}"
+            ].join(" && ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_git_deploy/recipes/fast_git_deploy/rollback.rb

@@ -0,0 +1,62 @@
+module FastGitDeploy
+  module Rollback
+    def self.load_into(configuration)
+      configuration.load do
+        namespace :deploy do
+          namespace :rollback do
+            desc "Rolls the app back one revision"
+            task :code, :except => { :no_release => true } do
+              current_revision  = capture("cat #{version_file}").gsub(/\r?\n?/, "")
+              previous_revision = nil
+
+              revision_log_data = capture("cat #{revision_log}").split(/\r?\n/)
+              revisions = revision_log_data.map do |entry|
+                entry.split(" ").last
+              end
+
+              revisions.reverse!
+
+              revisions.each_with_index do |revision, index|
+                if current_revision == revision
+                  # we have found the currently deployed revision
+                  # so scan the file backwards until a different revision
+                  # is found (removing duplicates - i.e.):
+                  #
+                  # 2010-04-21 15:22:59 deploy 2a285b0f600c7ed31b307390ad91c
+                  # 2010-04-22 09:58:28 deploy 53cff5db28116ecd5ad32d11ee6e1
+                  # 2010-04-22 10:02:41 deploy 53cff5db28116ecd5ad32d11ee6e1
+                  # 2010-04-26 08:18:39 deploy 5494dc2a00beb5350eff6be151987
+                  # 2010-04-27 09:10:06 deploy 5494dc2a00beb5350eff6be151987
+                  # 2010-04-27 11:49:29 deploy 5494dc2a00beb5350eff6be151987
+                  #
+                  # Rolling back from 5494dc should yield 53cff5db
+                  previous_revision = revisions[index..revision_log_data.length-1].detect do |rev|
+                    rev != current_revision
+                  end
+                end
+              end
+
+              if previous_revision
+                run [
+                  "cd #{current_path}",
+                  "#{scm_command} reset --hard #{previous_revision}"
+                ].join(" && ")
+              else
+                raise(Capistrano::Error, "Couldn't find a revision previous to #{current_revision}")
+              end
+            end
+
+            desc "Rolls back the app one revision, restarts mongrel, and writes the revision to the VERSION file (but not revisions.log)"
+            task :default do
+              transaction do
+                rollback.code
+                deploy.restart
+                deploy.set_version_file
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_git_deploy/recipes/fast_git_deploy/setup.rb

@@ -0,0 +1,107 @@
+module FastGitDeploy
+  module Setup
+    def self.load_into(configuration)
+      configuration.load do
+        namespace :deploy do
+          namespace :fast_git_setup do
+            task :cold do
+              clone_repository
+              finalize_clone
+              create_revision_log
+
+              deploy.update
+              deploy.start
+            end
+
+            def self.clone_repository_command(path)
+              [
+                "if [ ! -e #{path} ]",
+                  "then mkdir -p #{deploy_to}",
+                  "cd #{deploy_to}",
+                  "#{scm_command} clone #{repository} #{path}",
+                "fi"
+              ].join("; ")
+            end
+
+            desc "Clones the repos"
+            task :clone_repository, :except => { :no_release => true } do
+              run clone_repository_command(current_path)
+            end
+
+            task :create_revision_log, :except => { :no_release => true } do
+              run [
+                "if [ ! -e #{revision_log} ]",
+                  "then touch #{revision_log}",
+                  "chmod 664 #{revision_log}",
+                "fi"
+              ].join("; ")
+            end
+
+            task :warm do
+              clone_repository_to_tmp_path
+
+              deploy.web.disable
+              remove_old_app
+              rename_clone
+              finalize_clone
+              deploy.default
+              deploy.web.enable
+            end
+
+            task :clone_repository_to_tmp_path, :except => { :no_release => true } do
+              run clone_repository_command("#{current_path}.clone")
+            end
+
+            task :rename_clone, :except => { :no_release => true } do
+              run "mv #{current_path}.clone #{current_path}"
+            end
+
+            task :remove_old_app do
+              remove_releases
+              remove_current
+            end
+
+            task :remove_releases, :except => { :no_release => true } do
+              run [
+                "if [ -e #{deploy_to}/releases ]",
+                  "then mv #{deploy_to}/releases #{deploy_to}/releases.old",
+                "fi"
+              ].join("; ")
+            end
+
+            task :remove_current, :except => { :no_release => true } do
+              # test -h => symlink
+              run [
+                "if [ -h #{current_path} ]",
+                  "then mv #{current_path} #{current_path}.old",
+                "fi"
+              ].join("; ")
+            end
+
+
+            desc <<-HERE
+              This task will make the release group-writable (if the :group_writable
+              variable is set to true, which is the default). It will then set up
+              symlinks to the shared directory for the log, system, and tmp/pids
+              directories.
+            HERE
+            task :finalize_clone, :except => { :no_release => true } do
+              run "chmod -R g+w #{current_path}" if fetch(:group_writable, true)
+
+              # mkdir -p is making sure that the directories are there for some SCM's that don't
+              # save empty folders
+              run [
+                "rm -rf #{current_path}/log #{current_path}/public/system #{current_path}/tmp/pids",
+                "mkdir -p #{current_path}/public",
+                "mkdir -p #{current_path}/tmp",
+                "ln -s #{shared_path}/log    #{current_path}/log",
+                "ln -s #{shared_path}/system #{current_path}/public/system",
+                "ln -s #{shared_path}/pids   #{current_path}/tmp/pids"
+              ].join(" && ")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_git_deploy/version.rb

@@ -0,0 +1,9 @@
+module FastGitDeploy
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 1
+
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
+  end
+end

data/spec/Capfile

@@ -0,0 +1,4 @@
+load 'deploy' if respond_to?(:namespace) # cap2 differentiator
+Dir[File.dirname(__FILE__) + '/../**/recipes/*.rb'].each { |plugin| load(plugin) }
+
+load File.dirname(__FILE__) + '/config/deploy.rb' # remove this line to skip loading any of the default tasks

data/spec/config/deploy.rb

@@ -0,0 +1,35 @@
+def self.join(*args)
+  current_path = File.dirname(__FILE__)
+  File.expand_path(File.join(current_path, *args))
+end
+
+set :application, "fast_git_deploy_test"
+set :repository,  join("..", "..", ".git")
+set :deploy_to,   join("..", "deployments")
+set :scm_command, `which git`.chomp
+set :user,        `whoami`.chomp
+
+set :scm, :git
+
+ssh_options[:paranoid] = false
+default_run_options[:pty] = true
+
+role :web, "127.0.0.1"
+role :app, "127.0.0.1"
+role :db,  "127.0.0.1", :primary => true
+
+set :branch, "master"
+
+namespace :deploy do
+  task :restart do
+    # do nothing
+  end
+
+  task :migrate do
+    # do nothing
+  end
+
+  task :start do
+    # do nothing
+  end
+end

data/spec/deploy_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe "fast git deploy" do
+  def cap_execute(command)
+    commands = [
+      "--file", File.expand_path("#{File.dirname(__FILE__)}/Capfile"),
+      "--quiet"
+    ]
+    commands.push command.split(" ")
+    commands.flatten!
+
+    Capistrano::CLI.parse(commands).execute!
+  end
+
+  it "should be able to deploy with a dry-run" do
+    cap_execute "-n deploy"
+  end
+
+  it "should be able to deploy:setup" do
+    cap_execute "deploy:setup"
+  end
+
+  it "should be able to deploy:cold after deploy:setup" do
+    cap_execute "deploy:setup"
+    cap_execute "deploy:cold"
+  end
+
+  it "should be able to deploy" do
+    cap_execute "deploy:setup"
+    cap_execute "deploy:cold"
+    cap_execute "deploy"
+  end
+
+  it "should be able to deploy:migrations" do
+    cap_execute "deploy:setup"
+    cap_execute "deploy:cold"
+    cap_execute "deploy:migrations"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'capistrano/cli'
+require 'capistrano/configuration'
+
+# load File.expand_path(File.dirname(__FILE__) + "/../recipes/fast_git_deploy.rb")
+
+# load File.dirname(__FILE__) + '/config/deploy.rb'
+
+Spec::Runner.configure do |config|
+  config.before :each do
+    FileUtils.rm_rf(File.dirname(__FILE__) + "/deployments")
+  end
+
+  config.after :each do
+    FileUtils.rm_rf(File.dirname(__FILE__) + "/deployments")
+  end
+end
+
+module Capistrano
+  class Configuration
+    module Actions
+      module Invocation
+        def sudo(*parameters, &block)
+          options = parameters.last.is_a?(Hash) ? parameters.pop.dup : {}
+          command = parameters.first
+          user = options[:as] && "-u #{options.delete(:as)}"
+
+          sudo_prompt_option = "-p '#{sudo_prompt}'" unless sudo_prompt.empty?
+          sudo_command = [fetch(:sudo, "sudo"), sudo_prompt_option, user].compact.join(" ")
+
+          if command
+            run(command, options, &block)
+          else
+            return sudo_command
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: fast_git_deploy
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Scott Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-08 00:00:00.000000000 Z
+dependencies: []
+description: The Fast Git Deploy Method - just a git reset --hard to update code
+email:
+- scott@railsnewbie.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- fast_git_deploy.gemspec
+- lib/fast_git_deploy.rb
+- lib/fast_git_deploy/recipes/fast_git_deploy.rb
+- lib/fast_git_deploy/recipes/fast_git_deploy/rollback.rb
+- lib/fast_git_deploy/recipes/fast_git_deploy/setup.rb
+- lib/fast_git_deploy/version.rb
+- spec/Capfile
+- spec/config/deploy.rb
+- spec/deploy_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+homepage: http://github.com/smtlaissezfaire/fast_git_deploy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Amazingly fast git deploys by using only a current directory (using git as
+  the version the control history).  It's the same technique github uses at their
+  company.
+test_files: []