osbro-git-deploy 0.5.5

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Mislav Marohnić
+
+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.markdown

@@ -0,0 +1,86 @@
+Easy git deployment
+===================
+
+Straightforward, [Heroku][]-style, push-based deployment. Your deploys will look like this:
+
+    $ git push production master
+
+To get started, install the "git-deploy" gem.
+
+    $ gem install git-deploy
+
+
+What application frameworks/languages 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.
+
+Your deployment is customized with per-project callback scripts which can be written in any language.
+
+The assumption is that you're deploying to a single host to which you connect over SSH using public/private key authentication.
+
+
+Setup steps
+-----------
+
+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.
+
+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.
+
+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.
+
+4.  Push the code.
+
+        $ 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.
+
+
+Deployment
+----------
+
+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:
+
+    $ 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.
+
+Deployments are logged to "log/deploy.log" in your application.
+
+On every deploy, the "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;
+3. runs `rake db:migrate` if new migrations have been added;
+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.
+
+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.
+
+These scripts are ordinary unix executable files. The ones which are generated for you are written in shell script and Ruby.
+
+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/

data/bin/git-deploy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'git_deploy'
+GitDeploy.start

data/lib/git_deploy.rb

@@ -0,0 +1,110 @@
+require 'thor'
+require 'net/ssh'
+require 'net/scp'
+
+class GitDeploy < Thor
+  LOCAL_DIR = File.expand_path('..', __FILE__)
+
+  require 'git_deploy/configuration'
+  require 'git_deploy/ssh_methods'
+  include Configuration
+  include SSHMethods
+
+  class_option :remote, :aliases => '-r', :type => :string, :default => 'origin'
+  class_option :noop, :aliases => '-n', :type => :boolean, :default => false
+  class_option :env, :aliases => '-e', :type => :string, :default => 'production'
+
+  desc "init", "Generates deployment customization scripts for your app"
+  def init
+    require 'git_deploy/generator'
+    Generator::start([])
+  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 => false
+  def setup
+    sudo = options.sudo? ? "#{sudo_cmd} " : ''
+
+    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
+
+    run [] do |cmd|
+      cmd << "chmod g+ws #{deploy_to}" if options.shared?
+      cmd << "cd #{deploy_to}"
+      cmd << "git init #{options.shared? ? '--shared' : ''}"
+      cmd << "sed -i'' -e 's/master/#{branch}/' .git/HEAD" unless branch == 'master'
+      cmd << "git config --bool receive.denyNonFastForwards false" if options.shared?
+      cmd << "git config receive.denyCurrentBranch ignore"
+    end
+
+    invoke :hooks
+  end
+
+  desc "hooks", "Installs git hooks to the remote repository"
+  def hooks
+    hooks_dir = File.join(LOCAL_DIR, 'hooks')
+    remote_dir = "#{deploy_to}/.git/hooks"
+    scp_upload "#{hooks_dir}/post-receive.sh" => "#{remote_dir}/post-receive"
+    run "sed -i'' -e 's/production/#{options[:env]}/' #{remote_dir}/post-receive" unless options[:env] == 'production'
+    run "chmod +x #{remote_dir}/post-receive"
+  end
+  
+  desc "restart", "Restarts the application on the server"
+  def restart
+    run "cd #{deploy_to} && deploy/restart | tee -a log/deploy.log"
+  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
+  end
+  
+  desc "tag", "Checkout the tag <tag>"
+  def tag(tag)
+    run "cd #{deploy_to} && git reset --hard && git checkout #{tag}"
+    restart
+  end
+
+  desc "reset", "Bring the remote up to date with the current branch"
+  def reset
+    run "cd #{deploy_to} && git reset --hard && git checkout master"
+    restart
+  end
+
+  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"
+  def upload(*files)
+    files = files.map { |f| Dir[f.strip] }.flatten
+    abort "Error: Specify at least one file to upload" if files.empty?
+
+    scp_upload files.inject({}) { |all, file|
+      all[file] = File.join(deploy_to, file)
+      all
+    }
+  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/git_deploy/configuration.rb

