git-deploy 0.5.0 → 0.6.0

data/README.markdown

@@ -1,17 +1,20 @@
 Easy git deployment
 ===================
 
-Straightforward, [Heroku][]-style, push-based deployment. Your deploys will look like this:
+Straightforward, [Heroku][]-style, push-based deployment. Your deploys can become as simple as this:
 
     $ git push production master
 
 To get started, install the "git-deploy" gem.
 
-    $ gem install git-deploy
+    gem install git-deploy
 
+Only the person who is setting up deployment for the first time needs to install
+the gem. You don't have to add it to your project's Gemfile.
 
-What application frameworks/languages are supported?
-----------------------------------------------------
+
+Which app languages/frameworks are supported?
+---------------------------------------------
 
 Regardless of the fact that this tool is mostly written in Ruby, git-deploy can be useful for any kind of code that needs deploying on a remote server. The default scripts are suited for Ruby web apps, but can be edited to accommodate other frameworks.
 
@@ -20,50 +23,63 @@ Your deployment is customized with per-project callback scripts which can be wri
 The assumption is that you're deploying to a single host to which you connect over SSH using public/private key authentication.
 
 
-Setup steps
------------
+Initial setup
+-------------
 
 1.  Create a git remote for where you'll push the code on your server. The name of this remote in the examples is "production", but it can be whatever you wish ("online", "website", or other).
-    
-        $ git remote add production user@example.com:/path/to/myapp
-    
-    The "/path/to/myapp" is the directory where your code will reside. It doesn't have to exist; it will be created for you during this setup.
+
+    ```sh
+    git remote add production "user@example.com:/apps/mynewapp"
+    ```
+
+    `/apps/mynewapp` is the directory where you want your code to reside on the
+    remote server. If the directory doesn't exist, the next step creates it.
 
 2.  Run the setup task:
-    
-        $ git deploy setup -r production
-    
-    This will initialize the remote git repository in the target directory ("/path/to/myapp" in the above example) and install the remote git hooks.
+
+    ```sh
+    git deploy setup -r "production"
+    ```
+
+    This will initialize the remote git repository in the deploy directory
+    (`/apps/mynewapp` in the above example) and install the remote git hook.
 
 3.  Run the init task:
-    
-        $ git deploy init
-    
-    This generates default deploy callback scripts in the "deploy/" directory. You must check them in version control. They are going to be executed on the server on each deploy.
+
+    ```sh
+    git deploy init
+    ```
+
+    This generates default deploy callback scripts in the `deploy/` directory.
+    You should check them in git because they are going to be executed on the
+    server during each deploy.
 
 4.  Push the code.
 
-        $ git push production master
+    ```sh
+    git push production master
+    ```
 
 3.  Login to your server and manually perform necessary one-time administrative operations. This might include:
     * set up the Apache/nginx virtual host for this application;
-    * check your "config/database.yml" and create the production database.
+    * check your `config/database.yml` and create the production database.
 
 
-Deployment
-----------
+Everyday deployments
+--------------------
 
-If you've set your app correctly, visiting "http://example.com" in your browser should show it up and running.
+If you've set your app correctly, visiting <http://example.com> in your browser
+should show it up and running.
 
-Now, subsequent deployments are done simply by pushing to the branch that is currently checked out on the remote:
+Now, subsequent deployments are done simply **by pushing to the branch that is
+currently checked out on the remote**:
 
-    $ git push production master
+    git push production master
 
-Because the deployments are done with git, not everyone on the team had to install git-deploy. Just the person who was doing the setup.
+Because the deployments are performed with git, nobody else on the team needs to
+install the "git-deploy" gem.
 
-Deployments are logged to "log/deploy.log" in your application.
-
-On every deploy, the "deploy/after_push" script performs the following:
+On every deploy, the default `deploy/after_push` script performs the following:
 
 1. updates git submodules (if there are any);
 2. runs `bundle install --deployment` if there is a Gemfile;
