edploy 2.0.0

data/lib/capistrano/recipes/deploy/strategy/utilities/copy.rb

@@ -0,0 +1,53 @@
+# ---------------------------------------------------------------------------
+# A simple copy script for doing hard links and symbolic links instead of
+# explicit copies. Some OS's will already have a utility to do this, but
+# some won't; this file suffices in either case.
+#
+# Usage: ruby copy.rb <source> <target> <exclude> ...
+#
+# The <source> directory is recursively descended, and hard links to all of
+# the files are created in corresponding locations under <target>. Symbolic
+# links in <source> map to symbolic links in <target> that point to the same
+# destination.
+#
+# All arguments after <target> are taken to be exclude patterns. Any file
+# or directory in <source> that matches any of those patterns will be
+# skipped, and will thus not be present in <target>.
+# ---------------------------------------------------------------------------
+# This file is distributed under the terms of the MIT license by 37signals,
+# LLC, and is copyright (c) 2008 by the same. See the LICENSE file distributed
+# with this file for the complete text of the license.
+# ---------------------------------------------------------------------------
+require 'fileutils'
+
+from = ARGV.shift or abort "need source directory"
+to   = ARGV.shift or abort "need target directory"
+
+exclude = ARGV
+
+from = File.expand_path(from)
+to   = File.expand_path(to)
+
+Dir.chdir(from) do
+  FileUtils.mkdir_p(to)
+  queue = Dir.glob("*", File::FNM_DOTMATCH)
+  while queue.any?
+    item = queue.shift
+    name = File.basename(item)
+
+    next if name == "." || name == ".."
+    next if exclude.any? { |pattern| File.fnmatch(pattern, item) }
+
+    source = File.join(from, item)
+    target = File.join(to, item)
+
+    if File.symlink?(item)
+      FileUtils.ln_s(File.readlink(source), target)
+    elsif File.directory?(item)
+      queue += Dir.glob("#{item}/*", File::FNM_DOTMATCH)
+      FileUtils.mkdir_p(target, :mode => File.stat(item).mode)
+    else
+      FileUtils.ln(source, target)
+    end
+  end
+end

data/lib/edploy/environment_capistrano.rb

@@ -0,0 +1,19 @@
+if ENV['BUNDLE_GEMFILE'].nil? || ENV['BUNDLE_BIN_PATH'].nil?
+  abort "You should run this with bundle exec!"
+elsif !File.exists?(File.join(Dir.getwd, 'Capfile'))
+  abort "You should run this from the rails root!"
+end
+
+set :rails_root, Dir.getwd
+
+require 'Syck'
+
+Syck.load_file(File.join(rails_root, 'config', 'edploy', 'edploy.yml')).each do |key, value|
+  if key.to_sym == :ssh_options
+    value.each do |ssh_option, value|
+      ssh_options[ssh_option.to_sym] = value
+    end
+  else
+    set key.to_sym, value
+  end
+end

data/lib/edploy/recipes/apache.rb

@@ -0,0 +1,8 @@
+namespace :edploy do
+  namespace :apache do
+    desc "phased restart of apache on production"
+    task :restart, :roles => :passenger do
+      run "apache2ctl configtest && sudo /etc/init.d/apache2 restart"
+    end
+  end
+end

data/lib/edploy/recipes/bundle_install.rb

@@ -0,0 +1,15 @@
+set :bundle_path, "vendor/bundle"
+set :bundle_without, "development test"
+
+namespace :edploy do
+  after 'deploy:update_code', 'edploy:bundle_install'
+  task :bundle_install do
+    commands = []
+    [ bundle_path, ".bundle" ].uniq.each do |link_path|
+      commands << "mkdir -p #{shared_path}/#{link_path}"
+      commands << "ln -nfs #{shared_path}/#{link_path} #{latest_release}/#{link_path}"
+    end
+    commands << "cd #{latest_release} ; bundle install --path #{shared_path}/#{bundle_path} --local --without #{bundle_without} || bundle install --path #{shared_path}/#{bundle_path} --without #{bundle_without}"
+    run commands.join(' ; ')
+  end
+end