@@ -0,0 +1,81 @@
+class GitDeploy
+  module Configuration
+    private
+
+    def host
+      extract_host_and_user unless defined? @host
+      @host
+    end
+
+    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
+      end
+    end
+
+    def deploy_to
+      @deploy_to ||= remote_url.split(':').last
+    end
+
+    def branch
+      'master'
+    end
+
+    def git_config
+      @git_config ||= Hash.new do |cache, cmd|
+        git = ENV['GIT'] || 'git'
+        out = `#{git} #{cmd}`
+        if $?.success? then cache[cmd] = out.chomp
+        else cache[cmd] = nil
+        end
+        cache[cmd]
+      end
+    end
+
+    def remote_urls(remote)
+      git_config["config --get-all remote.#{remote}.url"].to_s.split("\n")
+    end
+
+    def remote_url(remote = options[:remote])
+      @remote_url ||= {}
+      @remote_url[remote] ||= begin
+        url = remote_urls(remote).first
+        if url.nil?
+          abort "Error: Remote url not found for remote #{remote.inspect}"
+        elsif url =~ /\bgithub\.com\b/
+          abort "Error: Remote url for #{remote.inspect} points to GitHub. Can't deploy there!"
+        end
+        url
+      end
+    end
+
+    def current_branch
+      git_config['symbolic-ref -q HEAD']
+    end
+
+    def tracked_branch
+      branch = current_branch && tracked_for(current_branch)
+      normalize_branch(branch) if branch
+    end
+
+    def normalize_branch(branch)
+      branch.sub('refs/heads/', '')
+    end
+
+    def remote_for(branch)
+      git_config['config branch.%s.remote' % normalize_branch(branch)]
+    end
+
+    def tracked_for(branch)
+      git_config['config branch.%s.merge' % normalize_branch(branch)]
+    end
+  end
+end

data/lib/git_deploy/generator.rb

@@ -0,0 +1,28 @@
+require 'thor/group'
+
+class GitDeploy::Generator < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.expand_path('../templates', __FILE__)
+  end
+
+  def copy_main_hook
+    copy_hook 'after_push.sh', 'deploy/after_push'
+  end
+
+  def copy_restart_hook
+    copy_hook 'restart.sh', 'deploy/restart'
+  end
+
+  def copy_restart_callbacks
+    copy_hook 'before_restart.rb', 'deploy/before_restart'
+  end
+
+  private
+
+  def copy_hook(template, destination)
+    copy_file template, destination
+    chmod destination, 0744 unless File.executable? destination
+  end
+end

data/lib/git_deploy/ssh_methods.rb

@@ -0,0 +1,99 @@
+class GitDeploy
+  module SSHMethods
+    private
+
+    def sudo_cmd
+      "sudo -p 'sudo password: '"
+    end
+
+    def system(*args)
+      puts "[local] $ " + args.join(' ').gsub(' && ', " && \\\n  ")
+      super unless options.noop?
+    end
+
+    def run(cmd = nil)
+      cmd = yield(cmd) if block_given?
+      cmd = cmd.join(' && ') if Array === cmd
+      puts "[#{options[:remote]}] $ " + cmd.gsub(' && ', " && \\\n  ")
+
+      unless options.noop?
+        status, output = ssh_exec cmd do |ch, stream, data|
+          case stream
+          when :stdout then $stdout.print data
+          when :stderr then $stderr.print data
+          end
+          ch.send_data(askpass) if data =~ /^sudo password: /
+        end
+        output
+      end
+    end
+
+    def run_test(cmd)
+      status, output = ssh_exec(cmd) { }
+      status == 0
+    end
+
+    def ssh_exec(cmd, &block)
+      status = nil
+      output = ''
+
+      channel = ssh_connection.open_channel do |chan|
+        chan.exec(cmd) do |ch, success|
+          raise "command failed: #{cmd.inspect}" unless success
+          # ch.request_pty
+
+          ch.on_data do |c, data|
+            output << data
+            yield(c, :stdout, data)
+          end
+
+          ch.on_extended_data do |c, type, data|
+            output << data
+            yield(c, :stderr, data)
+          end
+
+          ch.on_request "exit-status" do |ch, data|
+            status = data.read_long
+          end
+        end
+      end
+
+      channel.wait
+      [status, output]
+    end
+
+    # TODO: use Highline for cross-platform support
+    def askpass
+      tty_state = `stty -g`
+      system 'stty raw -echo -icanon isig' if $?.success?
+      pass = ''
+      while char = $stdin.getbyte and not (char == 13 or char == 10)
+        if char == 127 or char == 8
+          pass[-1,1] = '' unless pass.empty?
+        else
+          pass << char.chr
+        end
+      end
+      pass
+    ensure
+      system "stty #{tty_state}" unless tty_state.empty?
+    end
+
+    def scp_upload(files)
+      channels = []
+      files.each do |local, remote|
+        puts "FILE: [local] #{local.sub(LOCAL_DIR + '/', '')}  ->  [#{options[:remote]}] #{remote}"
+        channels << ssh_connection.scp.upload(local, remote) unless options.noop?
+      end
+      channels.each { |c| c.wait }
+    end
+
+    def ssh_connection
+      @ssh ||= begin
+        ssh = Net::SSH.start(host, remote_user)
+        at_exit { ssh.close }
+        ssh
+      end
+    end
+  end
+end

