fletcherm-git-deploy 0.3.0

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,111 @@
+Capistrano strategy for smart git deployment
+============================================
+
+Let's set up a straightforward, [Heroku][]-style, push-based deployment, shall we? The goal is that our deployment looks like this:
+
+    $ git push origin production
+
+Assumptions are that you are using git for your Rails app and Passenger on the server. For now, we're going to deploy on a single host.
+
+To get started, install the "git-deploy" gem from Gemcutter.org.
+
+
+Considerations
+--------------
+
+This is not "yet another Capistrano strategy". Capistrano is only used for setup, after which it's all git hooks (see detailed description in "Deployment"). This actually replaces the default Capistrano recipe (which is not loaded) with only a basic set of tasks. If you have more advanced deployment (multiple hosts, many "after deploy" hooks) then this library cannot suit your needs at present.
+
+
+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 "origin", but it can be whatever you wish ("online", "website", or other).
+    
+        $ git remote add origin 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.  Create/overwrite the following files in your project:
+    
+    **config/deploy.rb** (entire file):
+    
+        # set to the name of git remote you intend to deploy to
+        set :remote, "origin"
+        # specify the deployment branch
+        set :branch, "master"
+        # specify the RAILS_ENV used by db:migrate. defaults to production
+        set :environment, "staging"
+        # sudo will only be used to create the deployment directory
+        set :use_sudo, true
+        # the remote host is read automatically from your git remote specification
+        server remote_host, :app, :web, :db, :primary => true
+    
+    **Capfile**:
+    
+        require 'git_deploy'
+        load 'config/deploy'
+    
+    Test it by running `cap -T`. You should see several deploy tasks listed.
+
+3.  Run the setup task:
+    
+        $ cap deploy:setup
+    
+    This will initialize a git repository in the target directory, install the push hook and push the branch you specified to the server.
+
+4.  Login to your server to perform necessary one-time administrative operations. This might include:
+    * set up the Apache/nginx virtual host for this application;
+    * check out the branch which you will push production code into (often this is "production");
+    * check your config/database.yml and create or import the production database.
+
+
+Deployment
+----------
+
+After you've set everything up, visiting "http://example.com" in your browser should show your app up and running. Subsequent deployments are done simply by pushing to the branch that is currently checked out on our server (see step 4.). The branch is by default "master", but it's suggested to have production code in another branch like "production" or other. This, of course, depends on your git workflow.
+
+We've reached our goal; our deployment now looks like:
+
+    $ git push origin production
+
+In fact, running "cap deploy" does exactly this. So what does it do?
+
+The "deploy:setup" task installed a couple of hooks in the remote git repository: "post-receive" and "post-reset". The former is a git hook which is invoked after every push to your server, while the latter is a *custom* hook that's called asynchronously by "post-receive" when we updated the deployment branch. This is how your working copy on the server is kept up-to-date.
+
+Thus, on first push your server automatically:
+
+1. creates the "log" and "tmp" directories;
+2. copies "config/database.example.yml" or "config/database.yml.example" to "config/database.yml".
+
+On every subsequent deploy, the "post-reset" script analyzes changes and:
+
+1. clears cached css and javascript assets if any versioned files under "public/stylesheets" and "public/javascripts" have changed, respectively;
+2. runs "rake db:migrate" if new migrations have been added;
+3. sync submodule urls if ".gitmodules" file has changed;
+4. initialize and update submodules;
+5. touches "tmp/restart.txt" if app restart is needed.
+
+Finally, these are the conditions that dictate an app restart:
+
+1. css/javascript assets have been cleared;
+2. the database has migrated;
+3. one or more files/submodules under "app", "config", "lib", "public", or "vendor" changed.
+
+The output of "post-reset" is logged to "log/deploy.log" in your application.
+
+It's worth remembering that "post-reset" is done asynchronously from your push operation. This is because migrating the database and updating submodules might take a long time and we don't want to wait for all that while we're doing 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, depending on what you pushed.
+
+
+In the future
+-------------
+
+Next steps for this library are:
+
+* Support for deployment on multiple hosts. This is a slightly different strategy based on git pull instead of push; something in-between regular "remote cache" strategy and the aforementioned
+* Better configurability
+* Steps forward to supporting more existing 3rd-party Capistrano tasks, like that of the EngineYard gem
+* Support for multiple environments on the same server (production, staging, continuous integration, etc.) sharing the same git repo, so you don't have to push same objects twice
+* Automatic submodule conflict resolving
+
+
+[heroku]: http://heroku.com/