data/lib/edploy/recipes/fast_remote_cache.rb

@@ -0,0 +1,43 @@
+# ---------------------------------------------------------------------------
+# This is a recipe definition file for Capistrano. The tasks are documented
+# below.
+# ---------------------------------------------------------------------------
+# This file is distributed under the terms of the MIT license by 37signals,
+# LLC, and is copyright (c) 2008 by the same. See the LICENSE file distributed
+# with this file for the complete text of the license.
+# ---------------------------------------------------------------------------
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+namespace :fast_remote_cache do
+
+  desc <<-DESC
+    Perform any setup required by fast_remote_cache. This is called
+    automatically after deploy:setup, but may be invoked manually to configure
+    a new machine. It is also necessary to invoke when you are switching to the
+    fast_remote_cache strategy for the first time.
+  DESC
+  task :setup, :except => { :no_release => true } do
+    if deploy_via == :fast_remote_cache
+      strategy.setup!
+    else
+      logger.important "you're including the fast_remote_cache strategy, but not using it!"
+    end
+  end
+
+  desc <<-DESC
+    Updates the remote cache. This is handy for either priming a new box so
+    the cache is all set for the first deploy, or for preparing for a large
+    deploy by making sure the cache is updated before the deploy goes through.
+    Either way, this will happen automatically as part of a deploy; this task
+    is purely convenience for giving admins more control over the deployment.
+  DESC
+  task :prepare, :except => { :no_release => true } do
+    if deploy_via == :fast_remote_cache
+      strategy.prepare!
+    else
+      logger.important "#{current_task.fully_qualified_name} only works with the fast_remote_cache strategy"
+    end
+  end
+end
+
+after "deploy:setup", "fast_remote_cache:setup"

data/lib/edploy/recipes/fast_remote_cache_extensions.rb

@@ -0,0 +1,11 @@
+namespace :edploy do
+  before 'fast_remote_cache:prepare', 'edploy:gc'
+  task :gc do
+    run "cd #{shared_path}/cached-copy ; git gc"
+  end
+  
+  after 'fast_remote_cache:prepare', 'edploy:pre_bundle'
+  task :pre_bundle do
+    run "cd #{shared_path}/cached-copy ; bundle install --path #{shared_path}/vendor/bundle --local --without development test || bundle install --path #{shared_path}/vendor/bundle --without development test"
+  end
+end

data/lib/edploy/recipes/hooks.rb

@@ -0,0 +1,24 @@
+namespace :edploy do
+  
+  %w(deploy:update_code deploy:symlink deploy:setup).each do |task_name|
+    [ :before, :after ].each do |milestone|
+      
+      subdir = "#{milestone}_#{task_name.gsub(/:/, '_')}"
+      Dir[File.join(rails_root, 'config', 'edploy', 'scripts', subdir, "**", "*")].sort.each do |full_entry|
+        next if File.directory?(full_entry)
+        
+        entry = full_entry[File.join(rails_root, 'config', 'edploy', 'scripts', subdir, "/").length..-1]
+        roles = (entry.include?('/') ? File.dirname(entry).split('_').map(&:to_sym) : nil)
+        options = {}
+        options[:roles] = roles if roles
+        script_name = File.basename(entry).to_sym
+
+        self.send(milestone, task_name, "edploy:#{script_name}")
+        task script_name, options do
+          run "cd #{latest_release} ; RAILS_ENV=#{rails_env} PROJECT_PATH=#{latest_release} DEPLOY_USER=#{user} DEPLOY_GROUP=#{group} bundle exec config/edploy/scripts/#{subdir}/#{entry}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/edploy/recipes/production.rb