data/lib/git_deploy/templates/after_push.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -e
+oldrev=$1
+newrev=$2
+
+run() {
+  [ -x $1 ] && $1 $oldrev $newrev
+}
+
+echo files changed: $(git diff $oldrev $newrev --diff-filter=ACDMR --name-only | wc -l)
+
+umask 002
+
+git submodule init && git submodule sync && git submodule update
+
+run deploy/before_restart
+run deploy/restart && run deploy/after_restart

data/lib/git_deploy/templates/before_restart.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+oldrev, newrev = ARGV
+
+def run(cmd)
+  exit($?.exitstatus) unless system "umask 002 && #{cmd}"
+end
+
+RAILS_ENV   = ENV['RAILS_ENV'] || 'production'
+use_bundler = File.file? 'Gemfile'
+rake_cmd    = use_bundler ? 'bundle exec rake' : 'rake'
+
+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'
+  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
+  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)
+run "git clean -x -f -- public/stylesheets public/javascripts"
+
+# clean unversioned files from vendor/plugins (e.g. old submodules)
+run "git clean -d -f -- vendor/plugins"

data/lib/git_deploy/templates/restart.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+touch tmp/restart.txt
+echo "restarting Passenger app"

data/lib/hooks/post-receive.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+if [ "$GIT_DIR" = "." ]; then
+  # The script has been called as a hook; chdir to the working copy
+  cd ..
+  GIT_DIR=.git
+  export GIT_DIR
+fi
+
+# try to obtain the usual system PATH
+if [ -f /etc/profile ]; then
+  PATH=$(source /etc/profile; echo $PATH)
+  export PATH
+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
+
+export RAILS_ENV=production
+export RACK_ENV=production
+
+# check out the latest code into the working copy
+umask 002
+git reset --hard
+
+logfile=log/deploy.log
+restart=tmp/restart.txt
+
+if [ -z "${oldrev//0}" ]; then
+  # this is the first push; this branch was just created
+  mkdir -p log tmp
+  chmod 0775 log tmp
+  touch $logfile $restart
+  chmod 0664 $logfile $restart
+
+  # init submodules
+  git submodule update --init | 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 &
+fi

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: osbro-git-deploy
+version: !ruby/object:Gem::Version 
+  hash: 1
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 5
+  version: 0.5.5
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+- Simon Brook
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: net-scp
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: A tool to install useful git hooks on your remote repository to enable push-based, Heroku-like deployment on your host.
+email: simon@obdev.co.uk
+executables: 
+- git-deploy
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/git-deploy
+- lib/git_deploy/configuration.rb
+- lib/git_deploy/generator.rb
+- lib/git_deploy/ssh_methods.rb
+- lib/git_deploy/templates/after_push.sh
+- lib/git_deploy/templates/before_restart.rb
+- lib/git_deploy/templates/restart.sh
+- lib/git_deploy.rb
+- lib/hooks/post-receive.sh
+- README.markdown
+- LICENSE
+has_rdoc: true
+homepage: https://github.com/osbornebrook/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 
+      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: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple git push-based application deployment
+test_files: []
+