capistrano-kitchen 0.0.0.pre

data/lib/capistrano_kitchen/dishes/unicorn/hooks.rb

@@ -0,0 +1,9 @@
+# @author Donovan Bray <donnoman@donovanbray.com>
+Capistrano::Configuration.instance(true).load do
+  before "deploy:start", "unicorn:configure"
+  before "deploy:restart", "unicorn:configure"
+  after "deploy:stop",    "unicorn:stop"
+  after "deploy:restart", "unicorn:restart"
+  before "deploy:finalize_update", "unicorn:finalize_update"
+  on :load, "unicorn:watcher"
+end

data/lib/capistrano_kitchen/dishes/unicorn/install.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + '/../utilities')
+
+Capistrano::Configuration.instance(true).load do
+  namespace :unicorn do
+
+    set :unicorn_template_path, File.join(File.dirname(__FILE__),'unicorn.rb.erb')
+    set :unicorn_god_path, File.join(File.dirname(__FILE__),'unicorn.god')
+    set(:unicorn_user) {user}
+    set(:unicorn_group) {user}
+    set :unicorn_workers, 3
+    set :unicorn_backlog, 128
+    set :unicorn_tries, -1
+    set :unicorn_timeout, 120
+    set(:unicorn_root) { current_path }
+    set :unicorn_socket_location, %q{File.expand_path('../../../../shared/sockets/unicorn.sock', __FILE__)} #this IS CORRECTLY a non-interpolated string, to be evaled later.
+    set :unicorn_backup_socket_location, %q{File.expand_path('../../tmp/sockets/unicorn.sock', __FILE__)} #this IS CORRECTLY a non-interpolated string, to be evaled later.
+    set :unicorn_relative_socket_location, 'tmp/sockets'
+    set :unicorn_watcher, nil
+    set :unicorn_suppress_runner, false
+    set :unicorn_suppress_configure, false
+    set :unicorn_init_name, "unicorn"
+    set(:unicorn_god_group_name) { "unicorns" } #must not equal the unicorn_init_name, god will fail to load complaining.
+    set(:unicorn_god_name) { unicorn_init_name } #name for original compatability.
+    set :unicorn_use_syslogger, false
+    set :unicorn_god_start_grace, 30
+    set :unicorn_god_restart_grace, 30
+    set :unicorn_god_stop_grace, 30
+    set :unicorn_god_stop_timeout, 120
+    set :unicorn_disable_rack_attack, false
+
+    desc "select watcher"
+    task :watcher do
+      unicorn.send("watch_with_#{unicorn_watcher}".to_sym) unless unicorn_watcher.nil?
+    end
+
+    desc "Use GOD as unicorn's runner"
+    task :watch_with_god do
+      #This is a test pattern, and may not be the best way to handle diverging
+      #maintenance tasks based on which watcher is used but here goes:
+      #rejigger the maintenance tasks to use god when god is in play
+      %w(start stop restart).each do |t|
+        task t.to_sym, :roles => :app do
+          god.cmd "#{t} #{unicorn_god_name}" unless unicorn_suppress_runner
+        end
+      end
+      after "god:setup", "unicorn:setup_god"
+    end
+
+    desc "setup god to watch unicorn"
+    task :setup_god, :roles => :app do
+      god.upload unicorn_god_path, "#{unicorn_init_name}.god"
+    end
+
+    desc 'Installs unicorn'
+    task :install, :roles => :app do
+      logger.info "unicorn install doesn't do anything, make sure your Gemfile specifies a version of unicorn"
+    end
+
+    task :configure, :roles => :app do
+      # if you check in your unicorn.rb you can enable supressing this configure step
+      unless unicorn_suppress_configure
+        utilities.upload_template unicorn_template_path, "#{latest_release}/config/unicorn.rb"
+      end
+    end
+
+    desc "decrement the number of unicorn worker processes by one"
+    task :ttou, :roles => :app do
+      run "pkill -TTOU -f 'unicorn master'"
+    end
+
+    desc "increment the number of unicorn worker processes by one"
+    task :ttin, :roles => :app do
+      run "pkill -TTIN -f 'unicorn master';true"
+    end
+
+    task :workers, :roles => :app do
+      run "ps aux | grep -c '[u]nicorn worker';true"
+    end
+
+    task :stop, :roles => :app do
+      run "cd #{latest_release} && kill -QUIT `cat tmp/pids/unicorn.pid`;true"
+    end
+
+    task :start, :roles => :app do
+      run "cd #{latest_release} && #{base_ruby_path}/bin/unicorn_rails -c config/unicorn.rb -E #{rails_env} -D"
+    end
+
+    desc "restart unicorn"
+    task :restart, :roles => :app do
+      run "cd #{latest_release}; [ -f tmp/pids/unicorn.pid ] && kill -USR2 `cat tmp/pids/unicorn.pid` || #{base_ruby_path}/bin/unicorn_rails -c config/unicorn.rb -E #{rails_env} -D"
+    end
+
+    task :deprovision, :roles => :app do
+      unicorn.stop
+      god.remove  "#{unicorn_init_name}.god"
+      god.restart
+    end
+
+    desc "unicorn finalize_update hook to ensure sockets directory is symlinked without using shared_children"
+    task :finalize_update, :roles => :app do
+      escaped_release = latest_release.to_s.shellescape
+      commands = []
+      commands << "chmod -R -- g+w #{escaped_release}" if fetch(:group_writable, true)
+      [unicorn_relative_socket_location].map do |dir|
+        d = dir.shellescape
+        if (dir.rindex('/')) then
+          commands += ["rm -rf -- #{escaped_release}/#{d}",
+                       "mkdir -p -- #{escaped_release}/#{dir.slice(0..(dir.rindex('/'))).shellescape}"]
+        else
+          commands << "rm -rf -- #{escaped_release}/#{d}"
+        end
+        commands << "mkdir -p -- #{shared_path}/#{dir.split('/').last.shellescape}"
+        commands << "ln -s -- #{shared_path}/#{dir.split('/').last.shellescape} #{escaped_release}/#{d}"
+      end
+
+      run commands.join(' && ') if commands.any?
+    end
+
+  end
+end

