app-deploy 0.6.0

data/CHANGES

@@ -0,0 +1,7 @@
+= app-deploy changes history
+
+== app-deploy 0.6.0 / 2009-12-14
+ * first release to gemcutter
+
+== app-deploy ? / 2008-12-10
+ * bundle as gem

data/README

@@ -0,0 +1,85 @@
+= app-deploy 0.6
+by Lin Jen-Shin (aka godfat-真常[http://godfat.org])
+  godfat (XD) godfat.org
+
+== LINKS:
+
+* github-project[http://github.com/godfat/app-deploy]
+
+== DESCRIPTION:
+
+ rake tasks for deployment
+
+== FEATURES:
+
+$ rake -T app
+(in /home/photos)
+rake app:daemon:restart[config]                        # restart the daemon cluster
+rake app:daemon:start[config]                          # start the daemon cluster
+rake app:daemon:stop[config]                           # stop the daemon cluster
+rake app:deploy                                        # deploy to master state
+rake app:deploy:after                                  # after deploy hook for you to override
+rake app:deploy:before                                 # before deploy hook for you to override
+rake app:gem:install                                   # install gems
+rake app:gem:reinstall                                 # reinstall gems
+rake app:gem:uninstall                                 # uninstall gems
+rake app:git[cmd]                                      # generic git cmd walk through all dependency
+rake app:git:clone                                     # clone repoitory from github
+rake app:git:pull                                      # pull anything from origin
+rake app:git:stash                                     # make anything reflect master state
+rake app:git:submodule                                 # init and update submodule
+rake app:install                                       # install this application
+rake app:install:after                                 # after install hook for you to override
+rake app:install:before                                # before install hook for you to override
+rake app:install:remote[hosts,git,cd,branch,script]    # remote installation
+rake app:install:remote:setup[user,file,hosts,script]  # upload a tarball and untar to user home, then useradd
+rake app:install:remote:sh[hosts,script]               # invoke a shell script on remote machines
+rake app:install:remote:upload[file,hosts,path]        # upload a file to remote machines
+rake app:install:remote:useradd[user,hosts,script]     # create a user on remote machines
+rake app:nginx:reload                                  # reload config
+rake app:nginx:restart                                 # restart nginx
+rake app:nginx:start[config,nginx]                     # start nginx, default config is config/nginx.conf, nginx is /usr/sbin/nginx
+rake app:nginx:stop[timeout]                           # stop nginx
+rake app:rack:restart[config]                          # restart the rack cluster
+rake app:rack:start[config]                            # start the rack cluster
+rake app:rack:stop[config]                             # stop the rack cluster
+rake app:server:restart                                # please define your server:restart task
+
+== SYNOPSIS:
+
+ see
+   - example/Rakefile
+   - example/rack_cluster.yaml
+   - example/daemon_cluster.yaml
+
+== REQUIREMENTS:
+
+* ruby 1.8.7+
+* [required] rake
+* [optional] rubygems for rubygems task
+* [optional] git      for git      task
+* [optional] nginx    for nginx    task
+* [optional] rack and daemons for rack-cluster task
+* [optional] thin     for thin     task
+
+== INSTALL:
+
+* gem install app-deploy
+
+== LICENSE:
+
+Apache License 2.0
+
+Copyright (c) 2008-2009, Lin Jen-Shin (aka godfat 真常)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+ensure_in_path 'lib'
+proj = 'app-deploy'
+require "#{proj}/version"
+
+Bones{
+  version AppDeploy::VERSION
+
+  # ruby_opts [''] # silence warning, too many in addressable and/or dm-core
+
+  name    proj
+  url     "http://github.com/godfat/#{proj}"
+  authors 'Lin Jen-Shin (aka godfat 真常)'
+  email   'godfat (XD) godfat.org'
+
+  history_file   'CHANGES'
+   readme_file   'README'
+   ignore_file   '.gitignore'
+  rdoc.include   ['\w+']
+}
+
+CLEAN.include Dir['**/*.rbc']
+
+task :default do
+  Rake.application.options.show_task_pattern = /./
+  Rake.application.display_tasks_and_comments
+end

data/TODO

@@ -0,0 +1,10 @@
+= app-deploy todo list
+
+* adding sending signal to cluster
+
+* escape \" and \' in options?
+* extract rack-cluster
+* detect binding to port succeeded or not
+* fix default options for rack-cluster
+
+* provide a way to hide tasks we don't care

data/app-deploy.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{app-deploy}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Lin Jen-Shin (a.k.a. godfat \347\234\237\345\270\270)"]
+  s.date = %q{2009-02-09}
+  s.description = %q{rake tasks for deployment}
+  s.email = %q{godfat (XD) godfat.org}
+  s.extra_rdoc_files = ["CHANGES", "README", "TODO", "app-deploy.gemspec", "example/daemon_cluster.yaml", "example/rack_cluster.yaml", "lib/app-deploy/daemon.rake", "lib/app-deploy/deploy.rake", "lib/app-deploy/gem.rake", "lib/app-deploy/git.rake", "lib/app-deploy/install.rake", "lib/app-deploy/merb.rake", "lib/app-deploy/mongrel.rake", "lib/app-deploy/nginx.rake", "lib/app-deploy/rack.rake", "lib/app-deploy/server.rake", "lib/app-deploy/thin.rake"]
+  s.files = ["CHANGES", "README", "Rakefile", "TODO", "app-deploy.gemspec", "example/Rakefile", "example/daemon_cluster.yaml", "example/rack_cluster.yaml", "lib/app-deploy.rb", "lib/app-deploy/daemon.rake", "lib/app-deploy/daemon.rb", "lib/app-deploy/daemon_cluster.rb", "lib/app-deploy/deploy.rake", "lib/app-deploy/gem.rake", "lib/app-deploy/git.rake", "lib/app-deploy/install.rake", "lib/app-deploy/merb.rake", "lib/app-deploy/mongrel.rake", "lib/app-deploy/nginx.rake", "lib/app-deploy/rack.rake", "lib/app-deploy/rack_cluster.rb", "lib/app-deploy/server.rake", "lib/app-deploy/thin.rake", "lib/app-deploy/utils.rb", "lib/app-deploy/version.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/godfat/app-deploy}
+  s.rdoc_options = ["--diagram", "--charset=utf-8", "--inline-source", "--line-numbers", "--promiscuous", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{ludy}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{rake tasks for deployment}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bones>, [">= 2.4.0"])
+    else
+      s.add_dependency(%q<bones>, [">= 2.4.0"])
+    end
+  else
+    s.add_dependency(%q<bones>, [">= 2.4.0"])
+  end
+end

data/example/Rakefile

@@ -0,0 +1,113 @@
+
+begin
+  require 'app-deploy'
+rescue LoadError
+  puts "app-deploy not found, automaticly downloading and installing..."
+
+  gem_cmd = "#{Gem.ruby} #{`which gem`.strip}"
+  gem_opt = '--user-install --no-ri --no-rdoc'
+  gem_int = "#{gem_cmd} install #{gem_opt}"
+
+  sh "#{gem_int} bones" # need bones to build app-deploy
+
+  sh 'git clone git://github.com/godfat/app-deploy.git app-deploy'
+  Dir.chdir 'app-deploy'
+
+  sh 'rake clobber'
+  sh 'rake gem:package'
+  sh "#{gem_int} --local pkg/app-deploy-*.gem"
+
+  Dir.chdir '..'
+  Gem.refresh
+  require 'app-deploy'
+end
+
+task :default do
+  Rake.application.options.show_task_pattern = /./
+  Rake.application.display_tasks_and_comments
+end
+
+# install gem from rubyforge
+AppDeploy.dependency_gem :gem => 'bones'
+
+# install gem from github
+AppDeploy.dependency_gem :gem => 'pagfiy', :source => 'http://gems.github.com'
+
+# clone and build and install gem from github with bones
+AppDeploy.dependency_gem :github_user    => 'godfat',
+                         :github_project => 'friendly_format',
+                         :task_gem       => 'bones'
+
+# same as above but with hoe, and select a git clone path.
+AppDeploy.dependency_gem :github_user    => 'godfat',
+                         :github_project => 'mogilefs-client',
+                         :task_gem       => 'hoe',
+                         :git_path       => 'tmp/mogilefs-client'
+
+# same as above but with custom install script
+AppDeploy.dependency_gem :github_user    => 'godfat',
+                         :github_project => 'app-deploy',
+                         :git_path       => 'tmp/app-deploy' do
+  sh 'rake clobber'
+  sh 'rake gem:package'
+  sh 'gem install pkg/app-deploy-*.gem'
+end
+
+# no gem to install, just clone it
+AppDeploy.dependency     :github_user    => 'godfat',
+                         :github_project => 'in_place_editing',
+                         :git_path       => 'tmp/vendor/plugins/in_place_editing'
+
+%w[ rack rails daemons rmagick passenger
+    dm-core dm-types dm-timestamps dm-aggregates
+    mogilefs-client memcache-client rubycas-client ].each{ |name|
+  AppDeploy.dependency_gem(:gem => name)
+}
+
+namespace :app do
+  namespace :install do
+    # before install hook
+    task :before do
+      # explicit install gem, ignore gem that was already installed
+      AppDeploy.install_gem(:gem => 'hoe')
+    end
+
+    # after install hook
+    task :after do
+      # explicit uninstall gem, ignore gem that was not installed
+      AppDeploy.uninstall_gem(:gem => 'zzz')
+
+      # install passenger nginx module
+      sh("#{Gem.user_dir}/bin/" +
+         Gem.default_exec_format % 'passenger-install-nginx-module' +
+         " --auto --auto-download --prefix=#{Dir.pwd}/nginx")
+    end
+  end
+
+  namespace :server do
+    # use thin as server
+    task :restart => 'thin:restart'
+
+    [:start, :stop, :restart, :reload].each{ |cmd|
+      desc "#{cmd} nginx(passenger)"
+      task cmd do
+        ENV['config'] = '/home/app/config/nginx.conf'
+        ENV['nginx']  = '/home/app/nginx/sbin/nginx'
+        Rake::Task["app:nginx:#{cmd}"].invoke
+      end
+    }
+  end
+end
+
+begin # prevent lacking rails to stop rake app:install to install rails
+  gem 'rails'
+
+  require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+  require 'rake'
+  require 'rake/testtask'
+  require 'rake/rdoctask'
+
+  require 'tasks/rails'
+rescue LoadError
+end

data/example/bin/install.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+rake app:install
+./bin/start.sh

data/example/bin/remote_install.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+rake app:install:remote:setup user=cas file=ssh.tgz hosts=root@10.0.0.101,root@10.0.0.106,root@10.0.0.111,root@10.0.0.116,root@10.0.0.121
+
+rake app:install:remote hosts=cas@10.0.0.101,cas@10.0.0.106,cas@10.0.0.111,cas@10.0.0.116,cas@10.0.0.121 \
+                          git=git@github.com:godfat/cas.git \
+                           cd=~ \
+                       branch=origin/stable \
+                       script=./bin/install.sh

data/example/bin/remote_update.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+rake app:install:remote:sh hosts=cas@10.0.0.101,cas@10.0.0.106,cas@10.0.0.111,cas@10.0.0.116,cas@10.0.0.121 script=./bin/update.sh

data/example/bin/start.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+rake app:deploy

data/example/bin/update.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+git fetch
+git stash
+git checkout origin/stable
+git submodule update
+./bin/start.sh

data/example/daemon_cluster.yaml

@@ -0,0 +1,10 @@
+---
+pid: tmp/pids/daemon.pid
+log: log/daemon.log
+chdir: /home/photos
+servers: 5
+user: photos
+group: photos
+ruby: ruby
+script: -I lib daemon/bin/cron.rb
+args: daily

data/example/rack_cluster.yaml

@@ -0,0 +1,13 @@
+---
+pid: tmp/pids/web_server_rack.pid
+log: log/web_server_rack.log
+port: 3000
+chdir: /home/photos
+host: 0.0.0.0
+servers: 5
+user: photos
+group: photos
+rackup: web_server/config.ru
+server: thin
+environment: none
+delay: 5

data/lib/app-deploy/daemon.rake

@@ -0,0 +1,33 @@
+
+require 'app-deploy/daemon_cluster'
+
+namespace :app do
+  namespace :daemon do
+
+    desc 'start the daemon cluster'
+    task :start, [:config] do |t, args|
+      path = args[:config] || 'config/daemon_cluster.yaml'
+      AppDeploy::DaemonCluster.each(path){ |config, cmd|
+        AppDeploy::DaemonCluster.start(config, cmd)
+      }
+    end
+
+    desc 'stop the daemon cluster'
+    task :stop, [:config] do |t, args|
+      path = args[:config] || 'config/daemon_cluster.yaml'
+      AppDeploy::DaemonCluster.each(path){ |config, cmd|
+        AppDeploy.term(config[:pid], config[:server])
+      }
+    end
+
+    desc 'restart the daemon cluster'
+    task :restart, [:config] do |t, args|
+      path = args[:config] || 'config/daemon_cluster.yaml'
+      AppDeploy::DaemonCluster.each(path){ |config, cmd|
+        AppDeploy.term(config[:pid], config[:server])
+        AppDeploy::DaemonCluster.start(config, cmd)
+      }
+    end
+
+  end # of rack
+end # of app

data/lib/app-deploy/daemon.rb

@@ -0,0 +1,64 @@
+
+require 'daemons'
+
+require 'etc'
+require 'fileutils'
+
+module AppDeploy
+
+  module Daemon
+    module_function
+    def daemonize pid_path, log_path, user, group, chdir
+      Dir.chdir(chdir) if chdir
+
+      user  ||= Etc.getpwuid(Process.uid).name
+      group ||= Etc.getpwuid(Process.gid).name
+
+      Daemon.change_privilege(user, group)
+
+      cwd = Dir.pwd
+      ::Daemonize.daemonize(log_path)
+      Dir.chdir(cwd)
+
+      Daemon.write_pid(pid_path)
+
+      at_exit{
+        puts "Stopping #{pid_path}..."
+        Daemon.remove_pid(pid_path)
+      }
+    end
+
+    # extracted from thin
+    # Change privileges of the process
+    # to the specified user and group.
+    def change_privilege user, group
+
+      uid, gid = Process.euid, Process.egid
+      target_uid = Etc.getpwnam(user).uid
+      target_gid = Etc.getgrnam(group).gid
+
+      if uid != target_uid || gid != target_gid
+        puts "Changing process privilege to #{user}:#{group}"
+
+        # Change process ownership
+        Process.initgroups(user, target_gid)
+        Process::GID.change_privilege(target_gid)
+        Process::UID.change_privilege(target_uid)
+      end
+
+    rescue Errno::EPERM => e
+      puts "Couldn't change user and group to #{user}:#{group}: #{e}"
+    end
+
+    def write_pid path
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w'){ |f| f.write(Process.pid) }
+      File.chmod(0644, path)
+    end
+
+    def remove_pid path
+      File.delete(path) if File.exist?(path)
+    end
+
+  end # of Daemon
+end # of AppDeploy

data/lib/app-deploy/daemon_cluster.rb

@@ -0,0 +1,62 @@
+
+module AppDeploy
+
+  module DaemonCluster
+    module_function
+    def each path
+      config_orig = YAML.load(File.read(path)).inject({}){ |h, kv|
+        k, v = kv
+        h[k.to_sym] = v
+        h
+      }
+
+      config_orig = { :servers => 1,
+                      :log     => 'log/daemon_cluster.log',
+                      :pid     => 'tmp/pids/daemon_cluster.pid'
+                    }.merge(config_orig)
+
+      config_orig[:servers].times{ |n|
+        config = config_orig.dup
+
+        config[:num] = n
+        config[:pid] = DaemonCluster.pid_path(config, n)
+        config[:log] = DaemonCluster.log_path(config, n)
+
+        args = [:pid, :log, :user, :group, :chdir].map{ |kind|
+          value = config.send(:[], kind)
+          value ? "'#{value}'" : 'nil'
+        }.join(', ')
+
+        init_script = "require 'app-deploy/daemon'; AppDeploy::Daemon.daemonize(#{args});"
+        ruby_opts   = "-r rubygems -e \"#{init_script} load('#{config[:script]}')\""
+
+        yield( config, "#{config[:ruby]} #{ruby_opts} #{config[:args]}" )
+      }
+    end
+
+    def start config, cmd
+      puts "Starting ##{config[:num]} #{config[:ruby]} #{config[:script]} #{config[:args]}..."
+      sh cmd
+      puts
+    end
+
+    def pid_path config, number
+      path, script, args = config[:pid], config[:script], config[:args]
+      DaemonCluster.path_with_number(path, script, args, number)
+    end
+
+    def log_path config, number
+      # log should expand path since daemons' working dir is different
+      path, script, args = config[:log], config[:script], config[:args]
+      File.expand_path(DaemonCluster.path_with_number(path, script, args, number))
+    end
+
+    def path_with_number path, script, args, number
+      name = (args ? File.basename("#{script} #{args}") :
+                     File.basename(script)               ).gsub(/\s+/, '_')
+
+      ext = File.extname(path)
+      path.gsub(/#{ext}$/, ".#{name}.#{number}#{ext}")
+    end
+  end # of DaemonCluster
+end # of AppDeploy

data/lib/app-deploy/deploy.rake

@@ -0,0 +1,18 @@
+
+namespace :app do
+
+  desc 'deploy to master state'
+  task :deploy => 'deploy:default'
+
+  namespace :deploy do
+    desc 'before deploy hook for you to override'
+    task :before
+
+    desc 'after deploy hook for you to override'
+    task :after
+
+    task :default => [:before, 'git:stash',
+                               'server:restart', :after]
+
+  end # of deploy
+end # of app

data/lib/app-deploy/deprecated/merb.rake

@@ -0,0 +1,20 @@
+
+namespace :app do
+  namespace :merb do
+
+    desc 'start the merb server, default config: config/merb.yml'
+    task :start, [:config] do |t, args|
+      sh "merb #{AppDeploy.extract_config(args[:config] || 'config/merb.yml')}"
+    end
+
+    desc 'stop the merb server'
+    task :stop do
+      sh 'merb -K all'
+      sleep(0.5)
+    end
+
+    desc 'restart the merb server'
+    task :restart => [:stop, :start]
+
+  end # of merb
+end # of app

data/lib/app-deploy/deprecated/mongrel.rake

@@ -0,0 +1,13 @@
+
+namespace :app do
+  namespace :mongrel do
+
+    [:start, :stop, :restart].each{ |name|
+      desc "#{name} the mongrel cluster"
+      task name do
+        sh "mongrel_rails cluster::#{name}"
+      end
+    }
+
+  end # of mongrel
+end # of app

data/lib/app-deploy/gem.rake

@@ -0,0 +1,25 @@
+
+namespace :app do
+  namespace :gem do
+
+    desc 'install gems'
+    task :install do
+      AppDeploy.each(:gem){ |dep|
+        puts "Installing #{dep[:gem] || dep[:github_project]}..."
+        AppDeploy.install_gem(dep)
+      }
+    end
+
+    desc 'uninstall gems'
+    task :uninstall do
+      AppDeploy.each(:gem){ |dep|
+        puts "Uninstalling #{dep[:gem] || dep[:github_project]}..."
+        AppDeploy.uninstall_gem(dep)
+      }
+    end
+
+    desc 'reinstall gems'
+    task :reinstall => [:uninstall, :install]
+
+  end # of gem
+end # of app

data/lib/app-deploy/git.rake

@@ -0,0 +1,66 @@
+
+namespace :app do
+
+  desc 'generic git cmd walk through all dependency'
+  task :git, [:cmd] do |t, args|
+    cmd = args[:cmd] || 'status'
+
+    puts "Invoking git #{cmd}..."
+    begin
+      sh "git #{cmd}"
+    rescue RuntimeError => e
+      puts e
+    end
+
+    AppDeploy.each(:github){ |opts|
+      puts "Invoking git #{cmd} on #{opts[:github_project]}..."
+      begin
+        sh "git #{cmd}"
+      rescue RuntimeError => e
+        puts e
+      end
+    }
+
+  end
+
+  namespace :git do
+
+    task :reset => :stash
+
+    desc 'make anything reflect master state'
+    task :stash do
+      puts 'Stashing...'
+      sh 'git stash'
+    end
+
+    desc 'init and update submodule'
+    task :submodule do
+      sh 'git submodule init'
+      sh 'git submodule update'
+    end
+
+    desc 'clone repoitory from github'
+    task :clone do
+      AppDeploy.github.each{ |dep|
+        puts "Cloning #{dep[:github_project]}..."
+        AppDeploy.clone(dep)
+      }
+    end
+
+    desc 'pull anything from origin'
+    task :pull do
+      puts 'Pulling...'
+      begin
+        sh 'git pull' if `git remote` =~ /^origin$/
+      rescue RuntimeError => e
+        puts e
+      end
+
+      AppDeploy.each(:github){ |opts|
+        puts "Pulling #{opts[:github_project]}..."
+        sh 'git pull'
+      }
+    end
+
+  end # of git
+end # of app

data/lib/app-deploy/install.rake

@@ -0,0 +1,84 @@
+
+namespace :app do
+
+  desc 'install this application'
+  task :install => 'install:default'
+
+  namespace :install do
+    desc 'before install hook for you to override'
+    task :before
+
+    desc 'after install hook for you to override'
+    task :after
+
+    task :default => [:before,
+                      'git:submodule',
+                      'git:clone',
+                      'gem:install',
+                      :after]
+
+    desc 'remote installation'
+    task :remote, [:hosts, :git, :cd, :branch, :script] => 'remote:default'
+
+    namespace :remote do
+      task :default, [:hosts, :git, :cd, :branch, :script] do |t, args|
+        unless [args[:hosts], args[:git]].all?
+          puts 'please fill your arguments like:'
+          puts "  > rake app:install:remote[#{args.names.join(',').upcase}]"
+          exit(1)
+        end
+
+        cd     = args[:cd]     || '~'
+        branch = args[:branch] || 'master'
+        tmp    = "app-deploy-#{Time.now.to_i}"
+
+        chdir = "cd #{cd}"
+        clone = "git clone #{args[:git]} /tmp/#{tmp}"
+        setup = "find /tmp/#{tmp} -maxdepth 1 '!' -name #{tmp} -exec mv -f '{}' #{cd} ';'"
+        rmdir = "rmdir /tmp/#{tmp}"
+        check = "git checkout #{branch}"
+
+        ENV['script'] =
+          "#{chdir}; #{clone}; #{setup}; #{rmdir}; #{check}; #{args[:script]}"
+
+        Rake::Task['app:install:remote:sh'].invoke
+      end
+
+      desc 'invoke a shell script on remote machines'
+      task :sh, [:hosts, :script] do |t, args|
+        args[:hosts].split(',').map{ |host|
+          script = args[:script].gsub('"', '\\"')
+          Thread.new{ sh "ssh #{host} \"#{script}\"" }
+        }.each(&:join)
+      end
+
+      desc 'upload a file to remote machines'
+      task :upload, [:file, :hosts, :path] do |t, args|
+        args[:hosts].split(',').each{ |host|
+          sh "scp #{args[:file]} #{host}:#{args[:path]}"
+        }
+      end
+
+      desc 'create a user on remote machines'
+      task :useradd, [:user, :hosts, :script] do |t, args|
+        useradd = "sudo useradd -m #{args[:user]}"
+        args[:hosts].split(',').each{ |host|
+          script = "#{useradd}; #{args[:script]}".gsub('"', '\\"')
+          sh "ssh #{host} \"#{script}\""
+        }
+      end
+
+      desc 'upload a tarball and untar to user home, then useradd'
+      task :setup, [:user, :file, :hosts, :script] do |t, args|
+        ENV['path'] = "/tmp/app-deploy-#{Time.now.to_i}"
+        Rake::Task['app:install:remote:upload'].invoke
+
+        ENV['script'] = "sudo -u #{args[:user]} tar -zxf #{ENV['path']}" +
+                            " -C /home/#{args[:user]};" +
+                        " rm #{ENV['path']}; #{args[:script]}"
+        Rake::Task['app:install:remote:useradd'].invoke
+      end
+
+    end # of remote
+  end # of install
+end # of app

data/lib/app-deploy/nginx.rake

@@ -0,0 +1,31 @@
+
+namespace :app do
+  namespace :nginx do
+
+    desc 'start nginx, default config is config/nginx.conf, nginx is /usr/sbin/nginx'
+    task :start, [:config, :nginx] do |t, args|
+      # TODO: extract pid file path
+      if File.exist?('tmp/pids/nginx.pid')
+        puts "WARN: pid file #{'tmp/pids/nginx.pid'} already exists, ignoring."
+      else
+        sh "#{args[:nginx] || '/usr/sbin/nginx'} -c #{args[:config] || 'config/nginx.conf'}"
+      end
+    end
+
+    desc 'reload config'
+    task :reload do
+      # sh 'kill -HUP `cat tmp/pids/nginx.pid`'
+      AppDeploy.hup('tmp/pids/nginx.pid', 'nginx')
+    end
+
+    desc 'stop nginx'
+    task :stop, [:timeout] do |t, args|
+      # sh "kill -TERM `cat tmp/pids/nginx.pid`"
+      AppDeploy.term('tmp/pids/nginx.pid', 'nginx', args[:timeout] || 5)
+    end
+
+    desc 'restart nginx'
+    task :restart => [:stop, :start]
+
+  end # of nginx
+end # of app

data/lib/app-deploy/rack.rake

@@ -0,0 +1,34 @@
+
+require 'app-deploy/rack_cluster'
+
+namespace :app do
+  namespace :rack do
+
+    desc 'start the rack cluster'
+    task :start, [:config] do |t, args|
+      path = args[:config] || 'config/rack_cluster.yaml'
+      AppDeploy::RackCluster.each(path){ |config, ruby_opts, rack_opts|
+        AppDeploy::RackCluster.start(config, ruby_opts, rack_opts)
+      }
+    end
+
+    desc 'stop the rack cluster'
+    task :stop, [:config] do |t, args|
+      path = args[:config] || 'config/rack_cluster.yaml'
+      AppDeploy::RackCluster.each(path){ |config, ruby_opts, rack_opts|
+        AppDeploy.term(config[:pid], config[:server])
+      }
+    end
+
+    desc 'restart the rack cluster'
+    task :restart, :config do |t, args|
+      path = args[:config] || 'config/rack_cluster.yaml'
+      AppDeploy::RackCluster.each(path){ |config, ruby_opts, rack_opts|
+        AppDeploy.term(config[:pid], config[:server])
+        AppDeploy::RackCluster.start(config, ruby_opts, rack_opts)
+        sleep(config[:delay]) if config[:delay]
+      }
+    end
+
+  end # of rack
+end # of app

data/lib/app-deploy/rack_cluster.rb

@@ -0,0 +1,79 @@
+
+module AppDeploy
+
+  module RackCluster
+    module_function
+    def each path
+      config_orig = {}
+      rack_opts = AppDeploy.extract_config(path){ |opt, value|
+        case opt
+          when 'environment'
+            "--env #{value}"
+
+          when *%w[server host]
+            config_orig[opt.to_sym] = value
+            "--#{opt} #{value}"
+
+          when *%w[user group chdir servers require rackup daemonize port pid log delay]
+            config_orig[opt.to_sym] = value
+            nil # rack doesn't have this option
+
+          else
+            "--#{opt} #{value}"
+
+        end
+      }
+
+      config_orig = { :servers => 1,
+                      :port    => 9292,
+                      :host    => '0.0.0.0',
+                      :log     => 'log/rack_cluster.log',
+                      :pid     => 'tmp/pids/rack_cluster.pid',
+                      :server  => 'mongrel',
+                      :rackup  => 'config.ru' }.merge(config_orig)
+
+      config_orig[:servers].times{ |n|
+        config = config_orig.dup
+
+        config[:port] += n
+        config[:pid] = RackCluster.pid_path(config[:pid], config[:port])
+        config[:log] = RackCluster.log_path(config[:log], config[:port])
+
+        args = [:pid, :log, :user, :group, :chdir].map{ |kind|
+          value = config.send(:[], kind)
+          value ? "'#{value}'" : 'nil'
+        }.join(', ')
+
+        init_script = "AppDeploy::Daemon.daemonize(#{args})"
+        ruby_opts   = "-r rubygems -r app-deploy/daemon -e \"#{init_script}\""
+
+        yield( config, ruby_opts, rack_opts + " --port #{config[:port]}" )
+      }
+
+    end
+
+    def start config, ruby_opts, rack_opts
+      puts "Starting #{config[:server]} on #{config[:host]}:#{config[:port]}..."
+      sh "rackup #{ruby_opts} #{rack_opts} #{config[:rackup]}"
+      puts
+    end
+
+    def pid_path path, port
+      RackCluster.path_with_number(path, port)
+    end
+
+    def log_path path, port
+      # log should expand path since daemons' working dir is different
+      File.expand_path(RackCluster.path_with_number(path, port))
+    end
+
+    # extracted from thin
+    # Add the server port or number in the filename
+    # so each instance get its own file
+    def path_with_number path, number
+      ext = File.extname(path)
+      path.gsub(/#{ext}$/, ".#{number}#{ext}")
+    end
+
+  end # of RackCluster
+end # of AppDeploy

data/lib/app-deploy/server.rake

@@ -0,0 +1,9 @@
+
+namespace :app do
+  namespace :server do
+
+    desc 'please define your server:restart task'
+    task :restart
+
+  end # of server
+end # of app

data/lib/app-deploy/signal.rake

@@ -0,0 +1,30 @@
+
+namespace :app do
+  namespace :signal do
+
+    desc 'invoke command if not running already.'
+    task :start, [:script, :pid] do |t, args|
+      if File.exist?(args[:pid])
+        puts "WARN: pid file #{args[:pid]} already exists, ignoring."
+      else
+        sh args[:script]
+      end
+    end
+
+    desc 'send a signal to a process with a pid file'
+    task :kill, [:signal] do |t, args|
+      # sh 'kill -HUP `cat tmp/pids/nginx.pid`'
+      AppDeploy.kill(args[:signal], 'tmp/pids/nginx.pid', 'nginx')
+    end
+
+    desc 'stop nginx'
+    task :stop, [:timeout] do |t, args|
+      # sh "kill -TERM `cat tmp/pids/nginx.pid`"
+      AppDeploy.term('tmp/pids/nginx.pid', 'nginx', args[:timeout] || 5)
+    end
+
+    desc 'restart nginx'
+    task :restart => [:stop, :start]
+
+  end # of nginx
+end # of app

data/lib/app-deploy/thin.rake

@@ -0,0 +1,13 @@
+
+namespace :app do
+  namespace :thin do
+
+    [:start, :stop, :restart].each{ |name|
+      desc "#{name} the thin cluster"
+      task name, [:config] do |t, args|
+        sh "thin -C #{args[:config] || 'config/thin.yml'} #{name}"
+      end
+    }
+
+  end # of thin
+end # of app

data/lib/app-deploy/utils.rb

@@ -0,0 +1,189 @@
+
+module AppDeploy
+  module_function
+  def github; @github ||= []; end
+  def dependency opts = {}
+    opts = opts.dup
+    opts[:git_path] ||= opts[:github_project]
+    github << opts.freeze
+  end
+
+  def gem; @gem ||= []; end
+  def dependency_gem opts = {}, &block
+    opts = opts.dup
+
+    if opts[:github_project]
+      opts[:git_path] ||= opts[:github_project]
+      opts[:task_gem] = block if block_given?
+      github << opts.freeze
+    end
+
+    gem << opts.freeze
+  end
+
+  def each *with
+    # yield common gem first, github gem last
+    with = [:gem, :github] if with.empty?
+    cwd = Dir.pwd
+
+    # github's gem would be in @github and @gem,
+    # so call uniq to ensure it wouldn't get called twice.
+    with.map{ |kind| AppDeploy.send(kind) }.flatten.uniq.each{ |opts|
+      puts
+
+      if opts[:github_project]
+        if File.directory?(opts[:git_path])
+          begin
+            Dir.chdir(opts[:git_path])
+            yield(opts)
+          rescue RuntimeError => e
+            puts e
+          ensure
+            Dir.chdir(cwd)
+          end
+        else
+          puts "Skip #{opts[:github_project]}, because it was not found"
+        end
+      else # it's a plain gem
+        yield(opts)
+      end
+    }
+  end
+
+  def extract_config config
+    require 'yaml'
+    YAML.load(File.read(config)).inject([]){ |result, opt_value|
+      opt, value = opt_value
+      if block_given?
+        result << yield(opt, value)
+      else
+        result << "--#{opt} #{value}"
+      end
+      result
+    }.compact.join(' ')
+  end
+
+  # about git
+  def clone opts
+    user, proj, path = opts[:github_user], opts[:github_project], opts[:git_path]
+
+    if File.exist?(path)
+      puts "Skip #{proj} because #{path} exists"
+    else
+      sh "git clone git://github.com/#{user}/#{proj}.git #{path}"
+      sh "git --git-dir #{path}/.git gc"
+    end
+  end
+
+  # about gem
+  def installed_gem? gem_name
+    # `#{gem_bin} list '^#{gem_name}$'` =~ /^#{gem_name}/
+    Gem.send(:gem, gem_name)
+    true
+  rescue LoadError
+    false
+  end
+
+  def install_gem opts
+    gem_name = opts[:gem] || opts[:github_project]
+
+    if AppDeploy.installed_gem?(gem_name)
+      puts "Skip #{gem_name} because it was installed. Uninstall first if you want to reinstall"
+
+    else
+      if opts[:gem]
+        AppDeploy.install_gem_remote(opts[:gem], opts[:source])
+      else
+        AppDeploy.install_gem_local(opts[:github_project], opts[:task_gem])
+      end
+
+    end
+  end
+
+  def uninstall_gem opts
+    gem_name = opts[:gem] || opts[:github_project]
+    if AppDeploy.installed_gem?(gem_name)
+      sh "#{gem_bin} uninstall #{gem_name}"
+    else
+      puts "Skip #{gem_name} because it was not installed"
+    end
+  end
+
+  def install_gem_remote gem_name, source = nil
+    sh "#{gem_bin} install #{gem_name}#{source ? ' --source ' + source : ''}"
+  end
+
+  def install_gem_local proj, task
+    case task
+      when 'bones'
+        sh 'rake clobber'
+        sh 'rake gem:package'
+        sh "#{gem_bin} install --local pkg/#{proj}-*.gem --no-ri --no-rdoc"
+
+      when 'hoe'
+        sh 'rake gem'
+        sh "#{gem_bin} install --local pkg/#{proj}-*.gem --no-ri --no-rdoc"
+
+      when Proc
+        task.call
+    end
+  end
+
+  def gem_bin
+    Gem.ruby + ' ' + `which gem`.strip
+  end
+
+  # about sending signal
+  def read_pid pid_path
+    if File.exist?(pid_path)
+      File.read(pid_path).strip.to_i
+
+    else
+      puts "WARN: No pid file found in #{pid_path}"
+      nil
+
+    end
+  end
+
+  def term pid_path, name = nil, limit = 5
+    if pid = AppDeploy.read_pid(pid_path)
+      puts "Sending TERM to #{name}(#{pid})..."
+
+    else
+      return
+
+    end
+
+    require 'timeout'
+    begin
+      timeout(limit){
+        while true
+          Process.kill('TERM', pid)
+          sleep(0.1)
+        end
+      }
+    rescue Errno::ESRCH
+      if File.exist?(pid_path)
+        puts "WARN: No such pid: #{pid}, removing #{pid_path}..."
+        File.delete(pid_path)
+      else
+        puts "Killed #{name}(#{pid})"
+      end
+
+    rescue Timeout::Error
+      puts "Timeout(#{limit}) killing #{name}(#{pid})"
+
+    end
+  end
+
+  def hup pid_path, name = nil
+    if pid = AppDeploy.read_pid(pid_path)
+      puts "Sending HUP to #{name}(#{pid})..."
+      Process.kill('HUP', pid)
+    end
+  rescue Errno::ESRCH
+    puts "WARN: No such pid: #{pid}, removing #{pid_path}..."
+    File.delete(pid_path)
+  end
+
+end

data/lib/app-deploy/version.rb

@@ -0,0 +1,4 @@
+
+module AppDeploy
+  VERSION = '0.6.0'
+end

data/lib/app-deploy.rb

@@ -0,0 +1,6 @@
+
+%w[ deploy gem git install nginx server rack daemon].each{ |task|
+  load "app-deploy/#{task}.rake"
+}
+
+require 'app-deploy/utils'

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: app-deploy
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+platform: ruby
+authors: 
+- "Lin Jen-Shin (aka godfat \xE7\x9C\x9F\xE5\xB8\xB8)"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-14 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.2.0
+    version: 
+description: " rake tasks for deployment"
+email: godfat (XD) godfat.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- Rakefile
+- TODO
+- app-deploy.gemspec
+- example/Rakefile
+- example/bin/install.sh
+- example/bin/remote_install.sh
+- example/bin/remote_update.sh
+- example/bin/start.sh
+- example/bin/update.sh
+- example/daemon_cluster.yaml
+- example/rack_cluster.yaml
+- lib/app-deploy/daemon.rake
+- lib/app-deploy/deploy.rake
+- lib/app-deploy/deprecated/merb.rake
+- lib/app-deploy/deprecated/mongrel.rake
+- lib/app-deploy/gem.rake
+- lib/app-deploy/git.rake
+- lib/app-deploy/install.rake
+- lib/app-deploy/nginx.rake
+- lib/app-deploy/rack.rake
+- lib/app-deploy/server.rake
+- lib/app-deploy/signal.rake
+- lib/app-deploy/thin.rake
+files: 
+- CHANGES
+- README
+- Rakefile
+- TODO
+- app-deploy.gemspec
+- example/Rakefile
+- example/bin/install.sh
+- example/bin/remote_install.sh
+- example/bin/remote_update.sh
+- example/bin/start.sh
+- example/bin/update.sh
+- example/daemon_cluster.yaml
+- example/rack_cluster.yaml
+- lib/app-deploy.rb
+- lib/app-deploy/daemon.rake
+- lib/app-deploy/daemon.rb
+- lib/app-deploy/daemon_cluster.rb
+- lib/app-deploy/deploy.rake
+- lib/app-deploy/deprecated/merb.rake
+- lib/app-deploy/deprecated/mongrel.rake
+- lib/app-deploy/gem.rake
+- lib/app-deploy/git.rake
+- lib/app-deploy/install.rake
+- lib/app-deploy/nginx.rake
+- lib/app-deploy/rack.rake
+- lib/app-deploy/rack_cluster.rb
+- lib/app-deploy/server.rake
+- lib/app-deploy/signal.rake
+- lib/app-deploy/thin.rake
+- lib/app-deploy/utils.rb
+- lib/app-deploy/version.rb
+has_rdoc: true
+homepage: http://github.com/godfat/app-deploy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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: app-deploy
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: rake tasks for deployment
+test_files: []
+