data/lib/git_deploy.rb

@@ -0,0 +1,126 @@
+require 'capistrano/recipes/deploy/scm/git'
+
+Capistrano::Configuration.instance(true).load do
+  def _cset(name, *args, &block)
+    unless exists?(name)
+      set(name, *args, &block)
+    end
+  end
+
+  _cset(:application) { abort "Please specify the name of your application, set :application, 'foo'" }
+  _cset :remote, "origin"
+  _cset :branch, "master"
+  _cset :environment, "production"
+
+  _cset(:multiple_hosts) { roles.values.map{ |v| v.servers}.flatten.uniq.size > 1 }
+  _cset(:repository)  { `#{ source.local.scm('config', "remote.#{remote}.url") }`.chomp }
+  _cset(:remote_host) { repository.split(':', 2).first }
+  _cset(:deploy_to)   { repository.split(':', 2).last }
+  _cset(:run_method)  { fetch(:use_sudo, true) ? :sudo : :run }
+  _cset :group_writeable, false
+
+  _cset(:current_branch) { File.read('.git/HEAD').chomp.split(' refs/heads/').last }
+  _cset(:revision) { branch }
+  _cset(:source)   { Capistrano::Deploy::SCM::Git.new(self) }
+
+
+  # If :run_method is :sudo (or :use_sudo is true), this executes the given command
+  # via +sudo+. Otherwise is uses +run+. If :as is given as a key, it will be
+  # passed as the user to sudo as, if using sudo. If the :as key is not given,
+  # it will default to whatever the value of the :admin_runner variable is,
+  # which (by default) is unset.
+  def try_sudo(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    command = args.shift
+    raise ArgumentError, "too many arguments" if args.any?
+
+    as = options.fetch(:as, fetch(:admin_runner, nil))
+    
+    if command
+      invoke_command(command, :via => run_method, :as => as)
+    elsif :sudo == run_method
+      sudo(:as => as)
+    else
+      ""
+    end
+  end
+
+  namespace :deploy do
+    desc "Deploys your project."
+    task :default do
+      unless multiple_hosts
+        push
+      else
+        code
+        command = ["cd #{deploy_to}"]
+        command << ".git/hooks/post-reset `cat .git/ORIG_HEAD` HEAD 2>&1 | tee -a log/deploy.log"
+        
+        run command.join(' && ')
+      end
+    end
+
+    task :push do
+      system source.local.scm('push', remote, "#{revision}:#{branch}")
+    end
+
+    task :code do
+      command = ["cd #{deploy_to}"]
+      command << source.scm('fetch', remote, "+refs/heads/#{branch}:refs/remotes/origin/#{branch}")
+      command << source.scm('reset', '--hard', "origin/#{branch}")
+      
+      run command.join(' && ')
+    end
+
+    desc "Prepares servers for deployment."
+    task :setup do
+      shared = fetch(:group_writeable)
+      
+      command = ["#{try_sudo} mkdir -p #{deploy_to}"]
+      command << "#{try_sudo} chown $USER #{deploy_to}" if :sudo == run_method
+      command << "cd #{deploy_to}"
+      command << "chmod g+w ." if shared
+      command << "git init #{shared ? '--shared' : ''}"
+      command << "sed -i'' -e 's/master/#{branch}/' .git/HEAD" unless branch == 'master'
+      command << "git config --bool receive.denyNonFastForwards false" if shared
+      command << "git config receive.denyCurrentBranch ignore"
+      run command.join(' && ')
+      
+      install_hooks
+      push
+    end
+
+    task :install_hooks do
+      dir = File.dirname(__FILE__) + '/hooks'
+      remote_dir = "#{deploy_to}/.git/hooks"
+
+      top.upload "#{dir}/post-reset.rb", "#{remote_dir}/post-reset"
+      top.upload "#{dir}/post-receive.rb", "#{remote_dir}/post-receive"
+      run "chmod +x #{remote_dir}/post-receive #{remote_dir}/post-reset"
+
+      # Rewrite the post-reset hook to use the configured environment
+      run "sed -i'' 's/^environment_placeholder$/RAILS_ENV = \"#{environment}\"/' #{remote_dir}/post-reset"
+    end
+
+    desc "Restarts your Passenger application."
+    task :restart, :roles => :app do
+      run "touch #{deploy_to}/tmp/restart.txt"
+    end
+
+    desc <<-DESC
+      Copy files to the currently deployed version. Use a comma-separated \
+      list in FILES to specify which files to upload.
+
+      Note that unversioned files on your server are likely to be \
+      overwritten by the next push. Always persist your changes by committing.
+
+        $ cap deploy:upload FILES=templates,controller.rb
+        $ cap deploy:upload FILES='config/apache/*.conf'
+    DESC
+    task :upload do
+      files = (ENV["FILES"] || "").split(",").map { |f| Dir[f.strip] }.flatten
+      abort "Please specify at least one file or directory to update (via the FILES environment variable)" if files.empty?
+
+      files.each { |file| top.upload(file, File.join(deploy_to, file)) }
+    end
+  end
+end

data/lib/hooks/post-receive.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+if ENV['GIT_DIR'] == '.'
+  # this means the script has been called as a hook, not manually.
+  # get the proper GIT_DIR so we can descend into the working copy dir;
+  # if we don't then `git reset --hard` doesn't affect the working tree.
+  Dir.chdir('..')
+  ENV['GIT_DIR'] = '.git'
+end
+
+# find out the current branch
+head = File.read('.git/HEAD').chomp
+# abort if we're on a detached head
+exit unless head.sub!('ref: ', '')
+
+oldrev = newrev = nil
+null_ref = '0' * 40
+
+# read the STDIN to detect if this push changed the current branch
+while newrev.nil? and gets
+  # each line of input is in form of "<oldrev> <newrev> <refname>"
+  revs = $_.split
+  oldrev, newrev = revs if head == revs.pop
+end
+
+# abort if there's no update, or in case the branch is deleted
+exit if newrev.nil? or newrev == null_ref
+
+# update the working copy
+`git reset --hard`
+
+if oldrev == null_ref
+  # this is the first push; this branch was just created
+  require 'fileutils'
+  FileUtils.mkdir_p %w(log tmp)
+  config = 'config/database.yml'
+  
+  unless File.exists?(config)
+    # install the database config from the example file
+    example = ['config/database.example.yml', config + '.example'].find { |f| File.exists? f }
+    FileUtils.cp example, config if example
+  end
+else
+  logfile = 'log/deploy.log'
+  # log timestamp
+  File.open(logfile, 'a') { |log| log.puts "==== #{Time.now} ====" }
+  # start the post-reset hook in background
+  system %(nohup .git/hooks/post-reset #{oldrev} #{newrev} 1>>#{logfile} 2>>#{logfile} &)
+end

data/lib/hooks/post-reset.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+environment_placeholder
+oldrev, newrev = ARGV
+$stdout.sync = true
+
+def parse_configuration(file)
+  config = {}
+  current = nil
+
+  File.open(file).each_line do |line|
+    case line
+    when /^\[(\w+)(?: "(.+)")\]/
+      key, subkey = $1, $2
+      current = (config[key] ||= {})
+      current = (current[subkey] ||= {}) if subkey
+    else
+      key, value = line.strip.split(' = ')
+      current[key] = value
+    end
+  end
+  
+  config
+end
+
+class Array
+  # scans the list of files to see if any of them are under the given path
+  def any_in_dir?(dir)
+    if Array === dir
+      exp = %r{^(?:#{dir.join('|')})/}
+      any? { |file| file =~ exp }
+    else
+      dir += '/'
+      any? { |file| file.index(dir) == 0 }
+    end
+  end
+end
+
+# get a list of files that changed
+changes = `git diff #{oldrev} #{newrev} --diff-filter=ACDMR --name-status`.split("\n")
+
+# make a hash of files that changed and how they changed
+changes_hash = changes.inject(Hash.new { |h, k| h[k] = [] }) do |hash, line|
+  modifier, filename = line.split("\t", 2)
+  hash[modifier] << filename
+  hash
+end
+
+# create an array of files added, copied, modified or renamed
+modified_files = %w(A C M R).inject([]) { |files, bit| files.concat changes_hash[bit] }
+added_files = changes_hash['A'] # added
+deleted_files = changes_hash['D'] # deleted
+changed_files = modified_files + deleted_files # all
+puts "files changed: #{changed_files.size}"
+
+cached_assets_cleared = false
+
+# detect modified asset dirs
+asset_dirs = %w(public/stylesheets public/javascripts).select do |dir|
+  # did any on the assets under this dir change?
+  changed_files.any_in_dir?(dir)
+end
+
+unless asset_dirs.empty?
+  # clear cached assets (unversioned/ignored files)
+  system %(git clean -x -f -- #{asset_dirs.join(' ')})
+  cached_assets_cleared = true
+end
+
+# run migrations when new ones added
+if new_migrations = added_files.any_in_dir?('db/migrate')
+  system %(rake db:migrate RAILS_ENV=#{RAILS_ENV})
+end
+
+if modified_files.include?('.gitmodules')
+  # initialize new submodules
+  system %(git submodule init)
+  # sync submodule remote urls in case of changes
+  config = parse_configuration('.gitmodules')
+
+  if config['submodule']
+    config['submodule'].values.each do |submodule|
+      path = submodule['path']
+      subconf = "#{path}/.git/config"
+
+      if File.exists? subconf
+        old_url = `git config -f "#{subconf}" remote.origin.url`.chomp
+        new_url = submodule['url']
+        unless old_url == new_url
+          puts "changing #{path.inspect} URL:\n  #{old_url.inspect} → #{new_url.inspect}"
+          `git config -f "#{subconf}" remote.origin.url "#{new_url}"`
+        end
+      else
+        $stderr.puts "a submodule in #{path.inspect} doesn't exist"
+      end
+    end
+  end
+end
+# update existing submodules
+system %(git submodule update)
+
+# have bundler unpack new gems. Honor config/build_options.yml if it is present.
+if modified_files.include?("Gemfile")
+  base_command = "gem bundle --cached"
+  build_options = "config/build_options.yml"
+  if File.exists? build_options
+    system %(#{base_command} --build-options #{build_options})
+  else
+    system base_command
+  end
+end
+
+# clean unversioned files from vendor (e.g. old submodules)
+system %(git clean -d -f vendor)
+
+# determine if app restart is needed
+if cached_assets_cleared or new_migrations or changed_files.any_in_dir?(%w(app config lib public vendor))
+  require 'fileutils'
+  # tell Passenger to restart this app
+  FileUtils.touch 'tmp/restart.txt'
+  puts "restarting Passenger app"
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: fletcherm-git-deploy
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-09 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.9
+    version: 
+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
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/git_deploy.rb
+- lib/hooks/post-receive.rb
+- lib/hooks/post-reset.rb
+- README.markdown
+- LICENSE
+has_rdoc: false
+homepage: http://github.com/mislav/git-deploy
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple git push-based application deployment
+test_files: []
+