data/lib/capistrano_kitchen/dishes/unicorn/unicorn.god

@@ -0,0 +1,71 @@
+# http://unicorn.bogomips.org/SIGNALS.html
+
+rails_env = "<%=rails_env%>"
+rails_root = "<%=unicorn_root%>"
+group_name = "<%=unicorn_god_group_name%>"
+
+God.watch do |w|
+  w.group = group_name
+  w.name = "<%=unicorn_god_name%>"
+  w.interval = 10.seconds # 30 default
+  w.env = {
+    'UNICORN_WORKERS' =>  '<%=unicorn_workers%>'
+  }
+
+  # unicorn needs to be run from the rails root
+  w.start = "cd #{rails_root} && <%=base_ruby_path%>/bin/bundle exec unicorn -c #{rails_root}/config/unicorn.rb -E #{rails_env} -D"
+
+  # QUIT gracefully shuts down workers
+  w.stop =  "kill -QUIT `cat #{rails_root}/tmp/pids/unicorn.pid`"
+
+  # USR2 causes the master to re-create itself and spawn a new worker pool
+  w.restart = "kill -USR2 `cat #{rails_root}/tmp/pids/unicorn.pid`"
+
+  w.start_grace = <%=unicorn_god_start_grace%>.seconds
+  w.restart_grace = <%=unicorn_god_restart_grace%>.seconds
+  w.stop_grace = <%=unicorn_god_stop_grace%>.seconds
+  w.stop_timeout = <%=unicorn_god_stop_timeout%>.seconds
+
+  w.pid_file = "#{rails_root}/tmp/pids/unicorn.pid"
+
+  w.uid = '<%=unicorn_user%>'
+  w.gid = '<%=unicorn_group%>'
+
+  # clean pid files before start if necessary
+  w.behavior(:clean_pid_file)
+
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits) do |c|
+      c.notify = %w[ <%=god_notify_list%> ]
+    end
+  end
+
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 5.minute
+      c.transition = :unmonitored
+      c.retry_in = 10.minutes
+      c.retry_times = 5
+      c.retry_within = 2.hours
+      c.notify = %w[ <%=god_notify_list%> ]
+    end
+  end
+end

data/lib/capistrano_kitchen/dishes/unicorn/unicorn.rb.erb