@@ -0,0 +1,56 @@
+after 'production', 'setup_production'
+
+task :setup_production do
+  set :branch, "production"
+  set :rails_env, 'production'
+
+  EVEN_PASSENGER_HOSTS = find_servers(:roles => :passenger).each_with_index.map { |s, i| i % 2 == 1 ? s : nil }.compact
+  ODD_PASSENGER_HOSTS = find_servers(:roles => :passenger).each_with_index.map { |s, i| i % 2 == 0 ? s : nil }.compact
+  EVEN_DB_HOSTS = find_servers(:roles => :db).each_with_index.map { |s, i| i % 2 == 1 ? s : nil }.compact
+  ODD_DB_HOSTS = find_servers(:roles => :db).each_with_index.map { |s, i| i % 2 == 0 ? s : nil }.compact
+
+  def filter_hosts(hostfilter)
+    old_hostfilter = ENV['HOSTFILTER']
+    ENV['HOSTFILTER'] = hostfilter.to_s
+    yield
+    if old_hostfilter.nil?
+      ENV.delete('HOSTFILTER')
+    else
+      ENV['HOSTFILTER'] = old_hostfilter
+    end
+  end     
+
+  namespace :deploy do
+    desc "phased deploy of app on production"
+    task :zero do
+      [ ODD_PASSENGER_HOSTS + ODD_DB_HOSTS, EVEN_PASSENGER_HOSTS + EVEN_DB_HOSTS ].each do |hostlist|
+        filter_hosts(hostlist.join(',')) do
+          top.deploy.zero_downtime
+        end
+      end
+    end
+    
+    task :zero_downtime do
+      top.deploy.update
+      top.deploy.restart
+    end
+
+  end
+
+  namespace :edploy do
+    namespace :apache do
+      desc "phased restart of apache on production"
+      task :restart, :roles => :passenger do
+        [ ODD_PASSENGER_HOSTS, EVEN_PASSENGER_HOSTS ].each do |hostlist|
+          filter_hosts(hostlist.join(',')) do
+            top.deploy.apache.actual_restart
+          end
+        end
+      end
+      
+      task :actual_restart, :roles => :passenger do
+        run "apache2ctl configtest && sudo /etc/init.d/apache2 restart"
+      end
+    end
+  end
+end

data/lib/edploy/recipes/rails.rb

@@ -0,0 +1,5 @@
+namespace :deploy do
+  task :restart do
+    run "touch #{current_path}/tmp/restart.txt"
+  end
+end

data/lib/edploy/recipes/setup_project.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../edployscripts/archive', __FILE__)
+require File.expand_path('../../../edployscripts/file_handling', __FILE__)
+
+namespace :edploy do
+  
+  after 'deploy:setup', 'edploy:setup_project'
+  task :setup_project do
+    extract_path = File.expand_path('../../config/copy/extract', __FILE__)
+    init_scripts_path = File.expand_path('../../config/copy/init_scripts', __FILE__)
+
+    Edploy::FileHandling.iterate_dir_items(extract_path) do |dirname, basename, relative_entry, fqpn|
+      Edploy::FileHandling.upload_file(fqpn, "#{shared_path}/tmp") do |tmp_file|
+        target_dir = dirname.gsub(/HOME/, '~')
+        Edploy::Archive.extract tmp_file, target_dir, :remove => true
+      end
+    end
+    
+    Edploy::FileHandling.iterate_dir_items(init_scripts_path) do |dirname, basename, relative_entry, fqpn|
+      Edploy::FileHandling.upload_file(fqpn, "#{shared_path}/tmp") do |tmp_file|
+        script_name = "#{application}_#{stage}_#{basename}"
+        system("sudo sh -c 'test -f /etc/init.d/#{script_name} || { cp #{tmp_file} /etc/init.d/#{script_name} ; chmod 755 /etc/init.d/#{script_name} ; update-rc.d #{script_name} defaults ; }'")
+      end
+    end
+  end
+  
+end

data/lib/edploy/recipes/smart_deploy.rb