@@ -71,16 +87,48 @@ On every deploy, the "deploy/after_push" script performs the following:
 4. clears cached CSS/JS assets in "public/stylesheets" and "public/javascripts";
 5. restarts the web application.
 
-You can customize all of this by editing scripts in the "deploy/" directory of your app.
+You can customize all this by editing generated scripts in the `deploy/`
+directory of your app.
+
+Deployments are logged to `log/deploy.log` in your application's directory.
+
 
 How it works
 ------------
 
-The "setup" task installed a "post-receive" hook in the remote git repository. This is how your working copy on the server is kept up to date. This hook, after checking out latest code, asynchronously dispatches to "deploy/after_push" script in your application. This script executes on the server and also calls "deploy/before_restart", "restart", and "after_restart" callbacks if they are present.
+The `git deploy setup` command installed a `post-receive` git hook in the remote
+repository. This is how your code on the server is kept up to date. This script
+checks out the latest version of your project from the current branch and
+runs the following callback scripts:
+
+* `deploy/setup` - on first push.
+* `deploy/after_push` - on subsequent pushes. It in turn executes:
+  * `deploy/before_restart`
+  * `deploy/restart`
+  * `deploy/after_restart`
+* `deploy/rollback` - executed for `git deploy rollback`.
+
+All of the callbacks are optional. These scripts are ordinary Unix executables.
+The ones which get generated for you by `git deploy init` are written in shell
+script and Ruby.
+
+
+Extra commands
+--------------
+
+* `git deploy hooks` - Updates git hooks on the remote repository
+
+* `git deploy log [N=20]` - Shows last 20 lines of deploy log on the server
+
+* `git deploy rerun` - Re-runs the `deploy/after_push` callback as if a git push happened
+
+* `git deploy restart` - Runs the `deploy/restart` callback
+
+* `git deploy rollback` - Undo a deploy by checking out the previous revision,
+  runs `deploy/callback` if exists instead of `deploy/after_push`
 
-These scripts are ordinary unix executable files. The ones which are generated for you are written in shell script and Ruby.
+* `git deploy upload <files>` - Copy local files to the remote app
 
-It's worth remembering that "after_push" is done **asynchronously from your git push**. This is because migrating the database and updating submodules might take a long time and you don't want to wait for all that during a git push. But, this means that when the push is done, the server has *not yet restarted*. You might need to wait a few seconds or a minute.
 
 
-  [heroku]: http://heroku.com/
+  [heroku]: http://heroku.com/

data/lib/git_deploy/configuration.rb

@@ -1,30 +1,23 @@
+require 'uri'
+require 'cgi'
+require 'forwardable'
+
 class GitDeploy
   module Configuration
     private
 
-    def host
-      extract_host_and_user unless defined? @host
-      @host
-    end
+    extend Forwardable
+    def_delegator :remote_url, :host
+    def_delegator :remote_url, :port, :remote_port
+    def_delegator :remote_url, :path, :deploy_to
 
     def remote_user
-      extract_host_and_user unless defined? @user
-      @user
-    end
-
-    def extract_host_and_user
-      info = remote_url.split(':').first.split('@')
-      if info.size < 2
-        @user, @host = `whoami`.chomp, info.first
-      else
-        @user, @host = *info
+      @user ||= begin
+        user = remote_url.user
+        user ? CGI.unescape(user) : `whoami`.chomp
       end
     end
 
-    def deploy_to
-      @deploy_to ||= remote_url.split(':').last
-    end
-
     def branch
       'master'
     end
@@ -41,7 +34,9 @@ class GitDeploy
     end
 
     def remote_urls(remote)