@@ -0,0 +1,191 @@
+# Sample verbose configuration file for Unicorn (not Rack)
+#
+# This configuration file documents many features of Unicorn
+# that may not be needed for some applications. See
+# http://unicorn.bogomips.org/examples/unicorn.conf.minimal.rb
+# for a much simpler configuration file.
+#
+# See http://unicorn.bogomips.org/Unicorn/Configurator.html for complete
+# documentation.
+
+<% if unicorn_use_syslogger %>
+  # Redirect Log to Syslog
+  # https://gist.github.com/531749
+  # add to your Gemfile:
+  #  gem 'SyslogLogger', :git => 'git@github.com:castaclip/sysloglogger.git', :require => 'syslog_logger'
+  #
+  class Syslogger
+    def initialize
+      read, @write = IO.pipe
+      fork do
+        @write.close
+        $stdin.reopen read
+        exec *%w(logger -trails)
+      end
+      read.close
+      @write.sync = true
+    end
+    def write(progname=nil, &block)
+      @write.puts "#{progname} #{block.call if block_given?}"
+    end
+    alias :debug :write
+    alias :info :write
+    alias :warn :write
+    alias :error :write
+    alias :fatal :write
+  end
+  logger Syslogger.new
+<% end %>
+
+<% if unicorn_disable_rack_attack %>
+  # This isn't a built-in to rack attack.
+  # Use something like this in your config.ru to take advantage of this parameter.
+  #
+  # Rack::Attack.throttle('req/ip', :limit => 15, :period => 3.second) do |req|
+  #   req.ip unless ENV['DISABLE_RACK_ATTACK'].present?
+  # end
+  #
+  ENV['DISABLE_RACK_ATTACK'] = '1'
+<% end %>
+
+# unicorn will stash its original command-line at startup for the USR2 upgrades, and cleaning up old revisions will cause revision-specific installations of unicorn to go missing and upgrades to fail. If you find yourself in this situation and can't afford downtime, you can override the existing unicorn executable path in the config file like this:
+# Then use HUP to reload, and then continue with the USR2+QUIT upgrade sequence.
+Unicorn::HttpServer::START_CTX[0] = "<%=current_path%>/bin/unicorn"
+
+# Use at least one worker per core if you're on a dedicated server,
+# more will usually help for _short_ waits on databases/caches.
+
+worker_processes(( workers = ENV['UNICORN_WORKERS'].to_i ) > 0 ? workers : 4)
+
+# Help ensure your application will always spawn in the symlinked
+# "current" directory that Capistrano sets up.
+# working_directory "/path/to/app/current" # available in 0.94.0+
+
+# listen on both a Unix domain socket and a TCP port,
+# we use a shorter backlog for quicker failover when busy
+# listen "/tmp/.sock", :backlog => 64
+# listen 3000, :tcp_nopush => true
+
+if File.exists?( shared_socket = <%=unicorn_socket_location%> )
+  listen shared_socket, :backlog => <%=unicorn_backlog%>, :tries => <%=unicorn_tries%>
+else
+  listen <%=unicorn_backup_socket_location%>, :backlog => <%=unicorn_backlog%>, :tries => <%=unicorn_tries%>
+end
+
+timeout <%=unicorn_timeout%>
+
+# feel free to point this anywhere accessible on the filesystem
+# pid "/path/to/app/shared/pids/unicorn.pid"
+pid File.expand_path('../../tmp/pids/unicorn.pid', __FILE__)
+
+# By default, the Unicorn logger will write to stderr.
+# Additionally, ome applications/frameworks log to stderr or stdout,
+# so prevent them from going to /dev/null when daemonized here:
+# stderr_path "/path/to/app/shared/log/unicorn.stderr.log"
+# stdout_path "/path/to/app/shared/log/unicorn.stdout.log"
+stderr_path File.expand_path('../../log/unicorn.log', __FILE__)
+stdout_path File.expand_path('../../log/unicorn.log', __FILE__)
+
+# combine REE with "preload_app true" for memory savings
+# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+preload_app true
+GC.respond_to?(:copy_on_write_friendly=) and
+  GC.copy_on_write_friendly = true
+
+# sets the working directory for Unicorn.  This ensures SIGUSR2 will
+# start a new instance of Unicorn in this directory.  This may be
+# a symlink, a common scenario for Capistrano users.  Unlike
+# all other Unicorn configuration directives, this binds immediately
+# for error checking and cannot be undone by unsetting it in the
+# configuration file and reloading.
+working_directory "<%=current_path%>"
+
+# sets the before_exec hook to a given Proc object.  This
+# Proc object will be called by the master process right
+# before exec()-ing the new unicorn binary.  This is useful
+# for freeing certain OS resources that you do NOT wish to
+# share with the reexeced child process.
+# There is no corresponding after_exec hook (for obvious reasons).
+before_exec do |server|
+  ENV.each do |key,value|
+    server.logger.warn "EXEC ENV['#{key}']=#{value}" if %w(BUNDLE_BIN_PATH GEM_PATH GEM_HOME RACK_ENV PATH BUNDLE_GEMFILE USER PWD).include?(key)
+  end
+  ENV["BUNDLE_GEMFILE"] = "<%=current_path%>/Gemfile"
+end
+
+
+# sets before_fork got be a given Proc object.  This Proc
+# object will be called by the master process before forking
+# each worker.
+before_fork do |server, worker|
+  #Disconnections go in the before_fork, Reconnections should happen in the after_fork
+
+  # the following is highly recomended for Rails + "preload_app true"
+  # as there's no need for the master process to hold a connection
+  defined?(ActiveRecord::Base) and ActiveRecord::Base.connection.disconnect!
+
+  # Sequel contstants
+  defined?(DB) and DB.disconnect
+  defined?(SDB) and SDB.disconnect
+  # Riak connection via Ripple
+  Thread.current[:ripple_clent] = nil if Thread.current[:ripple_client]
+
+  #
+  # # *optionally* throttle the master from forking too quickly by sleeping
+  # sleep 1
+end
+
+# sets after_fork hook to a given block.  This block will be called by
+# the worker after forking.  The following is an example hook which adds
+# a per-process listener to every worker:
+#
+#  after_fork do |server,worker|
+#    # per-process listener ports for debugging/admin:
+#    addr = "127.0.0.1:#{9293 + worker.nr}"
+#    # the negative :tries parameter indicates we will retry forever
+#    # waiting on the existing process to exit with a 5 second :delay
+#    # Existing options for Unicorn::Configurator#listen such as
+#    # :backlog, :rcvbuf, :sndbuf are available here as well.
+#    server.listen(addr, :tries => -1, :delay => 5, :backlog => 128)
+#  end
+after_fork do |server, worker|
+  ENV.each do |key,value|
+    server.logger.info "AFTER ENV['#{key}']=#{value}" if %w(BUNDLE_BIN_PATH GEM_PATH GEM_HOME RACK_ENV PATH BUNDLE_GEMFILE PWD).include?(key)
+  end
+
+  # Redis reconnection via the Redis gem
+  # Guard against all failures including the redis server not being present at the default 127.0.0.1:6379
+  begin
+    Redis.current.client.reconnect
+  rescue
+  end
+
+  ##
+  # When sent a USR2, Unicorn will suffix its pidfile with .oldbin and
+  # immediately start loading up a new version of itself (loaded with a new
+  # version of our app). When this new Unicorn is completely loaded
+  # it will begin spawning workers. The first worker spawned will check to
+  # see if an .oldbin pidfile exists. If so, this means we've just booted up
+  # a new Unicorn and need to tell the old one that it can now die. To do so
+  # we send it a QUIT.
+  #
+  # Using this method we get 0 downtime deploys.
+
+  # wait until last worker boots to send QUIT signal
+  # next if worker.nr != (server.worker_processes - 1)
+  # wait for only half of them to ease memory constraints
+  next if worker.nr != (( server.worker_processes / 2 ) > 0 ? ( server.worker_processes / 2 ) : 1 )
+
+  old_pid = "#{server.config[:pid]}.oldbin"
+  if File.exists?(old_pid) && server.pid != old_pid
+    begin
+      Process.kill("QUIT", old_pid_number = File.read(old_pid).to_i)
+      server.logger.info "I slayed the Unicorn! with PID #{old_pid_number}"
+    rescue Errno::ENOENT, Errno::ESRCH
+      server.logger.info "Darn, PID #{old_pid_number} was already dead."
+    end
+  end
+
+end
+
+