@@ -0,0 +1,47 @@
+namespace :deploy do
+  
+  desc <<-DESC
+    Deploys your project. Does smart deploy if this is activated.
+  DESC
+  task :default do
+    if exists?(:smart_deploy) && smart_deploy
+      top.deploy.smart
+    else
+      top.deploy.code
+    end
+  end
+  
+  desc <<-DESC
+    Deploys your project. This calls both `update' and `restart'. Note that \
+    this will generally only work for applications that have already been deployed \
+    once. For a "cold" deploy, you'll want to take a look at the `deploy:cold' \
+    task, which handles the cold start specifically.
+  DESC
+  task :code do
+    update
+    restart
+  end
+  
+  desc <<-DESC
+    Deploys your project. Automagically figures out if deploy:setup, deploy:cold, \
+    deploy:migrations or deploy:default is needed.
+  DESC
+  task :smart do
+    project_is_setup = (capture("find #{deploy_to} -mindepth 1 -maxdepth 1 -type d \\( -name 'releases' -o -name 'shared' \\) 2>/dev/null | wc -l").to_i == 2)
+    top.deploy.setup unless project_is_setup
+    at_least_one_release_exists = capture("find #{releases_path} -mindepth 1 -maxdepth 1 -type d 2>/dev/null | wc -l").to_i > 0
+    unless at_least_one_release_exists
+      top.deploy.cold
+    else
+      remote_migrations = capture("find #{latest_release}/db/migrate -type f -name '*.rb' -exec basename {} .rb \\; 2>/dev/null || true").split("\n")
+      local_migrations = `find db/migrate -type f -name '*.rb' -exec basename {} .rb \\; 2>/dev/null || true`.split("\n")
+      pending_migrations = !(local_migrations - remote_migrations).empty?
+      if pending_migrations
+        top.deploy.migrations
+      else
+        top.deploy.code
+      end
+    end
+  end      
+  
+end

data/lib/edploy/recipes/templates.rb

@@ -0,0 +1,60 @@
+require 'erb'
+require 'fileutils'
+def render_template(local_template)
+	template_name = File.basename(local_template)
+	file_name = File.basename(template_name, '.erb')
+	app = File.basename(File.dirname(local_template))
+	path = File.join(deploy_to, app, file_name)
+	
+  template = ERB.new(IO.read(local_template))
+  rendered_template = template.result(binding)
+  
+  tmp_path = File.join('/tmp/', "#{File.basename(path)}-$CAPISTRANO:HOST$") 
+  put(rendered_template, tmp_path, :mode => 0644)
+  send run_method, <<-CMD
+    sh -c "install -m#{sprintf("%3o",0644)} #{tmp_path} #{path} &&
+    rm -f #{tmp_path}"
+  CMD
+end
+
+TEMPLATES = {}
+Dir[File.expand_path("../../config/templates/*", __FILE__)].each do |app|
+	TEMPLATES[File.basename(app).to_sym] = {
+		:templates => Dir[File.join(app, '*.erb')],
+		:config => File.join(app, 'config.rb'),
+		:after_config => File.join(app, 'after_config.rb'),
+		:activate => File.join(app, 'activate.rb'),
+		:deactivate => File.join(app, 'deactivate.rb'),
+	}
+end
+
+TEMPLATES.each do |application, data|
+	eval File.read(data[:config]) if File.exists?(data[:config])
+	
+	namespace :edploy do
+		namespace application do
+			after 'deploy:setup', "edploy:#{application}:config"
+			desc "Push #{application} config files to server"
+			task :config, :roles => application do
+				data[:templates].each do |template|
+					render_template(template)
+				end
+				eval File.read(data[:after_config]) if File.exists?(data[:after_config])
+			end
+			
+			if File.exists?(data[:activate])
+				desc "Activate #{application}"
+				task :activate, :roles => application do
+					eval File.read(data[:activate])
+				end
+			end
+			
+			if File.exists?(data[:deactivate])
+				desc "Deactivate #{application}"
+				task :deactivate, :roles => application do
+					eval File.read(data[:deactivate])
+				end
+			end
+		end
+	end
+end

data/lib/edploy/recipes/web_disable_enable.rb

@@ -0,0 +1,32 @@
+namespace :edploy do
+  namespace :web do
+    namespace :disable do
+      before 'deploy', 'edploy:web:disable:maintenance'
+      before 'deploy:migrations', 'edploy:web:disable:maintenance'
+      task :maintenance, :roles => :passenger do
+        on_rollback { run "rm -f #{shared_path}/system/maintenance.html" }
+        run "cp #{current_path}/config/edploy/copy/project_files/#{stage}/$(hostname)/public/maintenance.html #{shared_path}/system/ 2>/dev/null || cp #{current_path}/config/edploy/copy/project_files/#{stage}/public/maintenance.html #{shared_path}/system/ 2>/dev/null || cp #{current_path}/public/maintenance.html #{shared_path}/system/ 2>/dev/null"
+      end
+
+      before 'deploy:zero_downtime', 'edploy:web:disable:zero_downtime'
+      task :zero_downtime, :roles => :passenger do
+        run "mv /var/www/check.txt /var/www/check2.txt 2>/dev/null || true"
+        # sudo "/sbin/iptables -D INPUT -p tcp -s 95.170.77.132/26 -m state --state NEW --dport 443 -j ACCEPT 2>/dev/null || true"
+      end
+    end
+
+    namespace :enable do
+      after 'deploy', 'edploy:web:enable:maintenance'
+      after 'deploy:migrations', 'edploy:web:enable:maintenance'
+      task :maintenance, :roles => :passenger do
+        run "rm -f #{shared_path}/system/maintenance.html"
+      end
+
+      after 'deploy:zero_downtime', 'edploy:web:enable:zero_downtime'
+      task :zero_downtime, :roles => :passenger do
+        run "mv /var/www/check2.txt /var/www/check.txt 2>/dev/null || true"
+        # sudo "/sbin/iptables -A INPUT -p tcp -s 95.170.77.132/26 -m state --state NEW --dport 443 -j ACCEPT"
+      end
+    end
+  end
+end

data/lib/edploy.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2009-2012 by Ewout Vonk. All rights reserved.
+
+# prevent loading when called by Bundler, only load when called by capistrano
+if caller.any? { |callstack_line| callstack_line =~ /^Capfile:/ }
+  unless Capistrano::Configuration.respond_to?(:instance)
+    abort "edploy requires Capistrano 2"
+  end
+
+  Capistrano::Configuration.instance(:must_exist).load do
+    load File.expand_path('../edploy/environment_capistrano.rb', __FILE__)
+  	load File.expand_path('../capistrano/ext/multistage.rb', __FILE__)
+  	# load File.expand_path('../capistrano/ext/mailer.rb', __FILE__)
+    # load File.expand_path('../capistrano/ext/output_catcher.rb', __FILE__)
+    # load File.expand_path('../capistrano/ext/output_hooks.rb', __FILE__)
+  	Dir[File.expand_path('../edploy/recipes/*.rb', __FILE__)].each { |plugin| load(plugin) }
+  end
+end

data/lib/edployify/configuration.rb

@@ -0,0 +1,140 @@
+require 'highline'
+require 'yaml'
+require 'fileutils'
+# work around problem where HighLine detects an eof on $stdin and raises an err
+HighLine.track_eof = false
+
+module Edployify
+	
+	class Configuration
+		
+		class << self
+			
+			def configure
+				instance.configure
+			end
+
+			def get_binding
+				instance.get_binding
+			end
+
+			private
+			
+			def instance
+				@@instance ||= self.new
+			end
+			
+		end
+
+		def get_binding
+			binding
+		end
+		
+		CONFIGURATION_KEYS = {
+			:application => { :default => Proc.new { |c| File.basename(::RAILS_ROOT).gsub(/[^A-Za-z0-9_]/, '_').gsub(/_+/, '_') }, :type => Symbol },
+			:domain => { :default => Proc.new { |c| "#{c[:application]}.com" } },
+			:scm => { :default => :git, :type => Symbol },
+			:git_shallow_clone => { :default => true, :boolean => true },
+			:repository => { :default => Proc.new { |c| "git@HOSTNAME:#{c[:application]}.git" } },
+			:git_enable_submodules => { :default => false, :boolean => true },
+			:deploy_via => { :default => :fast_remote_cache, :type => Symbol },
+			:deploy_to => { :default => Proc.new { |c| "/apps/#{c[:application]}" } },
+			:user => { :default => 'deploy' },
+			:group => { :default => 'deploy' },
+			:normalize_asset_timestamps => { :default => false, :boolean => true },
+			:paranoid => { :ssh_option => true, :default => false, :boolean => true },
+			:forward_agent => { :ssh_option => true, :default => true, :boolean => true },
+			:notify_email => { :default => Proc.new { |c| "support@#{c[:application]}.com" } }
+		}
+		
+		def configure
+			CONFIGURATION_KEYS.each do |variable, options|
+				if self.respond_to?(:"ask_#{variable}")
+					self.send(:"ask_#{variable}", variable, options)
+				elsif options[:ssh_option]
+					ask_ssh_option(variable, options)
+				else
+					ask_value(variable, options)
+				end
+			end
+		end
+		
+		private
+		
+		def ask_repository(variable, options = {})
+			default = base[variable]
+			unless default
+				preset = Edployify::Preferences.request_preset(:use)
+				project = highline.ask("Git project name (without .git): ") { |q| q.default = config[:application] if config[:application] }
+				default = preset.sub(/\{PROJECT\}/, project)
+				options[:default] = default
+			end
+			ask_value(variable, options)
+		end
+		
+		def ask_ssh_option(variable, options = {})
+			ask_value(variable, options.merge(:base => config[:ssh_options]))
+		end
+
+		def ask_value(variable, options = {})
+			base = options[:base] || config
+			default = base[variable] || options[:default]
+			if default.is_a?(Proc)
+				default = default.call(config)
+			end
+
+			variable_prompt_name = variable.to_s.gsub(/(^|_)[A-Za-z0-9]/, &:upcase).gsub(/_/, ' ')
+			question_prompt = "#{variable_prompt_name} " # add trailing space so user input happens on the same line
+
+			value = if options[:boolean]
+				highline.agree(question_prompt) do |q|
+					q.default = (default ? "y" : "n") unless default.nil?
+					q.readline = true
+				end
+			else
+				arguments = [question_prompt]
+				arguments << options[:type] if options[:type]
+				highline.ask(*arguments) do |q|
+					q.default = default if default
+				end
+			end
+
+			base[variable] = value
+			write_file
+		end
+
+		##
+		
+		def config
+			unless @config
+				edploy_yml = File.join(::RAILS_ROOT, 'config', 'edploy', 'edploy.yml')
+				FileUtils.touch edploy_yml
+				$edploy_yml = File.open(edploy_yml, "r+")
+				at_exit do
+					$edploy_yml.close unless $edploy_yml.closed?
+				end
+				config_contents = $edploy_yml.read
+				@config = config_contents.length == 0 ? {} : YAML::load(config_contents)
+				$edploy_yml.rewind
+				@config[:ssh_options] = {}
+			end
+			@config
+		end
+		
+		def write_file
+			$edploy_yml.write YAML::dump(config)
+			$edploy_yml.truncate $edploy_yml.pos
+			$edploy_yml.rewind
+		end
+		
+		def highline
+			@highline ||= HighLine.new
+		end
+
+		def method_missing(method, *args, &block)
+			config[method.to_sym] || config[method.to_s] || super
+		end
+		
+	end
+	
+end