-      git_config["config --get-all remote.#{remote}.url"].to_s.split("\n")
+      git_config["remote -v"].to_s.split("\n").
+        select {|l| l =~ /^#{remote}\t/ }.
+        map {|l| l.split("\t")[1].sub(/\(.+?\)$/, '') }
     end
 
     def remote_url(remote = options[:remote])
@@ -50,8 +45,15 @@ class GitDeploy
         url = remote_urls(remote).first
         if url.nil?
           abort "Error: Remote url not found for remote #{remote.inspect}"
-        elsif url =~ /\bgithub\.com\b/
+        elsif url =~ /(^|@)github\.com\b/
           abort "Error: Remote url for #{remote.inspect} points to GitHub. Can't deploy there!"
+        else
+          url = 'ssh://' + url.sub(%r{:/?}, '/') unless url =~ %r{^[\w-]+://}
+          begin
+            url = URI.parse url
+          rescue
+            abort "Error parsing remote url #{url}"
+          end
         end
         url
       end

data/lib/git_deploy/ssh_methods.rb

@@ -11,10 +11,13 @@ class GitDeploy
       super unless options.noop?
     end
 
-    def run(cmd = nil)
+    def run(cmd = nil, opt = {})
       cmd = yield(cmd) if block_given?
       cmd = cmd.join(' && ') if Array === cmd
-      puts "[#{options[:remote]}] $ " + cmd.gsub(' && ', " && \\\n  ")
+
+      if opt.fetch(:echo, true)
+        puts "[#{options[:remote]}] $ " + cmd.gsub(' && ', " && \\\n  ")
+      end
 
       unless options.noop?
         status, output = ssh_exec cmd do |ch, stream, data|
@@ -90,7 +93,7 @@ class GitDeploy
 
     def ssh_connection
       @ssh ||= begin
-        ssh = Net::SSH.start(host, remote_user)
+        ssh = Net::SSH.start(host, remote_user, :port => remote_port)
         at_exit { ssh.close }
         ssh
       end

data/lib/git_deploy/templates/after_push.sh

@@ -11,7 +11,7 @@ echo files changed: $(git diff $oldrev $newrev --diff-filter=ACDMR --name-only |
 
 umask 002
 
-git submodule init && git submodule sync && git submodule update
+git submodule sync && git submodule update --init --recursive
 
 run deploy/before_restart
 run deploy/restart && run deploy/after_restart

data/lib/git_deploy/templates/before_restart.rb

@@ -9,13 +9,27 @@ RAILS_ENV   = ENV['RAILS_ENV'] || 'production'
 use_bundler = File.file? 'Gemfile'
 rake_cmd    = use_bundler ? 'bundle exec rake' : 'rake'
 
-# update gem bundle
-run "bundle install --deployment" if use_bundler
+if use_bundler
+  bundler_args = ['--deployment']
+  BUNDLE_WITHOUT = ENV['BUNDLE_WITHOUT'] || 'development:test'
+  bundler_args << '--without' << BUNDLE_WITHOUT unless BUNDLE_WITHOUT.empty?
+
+  # update gem bundle
+  run "bundle install #{bundler_args.join(' ')}"
+end
 
 if File.file? 'Rakefile'
-  num_migrations = `git diff #{oldrev} #{newrev} --diff-filter=A --name-only`.split("\n").size
+  tasks = []
+
+  num_migrations = `git diff #{oldrev} #{newrev} --diff-filter=A --name-only -z db/migrate`.split("\0").size
   # run migrations if new ones have been added
-  run "#{rake_cmd} db:migrate RAILS_ENV=#{RAILS_ENV}" if num_migrations > 0
+  tasks << "db:migrate" if num_migrations > 0
+
+  # precompile assets
+  changed_assets = `git diff #{oldrev} #{newrev} --name-only -z app/assets`.split("\0")
+  tasks << "assets:precompile" if changed_assets.size > 0
+
+  run "#{rake_cmd} #{tasks.join(' ')} RAILS_ENV=#{RAILS_ENV}" if tasks.any?
 end
 
 # clear cached assets (unversioned/ignored files)

data/lib/git_deploy.rb

@@ -20,14 +20,15 @@ class GitDeploy < Thor
   end
 
   desc "setup", "Create the remote git repository and install push hooks for it"
-  method_option :shared, :aliases => '-g', :type => :boolean, :default => true
-  method_option :sudo, :aliases => '-s', :type => :boolean, :default => true
+  method_option :shared, :aliases => '-g', :type => :boolean, :default => false
+  method_option :sudo, :aliases => '-s', :type => :boolean, :default => false
   def setup
     sudo = options.sudo? ? "#{sudo_cmd} " : ''
 
-    if run_test("test -x #{deploy_to}")
+    unless run_test("test -x #{deploy_to}")
       run ["#{sudo}mkdir -p #{deploy_to}"] do |cmd|
         cmd << "#{sudo}chown $USER #{deploy_to}" if options.sudo?
+        cmd
       end
     end
 
@@ -54,18 +55,40 @@ class GitDeploy < Thor
   
   desc "restart", "Restarts the application on the server"
   def restart
-    run "cd #{deploy_to} && deploy/restart | tee -a log/deploy.log"
+    run "cd #{deploy_to} && deploy/restart 2>&1 | tee -a log/deploy.log"
+  end
+
+  desc "rerun", "Runs the `deploy/after_push' callback as if a new revision was pushed via git"
+  def rerun
+    run <<-BASH, :echo => false
+      bash -e -c '
+        cd '#{deploy_to}'
+        declare -a revs=( $(git rev-parse HEAD@{1} HEAD) )
+        deploy/after_push ${revs[@]} 2>&1 | tee -a log/deploy.log
+      '
+    BASH
   end
 
   desc "rollback", "Rolls back the checkout to before the last push"
   def rollback
-    run "cd #{deploy_to} && git reset --hard ORIG_HEAD"
-    invoke :restart
+    run <<-BASH, :echo => false
+      bash -e -c '
+        cd '#{deploy_to}'
+        declare -a revs=( $(git rev-parse HEAD HEAD@{1}) )
+        git reset --hard ${revs[1]}
+        callback=after_push
+        [ -x deploy/rollback ] && callback=rollback
+        deploy/$callback ${revs[@]} 2>&1 | tee -a log/deploy.log
+      '
+    BASH
   end
 
-  desc "log [n=20]", "Shows the last part of the deploy log on the server"
-  def log(n = 20)
-    run "tail -n#{n} #{deploy_to}/log/deploy.log"
+  desc "log", "Shows the last part of the deploy log on the server"
+  method_option :tail, :aliases => '-t', :type => :boolean, :default => false
+  method_option :lines, :aliases => '-l', :type => :numeric, :default => 20
+  def log(n = nil)
+    tail_args = options.tail? ? '-f' : "-n#{n || options.lines}"
+    run "tail #{tail_args} #{deploy_to}/log/deploy.log"
   end
 
   desc "upload <files>", "Copy local files to the remote app"
@@ -79,15 +102,3 @@ class GitDeploy < Thor
     }
   end
 end
-
-__END__
-Multiple hosts:
-# deploy:
-  invoke :code
-  command = ["cd #{deploy_to}"]
-  command << ".git/hooks/post-reset `cat .git/ORIG_HEAD` HEAD 2>&1 | tee -a log/deploy.log"
-
-# code:
-command = ["cd #{deploy_to}"]
-command << source.scm('fetch', remote, "+refs/heads/#{branch}:refs/remotes/origin/#{branch}")
-command << source.scm('reset', '--hard', "origin/#{branch}")

data/lib/hooks/post-receive.sh

@@ -1,9 +1,10 @@
-#!/usr/bin/env bash
+#!/bin/bash
+set -e
+
 if [ "$GIT_DIR" = "." ]; then
   # The script has been called as a hook; chdir to the working copy
   cd ..
-  GIT_DIR=.git
-  export GIT_DIR
+  unset GIT_DIR
 fi
 
 # try to obtain the usual system PATH
@@ -14,16 +15,17 @@ fi
 
 # get the current branch
 head="$(git symbolic-ref HEAD)"
-# abort if we're on a detached head
-[ "$?" != "0" ] && exit 1
 
 # read the STDIN to detect if this push changed the current branch
 while read oldrev newrev refname
 do
   [ "$refname" = "$head" ] && break
 done
+
 # abort if there's no update, or in case the branch is deleted
-[ -z "${newrev//0}" ] && exit
+if [ -z "${newrev//0}" ]; then
+  exit
+fi
 
 # check out the latest code into the working copy
 umask 002
@@ -40,11 +42,14 @@ if [ -z "${oldrev//0}" ]; then
   chmod 0664 $logfile $restart
 
   # init submodules
-  git submodule update --init | tee -a $logfile
+  git submodule update --recursive --init 2>&1 | tee -a $logfile
+
+  # execute the one-time setup hook
+  [ -x deploy/setup ] && deploy/setup $oldrev $newrev 2>&1 | tee -a $logfile
 else
   # log timestamp
   echo ==== $(date) ==== >> $logfile
 
-  # execute the deploy hook in background
-  [ -x deploy/after_push ] && nohup deploy/after_push $oldrev $newrev 1>>$logfile 2>>$logfile &
+  # execute the main deploy hook
+  [ -x deploy/after_push ] && deploy/after_push $oldrev $newrev 2>&1 | tee -a $logfile
 fi

data/spec/configuration_spec.rb

@@ -0,0 +1,48 @@
+require 'rspec/autorun'
+require 'git_deploy/configuration'
+
+describe GitDeploy::Configuration do
+
+  subject {
+    mod = described_class
+    obj = Object.new
+    opt = options
+    (class << obj; self; end).class_eval do
+      include mod
+      mod.private_instance_methods.each {|m| public m }
+      define_method(:options) { opt }
+    end
+    obj
+  }
+
+  let(:options) { {:remote => 'production'} }
+
+  def stub_git_config(cmd, value)
+    subject.git_config[cmd] = value
+  end
+
+  def stub_remote_url(url, remote = options[:remote])
+    stub_git_config("remote -v", "#{remote}\t#{url} (fetch)")
+  end
+
+  describe "extracting user/host from remote url" do
+    context "ssh url" do
+      before { stub_remote_url 'ssh://jon%20doe@example.com:88/path/to/app' }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_port) { should eq(88) }
+      its(:remote_user) { should eq('jon doe') }
+      its(:deploy_to)   { should eq('/path/to/app') }
+    end
+
+    context "scp-style" do
+      before { stub_remote_url 'git@example.com:/path/to/app' }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_port) { should be_nil }
+      its(:remote_user) { should eq('git') }
+      its(:deploy_to)   { should eq('/path/to/app') }
+    end
+  end
+
+end

metadata

@@ -1,49 +1,64 @@
 --- !ruby/object:Gem::Specification
 name: git-deploy
 version: !ruby/object:Gem::Version
-  version: 0.5.0
   prerelease: 
+  version: 0.6.0
 platform: ruby
 authors:
 - Mislav Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-04 00:00:00.000000000 Z
+date: 2013-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.6
   name: thor
-  requirement: &70292395458180 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70292395458180
+        version: 0.14.6
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.6
   name: net-ssh
-  requirement: &70292395455260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70292395455260
+        version: 2.6.6
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
   name: net-scp
-  requirement: &70292395453880 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70292395453880
+        version: 1.1.0
 description: A tool to install useful git hooks on your remote repository to enable
   push-based, Heroku-like deployment on your host.
 email: mislav.marohnic@gmail.com
@@ -61,10 +76,12 @@ files:
 - lib/git_deploy/templates/restart.sh
 - lib/git_deploy.rb
 - lib/hooks/post-receive.sh
+- spec/configuration_spec.rb
 - README.markdown
 - LICENSE
 homepage: https://github.com/mislav/git-deploy
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -83,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple git push-based application deployment