data/lib/capistrano_kitchen/recipes/aptitude.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/aptitude/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/bundler.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/bundler/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/git.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/git/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/java_7_oracle.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/java_7_oracle/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/nginx_unicorn.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/nginx_unicorn/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/nodejs.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/nodejs/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/provision.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/provision/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/ruby.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/ruby/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/teelogger.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/teelogger/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/unicorn.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), '../dishes/unicorn/*.rb')].sort.each { |lib| require lib }

data/lib/capistrano_kitchen/recipes/utilities.rb

@@ -0,0 +1,442 @@
+require 'fileutils'
+require 'open3'
+require 'json'
+require 'open-uri'
+
+module Utilities
+  # utilities.config_gsub('/etc/example', /(.*)/im, "\\1")
+  def config_gsub(file, find, replace)
+    tmp="/tmp/#{File.basename(file)}"
+    get file, tmp
+    content=File.open(tmp).read
+    content.gsub!(find,replace)
+    put content, tmp
+    sudo "mv #{tmp} #{file}"
+  end
+
+  # utilities.ask('What is your name?', 'John')
+  def ask(question, default='')
+    question = "\n" + question.join("\n") if question.respond_to?(:uniq)
+    answer = Capistrano::CLI.ui.ask(space(question)).strip
+    answer.empty? ? default : answer
+  end
+
+  # utilities.suggest_version(:ruby_ver, 'ruby-2.1.0')
+  def suggest_version(config_var,suggestion)
+    ver = utilities.ask("#{config_var}: [#{suggestion}] ?",suggestion)
+    logger.info %Q{*** To pin your provision to this version you should add "set :#{config_var}, '#{ver}'" to your deploy.rb}
+    ver
+  end
+
+  # utilities.yes?('Proceed with install?')
+  def yes?(question)
+    question = "\n" + question.join("\n") if question.respond_to?(:uniq)
+    question += ' (y/n)'
+    ask(question).downcase.include? 'y'
+  end
+
+  def gem_install_preamble
+    "#{base_ruby_path}/bin/gem install #{capture('gem -v').chomp[0] < "2" ? '-y' : ''} --no-rdoc --no-ri"
+  end
+
+  # Uses the base ruby path to install gem(s), avoids installing the gem if it's already installed.
+  # Installs the gems detailed in +package+, selecting version +version+ if
+  # specified.
+  def gem_install(package, version=nil)
+    tries = 3
+    begin
+      cmd = "#{sudo} #{gem_install_preamble} #{version ? '-v '+version.to_s : ''} #{package}"
+      wrapped_cmd = "if ! #{base_ruby_path}/bin/gem list '#{package}' | grep --silent -e '#{package}.*#{version}'; then #{cmd}; fi"
+      run wrapped_cmd
+      #send(run_method,wrapped_cmd)
+    rescue Capistrano::Error
+      tries -= 1
+      retry if tries > 0
+    end
+  end
+
+  # Installs the gems detailed in +package+, selecting version +version+ if
+  # specified, after uninstalling all versions of previous gems of +package+
+  def gem_install_only(package, version=nil)
+    tries = 3
+    begin
+      run "if ! #{base_ruby_path}/bin/gem list '#{package}' | grep --silent -e '#{package} \(#{version}\)'; then #{sudo} #{base_ruby_path}/bin/gem uninstall --ignore-dependencies --executables --all #{package}; #{sudo} #{gem_install_preamble} #{version ? '-v '+version.to_s : ''} #{package}; fi"
+    rescue Capistrano::Error
+      tries -= 1
+      retry if tries > 0
+    end
+  end
+
+  # uninstalls the gems detailed in +package+, selecting version +version+ if
+  # specified, otherwise all.
+  def gem_uninstall(package, version=nil)
+    cmd = "#{sudo} #{base_ruby_path}/bin/gem uninstall --ignore-dependencies --executables #{version ? '-v '+version.to_s  : '--all'} #{package}"
+    run "if #{base_ruby_path}/bin/gem list '#{package}' | grep --silent -e '#{package}.*#{version}'; then #{cmd}; fi"
+  end
+
+  def aptitude_safe_upgrade
+    cmd = "#{sudo} dpkg --configure -a" #recover from previous failures.
+    run_with_input(cmd, input_query=/(<No>|\?)/, "N\n")
+    run "#{sudo} aptitude update"
+    #using every trick in the book to attempt to force it to not prompt.
+    cmd = "#{sudo} DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive aptitude safe-upgrade -o Aptitude::Delete-Unused=false -o Aptitude::CmdLine::Fix-Broken=true --quiet --assume-yes --target-release `lsb_release -cs`"
+    run_with_input(cmd, input_query=/(<No>|\?)/, "N\n") #attempt to answer ncurses overwrite popup like when libpam complains about local modifications.
+  end
+
+  # 10.04 <=> 12.04 naming compatability layer, find packages by executable name instead of package name.
+  # like add-apt-repository is in python-software-properties for 10.04 but software-properties-common in 12.04.
+  #
+  # utilities.apt_install_by_command('add-apt-repository')
+  def apt_install_by_command(command)
+    sudo_run_compressed %Q{
+      #{apt_get_preamble} install apt-file;
+      apt-file update;
+      #{apt_get_preamble} install `apt-file --non-interactive --package-only search #{command}`
+    }
+  end
+
+
+  # Install a package from a ppa utilizing add-apt-repository syntax
+  #
+  # utilities.apt_install_from_ppa("ppa:git-core/ppa","git-core")
+  def apt_install_from_ppa(ppa,package)
+    apt_install_by_command('add-apt-repository')
+    # 12.04 has a -y, 10.04 doesn't. (the check assumes all boxes are the same)
+    run "#{sudo} add-apt-repository #{capture("lsb_release -rs") < "12.04" ? "" : "-y" } #{ppa}"
+    apt_update
+    apt_install package
+  end
+
+
+
+  # utilities.apt_install %w[package1 package2]
+  # utilities.apt_install "package1 package2"
+  def apt_install(packages)
+    packages = packages.split(/\s+/) if packages.respond_to?(:split)
+    packages = Array(packages)
+    sudo "#{apt_get_preamble} install #{packages.join(" ")}"
+  end
+
+  # utilities.apt_reinstall %w[package1 package2]
+  # utilities.apt_reinstall "package1 package2"
+  def apt_reinstall(packages)
+    packages = packages.split(/\s+/) if packages.respond_to?(:split)
+    packages = Array(packages)
+    sudo "#{apt_get_preamble} --reinstall install #{packages.join(" ")}"
+  end
+
+  # remove is identical to install except that packages are removed instead of installed. Note the
+  # removing a package leaves its configuration files in system. If a plus sign is appended to the
+  # package name (with no intervening space), the identified package will be installed instead of
+  # removed.
+  def apt_remove(packages)
+    packages = packages.split(/\s+/) if packages.respond_to?(:split)
+    packages = Array(packages)
+    sudo "#{apt_get_preamble} remove #{packages.join(" ")}"
+  end
+
+  #purge is identical to remove except that packages are removed and purged (any configuration files are deleted too).
+  def apt_purge(packages)
+    packages = packages.split(/\s+/) if packages.respond_to?(:split)
+    packages = Array(packages)
+    sudo "#{apt_get_preamble} purge #{packages.join(" ")}"
+  end
+
+  def apt_autoremove
+    sudo "#{apt_get} -qy autoremove"
+  end
+
+  def apt_fix_missing
+    sudo "#{apt_get} -qy update --fix-missing"
+  end
+
+  def apt_update
+    sudo "#{apt_get} -qy update"
+  end
+
+  def apt_upgrade
+    sudo_with_input "dpkg --configure -a", /\?/, "\n" #recover from failed dpkg
+    sudo "#{apt_get} -qy update"
+    sudo_with_input "#{apt_get_preamble} upgrade", /\?/, "\n" #answer the default if any package pops up a warning
+  end
+
+  def apt_get
+    "DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive apt-get"
+  end
+
+  def apt_get_preamble
+    "#{apt_get} -qyu --force-yes"
+  end
+
+  # utilities.sudo_upload('/local/path/to/file', '/remote/path/to/destination', options)
+  def sudo_upload(from, to, options={}, &block)
+    top.upload from, "/tmp/#{File.basename(to)}", options, &block
+    sudo "mv /tmp/#{File.basename(to)} #{to}", options
+    sudo "chmod #{options[:mode]} #{to}", options if options[:mode]
+    sudo "chown #{options[:owner]} #{to}", options if options[:owner]
+  end
+
+  # Upload a file, running it through ERB
+  # utilities.sudo_upload_template('/local/path/to/file','remote/path/to/destination', options)
+  def sudo_upload_template(src,dst,options = {})
+    raise Capistrano::Error, "sudo_upload_template requires Source and Destination" if src.nil? or dst.nil?
+    put ERB.new(File.read(src),nil,'-').result(binding), "/tmp/#{File.basename(dst)}", options
+    sudo "mv /tmp/#{File.basename(dst)} #{dst}", options
+    sudo "chmod #{options[:mode]} #{dst}", options if options[:mode]
+    sudo "chown #{options[:owner]} #{dst}", options if options[:owner]
+  end
+
+  # Upload a file running it through ERB
+  def upload_template(src,dst,options = {})
+    raise Capistrano::Error, "put_template requires Source and Destination" if src.nil? or dst.nil?
+    put ERB.new(File.read(src)).result(binding), dst, options
+  end
+
+  # utilities.adduser('deploy')
+  def adduser(user, options={})
+    options[:shell] ||= '/bin/bash' # new accounts on ubuntu 6.06.1 have been getting /bin/sh
+    switches = ""
+    switches += " --system" if options[:system]
+    switches += ' --disabled-password --gecos ""'
+    switches += " --home #{options[:home]}" if options[:home]
+    switches += " --disabled-login" if options[:disabled_login]
+    switches += " --shell=#{options[:shell]} " if options[:shell] && !options[:system]
+    switches += ' --no-create-home ' if options[:nohome]
+    switches += " --uid #{options[:uid]} " if options[:uid]
+    switches += " --gid #{options[:gid]} " if options[:gid]
+    switches += " --ingroup #{options[:group]} " unless options[:group].nil?
+    invoke_command "grep '^#{user}:' /etc/passwd || sudo /usr/sbin/adduser #{switches} #{user}",
+    :via => run_method
+  end
+
+  # utilities.deluser('deploy')
+  def deluser(user, options={})
+    switches = '--force'
+    switches += " --backup" if options[:backup]
+    switches += " --quiet" if options[:quiet]
+    switches += " --remove-home" if options[:removehome]
+    switches += " --group #{options[:group]} " unless options[:group].nil?
+    invoke_command "sudo /usr/sbin/deluser #{switches} #{user}",
+    :via => run_method
+  end
+
+  #utilities.addgroup('deploy')
+  def addgroup(group,options={})
+    switches = ''
+    switches += " --system" if options[:system]
+    switches += " --gid #{options[:gid]} " if options[:gid]
+    invoke_command "/usr/sbin/addgroup  #{switches} #{group}", :via => run_method
+  end
+
+  #utilities.delgroup('deploy')
+  def delgroup(group,options={})
+    switches = '--force'
+    switches += " --only-if-empty" if options[:ifempty]
+    invoke_command "/usr/sbin/delgroup #{switches} #{group}", :via => run_method
+  end
+
+  # role = :app
+  def with_role(role, &block)
+    original, ENV['HOSTS'] = ENV['HOSTS'], find_servers(:role => role).map{|d| d.host}.join(",")
+    begin
+      yield
+    ensure
+      ENV['HOSTS'] = original
+    end
+  end
+
+  # role = :app
+  def without_role(role, &block)
+    original, ENV['HOSTS'] = ENV['HOSTS'], (find_servers() - find_servers(:roles => role)).map{|d| d.host}.join(",")
+    begin
+      yield
+    ensure
+      ENV['HOSTS'] = original
+    end
+  end
+
+  # utilities.with_credentials(:user => 'xxxx', :password => 'secret')
+  # options = { :user => 'xxxxx', :password => 'xxxxx' }
+  def with_credentials(options={}, &block)
+    original_username, original_password = user, password
+    begin
+      set :user,     options[:user] || original_username
+      set :password, options[:password] || original_password
+      yield
+    ensure
+      set :user,     original_username
+      set :password, original_password
+    end
+  end
+
+  def space(str)
+    "\n#{'=' * 80}\n#{str}"
+  end
+
+  ##
+  # Run a command and ask for input when input_query is seen.
+  # Sends the response back to the server.
+  #
+  # +input_query+ is a regular expression that defaults to /^Password/.
+  # Can be used where +run+ would otherwise be used.
+  # run_with_input 'ssh-keygen ...', /^Are you sure you want to overwrite\?/
+  def run_with_input(shell_command, input_query=/^Password/, response=nil)
+    handle_command_with_input(:run, shell_command, input_query, response)
+  end
+
+  ##
+  # Run a command using sudo and ask for input when a regular expression is seen.
+  # Sends the response back to the server.
+  #
+  # See also +run_with_input+
+  # +input_query+ is a regular expression
+  def sudo_with_input(shell_command, input_query=/^Password/, response=nil)
+    handle_command_with_input(:sudo, shell_command, input_query, response)
+  end
+
+  def invoke_with_input(shell_command, input_query=/^Password/, response=nil)
+    handle_command_with_input(run_method, shell_command, input_query, response)
+  end
+
+  ##
+  # Run a long bash command thats indented with appropriate ';' that allow the linefeeds to be stripped and make a single concise shell command
+  #
+  # utilities.run_compressed %Q{
+  #   cd /usr/local/src;
+  #   if [ -d "#{mysql_tuner_name}" ]; then
+  #     git pull;
+  #   else
+  #     git clone #{mysql_tuner_src_url} #{mysql_tuner_name};
+  #   fi
+  # }
+  def run_compressed(cmd)
+    run cmd.split("\n").reject(&:empty?).map(&:strip).join(' ')
+  end
+
+  def sudo_run_compressed(cmd)
+    sudo compressed_join(cmd)
+  end
+
+  def compressed_join(cmd)
+     %Q{sh -c "#{cmd.split("\n").reject(&:empty?).map(&:strip).join(' ')}"}
+  end
+
+  ##
+  # Checkout something from a git repo, update it if it's already checked out, and checkout the right ref.
+  #   This will leave the checkout on the 'deploy' branch.
+  #
+  # utilities.sudo_git_clone_or_pull "git://github.com/scalarium/server-density-plugins.git", "/usr/local/src/scalarium"
+  #
+  # Had to change from using sudo to the deploying user because
+  def git_clone_or_pull(repo,dest,ref="master")
+    run "#{sudo} mkdir -p #{File.dirname(dest)}; #{sudo} chown -R #{user} #{File.dirname(dest)}"
+    cmd = compressed_join %Q{
+      if [ -d #{dest} ]; then
+        cd #{dest};
+        git fetch;
+      else
+        git clone #{repo} #{dest};
+        cd #{dest};
+        git checkout -b deploy;
+      fi
+    }
+    run_with_input(cmd,%r{\(yes/no\)}, "yes\n")
+    run_compressed %Q{
+      if [ `cd #{dest} && git tag | grep -c #{ref}` = '1' ]; then
+        cd #{dest}; git reset --hard #{ref};
+      else
+        cd #{dest}; git reset --hard origin/#{ref};
+      fi
+    }
+  end
+
+  ##
+  # return the directory that holds the capfile
+  def caproot
+    File.dirname(capfile)
+  end
+
+  # logs the command then executes it locally.
+  # streams the command output
+  def stream_locally(cmd,opts={})
+    shell = opts[:shell] || 'bash'
+    tee = opts[:tee]
+    redact = opts[:redact]
+    redact_replacement = opts[:redact_replacment] || '-REDACTED-'
+    cmd = [shell,'-c "',cmd.gsub(/"/,'\"'),'" 2>&1'].join(' ')
+    cmd_text = redact ? redact.inject(cmd.inspect){|ct,r| ct.gsub(r,redact_replacement)} : cmd.inspect
+    logger.trace %Q{executing locally: #{cmd_text}} if logger
+    $stdout.sync = true
+    elapsed = Benchmark.realtime do
+      Open3.popen3(cmd) do |stdin, out, err, external|
+        # Create a thread to read from each stream
+        { :out => out, :err => err }.each do |key, stream|
+          Thread.new do
+            until (line = stream.gets).nil? do
+              redact.each {|r| line.gsub!(r,redact_replacement)} if redact
+              $stdout << line
+              File.open(tee,'a') {|f| f.write(line) } if tee
+            end
+          end
+        end
+        # Don't exit until the external process is done
+        external.join
+      end
+      if $?.to_i > 0 # $? is command exit code (posix style)
+        raise Capistrano::LocalArgumentError, "Command #{cmd_text} returned status code #{$?}"
+      end
+    end
+    $stdout.sync = false
+    logger.trace "\ncommand finished in #{(elapsed * 1000).round}ms" if logger
+  end
+
+  private
+
+  ##
+  # Find the location of the capfile you can use this to identify a path relative to the capfile.
+  def capfile
+    previous = nil
+    current  = File.expand_path(Dir.pwd)
+
+    until !File.directory?(current) || current == previous
+      filename = File.join(current, 'Capfile')
+      return filename if File.file?(filename)
+      current, previous = File.expand_path("..", current), current
+    end
+  end
+
+  ##
+  # Does the actual capturing of the input and streaming of the output.
+  #
+  # local_run_method: run or sudo
+  # shell_command: The command to run
+  # input_query: A regular expression matching a request for input: /^Please enter your password/
+  def handle_command_with_input(local_run_method, shell_command, input_query, response=nil)
+    send(local_run_method, shell_command, {:pty => true}) do |channel, stream, data|
+      if data =~ input_query
+        if response
+          logger.info "#{data} #{"*"*(rand(10)+5)}", channel[:host]
+          channel.send_data "#{response}\n"
+        else
+          logger.info data, channel[:host]
+          response = ::Capistrano::CLI.password_prompt "#{data}"
+          channel.send_data "#{response}\n"
+        end
+      else
+        logger.info data, channel[:host]
+      end
+    end
+  end
+
+  ##
+  # Use to raise warnings about deprecated items
+  # set(:var_no_longer_used) {utilities.deprecated(:var_no_longer_used,:var_that_should_be_used)}
+  def deprecated(name,replacement=nil)
+    raise Capistrano::Error, "#{name} is deprecated, #{replacement ? "see: #{replacment}" : "no replacement" }."
+  end
+
+
+
+end
+
+Capistrano.plugin :utilities, Utilities