edploy 2.0.0

data/lib/edployify/preferences.rb

@@ -0,0 +1,176 @@
+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 Preferences
+		
+		PREFERENCES_FILE = File.join(Dir.home, '.edployify.cfg')
+		
+		class << self
+			
+			def get
+				instance.get
+			end
+			
+			private
+			
+			def instance
+				@@instance ||= self.new
+			end
+			
+		end
+		
+		def get
+			initial_configure if preferences.empty?
+			preferences
+		end
+		
+		def configure
+			menu
+		end
+		
+		def request_preset(action)
+			list_presets
+			ask_preset(action)
+		end
+		
+		private
+		
+		def initial_configure
+			puts "You don't have any git repository presets configured, let's do this first."
+			puts ""
+			add_preset
+			menu
+		end
+		
+		def add_preset
+			puts ""
+			puts "Define a username, hostname and optionally a basepath for the preset."
+			puts "Note: A project name will be defined during the actual edployify run later on.\n"
+			puts "Structure: <USERNAME>@<HOSTNAME>:<BASEPATH>/{PROJECT}.git"
+			puts "Example: git@github.com:ewoutvonk/edploy.git"
+			puts "Example: gituser@my.server.com:myproject.git (if basepath is empty, there is no slash)"
+			preset_add(modify_preset)
+		end
+		
+		def modify_preset(preset = nil)
+			satisfied = false
+			username = nil
+			hostname = nil
+			basepath = nil
+			if preset
+				username, hostname, basepath = preset.split(/[@:]|\/?\{PROJECT\}\.git/)
+				basepath = nil if basepath.nil? || basepath.empty?
+			end
+			until satisfied do
+				puts ""
+				username = highline.ask("Git repository username: ") { |q| q.default = username || 'git' }
+				hostname = highline.ask("Git repository hostname: ") { |q| q.default = hostname || 'github.com' }
+				basepath = highline.ask("Git repository basepath (optional): ") { |q| q.default = basepath if basepath }
+				preset = "#{username}@#{hostname}:#{basepath}#{basepath.empty? ? '' : '/'}{PROJECT}.git"
+				puts ""
+				highline.choose do |menu|
+					menu.prompt = "Current value: `#{preset}'. What do you want to do? "
+					menu.choice(:save) { satisfied = true }
+					menu.choice(:change) { }
+					menu.choice(:abort) { return } unless preferences.empty?
+				end
+			end
+			preset
+		end
+		
+		def edit_preset
+			list_presets
+			old_preset = ask_preset(:edit)
+			new_preset = modify_preset(old_preset)
+			preset_update(old_preset, new_preset)
+		end
+		
+		def delete_preset
+			list_presets
+			preset_delete(ask_preset(:delete))
+		end
+		
+		def list_presets
+			puts "\nPresets:\n\n"
+			puts (presets_list.each_with_index.map { |entry, i| "    #{i+1}. #{entry}" }.join("\n") + "\n")
+		end
+		
+		def ask_preset(action)
+			preset = nil
+			begin
+				i = highline.ask("Preset to #{action}: ", Integer)
+			end until !(preset = preset_get(i-1)).nil?
+			preset
+		end
+		
+		def menu
+			while true do
+				puts ""
+				highline.choose do |menu|
+					menu.prompt = "Main menu. Please make a choice. "
+					menu.choice(:list_presets) { list_presets }
+					menu.choice(:add_preset) { add_preset }
+					menu.choice(:edit_preset) { edit_preset }
+					menu.choice(:delete_preset) { delete_preset }
+					menu.choice(:quit) { return }
+				end
+			end
+		end
+		
+		##
+		
+		def presets_list
+			preferences[:presets]
+		end
+		
+		def preset_add(preset)
+			preferences[:presets] << preset
+			write_file
+		end
+		
+		def preset_update(old_preset, new_preset)
+			delete_preset(old_preset)
+			add_preset(new_preset)
+		end
+		
+		def preset_delete(preset)
+			preferences[:presets].delete(preset)
+			write_file
+		end
+		
+		def preset_get(i)
+			preferences[:presets][i]
+		end
+		
+		def preferences
+			unless @preferences
+				FileUtils.touch PREFERENCES_FILE
+				$edployify_cfg = File.open(PREFERENCES_FILE, "r+")
+				at_exit do
+					$edployify_cfg.close unless $edployify_cfg.closed?
+				end
+				preferences_contents = $edployify_cfg.read
+				@preferences = preferences_contents.length == 0 ? {} : YAML::load(preferences_contents)
+				$edployify_cfg.rewind
+			end
+			@preferences
+		end
+		
+		def write_file
+			$edployify_cfg.write YAML::dump(preferences)
+			$edployify_cfg.truncate $edployify_cfg.pos
+			$edployify_cfg.rewind
+		end
+		
+		def highline
+			@highline ||= HighLine.new
+		end
+		
+	end
+	
+end

data/lib/edployify/project.rb

@@ -0,0 +1,69 @@
+require 'highline'
+require 'fileutils'
+# work around problem where HighLine detects an eof on $stdin and raises an err
+HighLine.track_eof = false
+
+module Edployify
+	
+	class Project
+		
+		class << self
+			
+			def before_capify_clean
+				FileUtils.rm_f('Capfile')
+			end
+
+			def after_capify_clean
+				capfile = File.readlines('Capfile').map { |line| line =~ /load 'config\/deploy'/ ? [ "require 'edploy'\n", line ] : line }.flatten.join('')
+				File.open('Capfile', 'w') { |f| f.write capfile }
+				check_existing_dir(File.join('config', 'deploy'))
+				check_existing_file(File.join('config', 'deploy.rb'))
+			end
+			
+			private
+			
+			def check_existing_file(file)
+				if File.exists?(file)
+					highline.choose do |menu|
+						menu.prompt = "File `#{file}' exists, what do you want to do?  "
+						menu.choice(:ignore) do
+						end
+						menu.choice(:truncate) do
+							File.truncate(file, 0)
+						end
+						menu.choice(:comment) do
+							File.open(file, 'r+') { |f| c = f.readlines.map { |l| "# #{l}" } ; f.rewind ; f.write c.join() ; f.truncate f.pos }
+						end
+					end
+				end
+			end
+
+			def check_existing_dir(dir)
+				if File.directory?(dir)
+					highline.choose do |menu|
+						menu.prompt = "Directory `#{dir}' exists, what do you want to do?  "
+						menu.choice(:ignore) do
+						end
+						menu.choice(:remove) do
+							FileUtils.rm_rf(dir)
+						end
+						menu.choice(:move_stages_to_edploy_and_remove) do
+							FileUtils.mv Dir.glob("config/deploy/*.rb"), "config/edploy/stages/"
+							FileUtils.rm_rf(dir)
+						end
+						menu.choice(:rename_with_bak_extension) do
+							FileUtils.mv(dir, dir + ".bak")
+						end
+					end
+				end
+			end
+			
+			def highline
+				@@highline ||= HighLine.new
+			end
+			
+		end
+				
+	end
+	
+end

data/lib/edployify/template.rb

@@ -0,0 +1,84 @@
+require 'fileutils'
+require 'erb'
+
+module Edployify
+	
+	class Dir
+		def initialize(path, base_path)
+			@path = File.join(base_path, path)
+		end
+		
+		def mkdir
+			FileUtils.mkdir_p(@path)
+		end
+	end
+	
+	class Template
+		
+		TEMPLATES_DIR = File.expand_path('../../../templates', __FILE__)
+
+		def initialize(path, templates_base, project_base)
+			@template = File.join(templates_base, path)
+			@target = File.join(project_base, path.sub(/\.erb$/, ''))
+		end
+		
+		def generate(local_binding)
+      content = ::ERB.new(IO.read(@template)).result(local_binding)
+		  if File.exists?(@target)
+		    warn "[skip] '#{@target}' already exists"
+		  elsif File.exists?(@target.downcase)
+		    warn "[skip] '#{@target.downcase}' exists, which could conflict with `#{@target}'"
+		  else
+		    unless File.exists?(File.dirname(@target))
+		      puts "[add] making directory '#{File.dirname(@target)}'"
+		      FileUtils.mkdir(File.dirname(@target))
+		    end
+		    puts "[add] writing '#{@target}'"
+		    File.open(@target, "w") { |f| f.write(content) }
+		  end
+		end
+
+		class << self
+			
+			def templates
+				@@templates ||= init(:templates)
+			end
+			
+			def dirs
+				@@dirs ||= init(:dirs)
+			end
+			
+			def make_dirs
+				dirs.each do |dir|
+					dir.mkdir
+				end
+			end
+			
+			def generate_templates(local_binding)
+				templates.each do |template|
+					template.generate(local_binding)
+				end
+			end
+
+			private
+
+			def init(type)
+				@@entries ||= { :templates => [], :dirs => [] }
+				if @@entries[:templates].empty? && @@entries[:dirs].empty?
+					::Dir["#{TEMPLATES_DIR}/config/edploy/**/*"].each do |fqpn|
+						entry = fqpn.sub(/^#{TEMPLATES_DIR}\//, '')
+						if File.directory?(fqpn)
+							@@entries[:dirs] << Edployify::Dir.new(entry, ::RAILS_ROOT)
+						elsif entry.end_with?('.erb')
+							@@entries[:templates] << Edployify::Template.new(entry, TEMPLATES_DIR, ::RAILS_ROOT)
+						end
+					end
+				end
+				@@entries[type]
+			end
+			
+		end
+		
+	end
+	
+end

data/lib/edployify.rb

@@ -0,0 +1,6 @@
+# Copyright (c) 2009-2012 by Ewout Vonk. All rights reserved.
+
+require File.expand_path('../edployify/configuration.rb', __FILE__)
+require File.expand_path('../edployify/preferences.rb', __FILE__)
+require File.expand_path('../edployify/project.rb', __FILE__)
+require File.expand_path('../edployify/template.rb', __FILE__)

data/lib/edployscripts/archive.rb

@@ -0,0 +1,27 @@
+module Edploy
+	class Archive
+	
+		class << self
+		
+			def extract(archive, target_dir, options = {})
+			  cmds = []
+			  case archive_type(archive)
+			  when :tgz then cmds << "tar -C #{target_dir} -z -x -f #{archive}"
+			  when :tbz2 then cmds << "tar -C #{target_dir} -j -x -f #{archive}"
+			  when :tar then cmds << "tar -C #{target_dir} -x -f #{archive}"
+			  when :zip then cmds << "cd #{target_dir} ; unzip #{archive}"
+			  end
+			  cmds << "rm -f #{archive}" if options[:remove]
+			  system cmds.join(' ; ')
+			end
+		
+			private
+		
+			def archive_type(archive)
+			  archive.sub(/\.tar\.gz$/, '.tgz').sub(/\.tar\.bz2$/, '.tbz2').gsub(/\./, '').downcase.to_sym
+			end
+		
+		end
+	
+	end
+end

data/lib/edployscripts/environment_scripts.rb

@@ -0,0 +1,47 @@
+if defined?(REQUIRE_BUNDLE_EXEC) && REQUIRE_BUNDLE_EXEC && (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
+
+RAILS_ROOT = Dir.getwd
+
+require 'syck'
+
+Syck.load_file(File.join(RAILS_ROOT, 'config', 'edploy', 'edploy.yml')).each do |key, value|
+  self.class.const_set(key.to_sym.upcase, value)
+end
+
+GEM_DIR = File.expand_path('../../../', __FILE__)
+MY_HOSTNAME = `hostname`.strip
+MY_HOSTNAME_WITHOUT_INDEX = `hostname | sed 's/[0-9]$//'`.strip
+
+unless defined?(Capistrano::Configuration) # only execute when this file gets included from a normal script
+  PROJECT_PATH = ENV['PROJECT_PATH'] || File.expand_path('../../../../', __FILE__)
+  DEPLOY_USER = (ENV['DEPLOY_USER'].nil? || ENV['DEPLOY_USER'].empty?) ? `id -un`.strip : ENV['DEPLOY_USER']
+  DEPLOY_GROUP = (ENV['DEPLOY_GROUP'].nil? || ENV['DEPLOY_GROUP'].empty?) ? `id -gn`.strip : ENV['DEPLOY_GROUP']
+
+  if %w(staging test qa tryout).include?(MY_HOSTNAME)
+    RAILS_ENV = 'staging'
+    if MY_HOSTNAME == 'test'
+      STAGE = 'testmachine'
+    else
+      STAGE = MY_HOSTNAME
+    end
+    SHARED_PATH = "#{DEPLOY_TO}/shared"
+    CURRENT_PATH = "#{DEPLOY_TO}/current"
+    GLUSTERFS_PATH = "/mnt/glusterfs"
+  elsif %w(app db).include?(MY_HOSTNAME_WITHOUT_INDEX)
+    RAILS_ENV = 'production'
+    STAGE = 'production'
+    SHARED_PATH = "#{DEPLOY_TO}/shared"
+    CURRENT_PATH = "#{DEPLOY_TO}/current"
+    GLUSTERFS_PATH = "/mnt/glusterfs"
+  else
+    RAILS_ENV = 'development'
+    STAGE = nil
+    SHARED_PATH = File.expand_path('../../../../shared', __FILE__)
+    CURRENT_PATH = PROJECT_PATH
+    GLUSTERFS_PATH = File.expand_path('../../../../glusterfs', __FILE__)
+  end
+end

data/lib/edployscripts/file_handling.rb

@@ -0,0 +1,28 @@
+module Edploy
+	class FileHandling
+	
+		class << self
+		
+			def upload_file(file, tmp_path, &block)
+			  if File.exists?(file)
+			    random_string = "#{Time.now.to_i}"
+			    tmp_file = "#{tmp_path}/#{random_string}-#{File.basename(file)}"
+			    commands << "mkdir -p #{File.dirname(tmp_file)}"
+			    put File.read(file), tmp_file, :mode => 0644
+			    yield(tmp_file)
+			  end
+			end
+
+			def iterate_dir_items(base_dir, &block)
+			  Dir["#{base_dir}/**"].each do |fqpn|
+			    entry = fqpn.sub(/^#{base_dir}\//, '')
+			    dirname = File.dirname(entry)
+			    filename = File.basename(entry)
+			    yield(dirname, filename, relative_entry, fqpn)
+			  end
+			end
+		
+		end
+	
+	end
+end

data/lib/edployscripts/git.rb

@@ -0,0 +1,27 @@
+module Edploy
+	class Git
+		
+		class << self
+			
+			def git(*opts)
+			  options = opts.last.is_a?(Hash) ? opts.pop : {}
+			  opts << "--hard" if options[:hard]
+			  if message = options.delete(:message)
+			    opts << "-m '#{message}'"
+			  end
+			  opts << '2>/dev/null' if options[:silent]
+			  cmd = "git #{opts.map(&:to_s).join(' ')}"
+			  unless system(cmd)
+			    return if options[:silent]
+			    abort "error while running `#{cmd}'"
+			  end
+			end
+			
+			def method_missing(method, *args, &block)
+				git(*([method] + args))
+			end
+			
+		end
+		
+	end
+end

data/lib/edployscripts.rb

@@ -0,0 +1,6 @@
+# Copyright (c) 2009-2012 by Ewout Vonk. All rights reserved.
+
+require File.expand_path('../edployscripts/environment_scripts.rb', __FILE__)
+require File.expand_path('../edployscripts/file_handling.rb', __FILE__)
+require File.expand_path('../edployscripts/archive.rb', __FILE__)
+require File.expand_path('../edployscripts/git.rb', __FILE__)

data/templates/config/edploy/scripts/after_deploy_symlink/passenger/clear_file_cache.erb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'edployscripts'
+require 'fileutils'
+
+puts "Clearing local file cache..."
+FileUtils.rm_rf(Dir['tmp/cache/[^.]*'])

data/templates/config/edploy/scripts/after_deploy_update_code/make_symlinks.erb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'edployscripts'
+require 'fileutils'
+
+FileUtils.mkdir_p(SHARED_PATH)
+FileUtils.mkdir_p(GLUSTERFS_PATH)
+
+sudo_mkdir_p = []
+mkdir_p = []
+sudo_chown = []
+rm_rf = []
+cp_a = {}
+sudo_ln_nfs = {}
+ln_nfs = {}
+commands = []
+
+SYMLINK_DURING_DEPLOY.each do |source_template, target_template|
+  is_dir_symlink = source_template.end_with?('/')
+  source = source_template.gsub(/:[^\/]+/) { |s| Kernel.const_get(s[1..-1].upcase.to_sym) }.gsub(/\/$/, '')
+  target = target_template.gsub(/:[^\/]+/) { |s| Kernel.const_get(s[1..-1].upcase.to_sym) }
+  
+  target_is_inside_project = target.start_with?(DEPLOY_TO)
+  source_is_inside_project = source.start_with?(DEPLOY_TO)
+  if is_dir_symlink
+		unless File.exists?(source)
+			if source_is_inside_project
+				mkdir_p << source
+			else
+				sudo_mkdir_p << source
+			end
+			sudo_chown << source
+		end
+		rm_rf << target if File.exists?(target) && !File.symlink?(target) && is_inside_project
+  end
+	if target_is_inside_project
+		ln_nfs[source] = target
+	else
+		sudo_ln_nfs[source] = target
+	end
+end
+
+stage_host_files_dir = File.join(PROJECT_PATH, 'config', 'edploy', 'copy', 'project_files', STAGE, MY_HOSTNAME)
+stage_role_files_dir = File.join(PROJECT_PATH, 'config', 'edploy', 'copy', 'project_files', STAGE, MY_HOSTNAME_WITHOUT_INDEX)
+stage_files_dir = File.join(PROJECT_PATH, 'config', 'edploy', 'copy', 'project_files', STAGE)
+stage_host_files_to_copy = Dir[File.join(stage_host_files_dir, '*')].map { |entry| entry.sub(/^#{stage_host_files_dir}\//, '') }
+stage_role_files_to_copy = Dir[File.join(stage_role_files_dir, '*')].map { |entry| entry.sub(/^#{stage_role_files_dir}\//, '') }
+stage_files_to_copy = Dir[File.join(stage_files_dir, '*')].reject { |entry| [ MY_HOSTNAME, MY_HOSTNAME_WITHOUT_INDEX ].include?(File.basename(entry)) }.map { |entry| entry.sub(/^#{stage_files_dir}\//, '') }
+
+{
+  stage_host_files_dir => stage_host_files_to_copy,
+  stage_role_files_dir => stage_role_files_to_copy,
+  stage_files_dir => stage_files_to_copy
+}.each do |base_source_dir, file_list|
+  file_list.each do |file|
+		mkdir_p << File.join(PROJECT_PATH, File.dirname(file))
+		cp_a[File.join(base_source_dir, file)] = File.join(PROJECT_PATH, File.dirname(file), '/')
+  end
+end
+
+commands = []
+commands << "sudo mkdir -p #{sudo_mkdir_p.uniq.join(' ')}" unless sudo_mkdir_p.empty?
+commands << "mkdir -p #{mkdir_p.uniq.join(' ')}" unless mkdir_p.empty?
+commands << "sudo chown #{DEPLOY_USER}:#{DEPLOY_GROUP} #{sudo_chown.uniq.join(' ')}" unless sudo_chown.empty?
+commands << "rm -rf #{rm_rf.uniq.join(' ')}" unless rm_rf.empty?
+commands += cp_a.map { |source, target| "cp -a #{source} #{target}" }
+commands += sudo_ln_nfs.map { |source, target| "sudo ln -nfs #{source} #{target}" }
+commands += ln_nfs.map { |source, target| "ln -nfs #{source} #{target}" }
+
+commands.each do |cmd|
+  puts cmd
+end
+
+system commands.join(' ; ') or abort "#{$0} failed"

data/templates/config/edploy/scripts/edploygen/01_bundle_install.erb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'edployscripts'
+
+system("bundle install --path vendor/bundle")

data/templates/config/edploy/scripts/edploygen/01_prepare_servers.post.erb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+REQUIRE_BUNDLE_EXEC = true
+require 'edployscripts'
+
+location = File.join(::RAILS_ROOT, 'config', 'edploy', 'stages')
+stages = Dir["#{location}/*.rb"].map { |f| File.basename(f, ".rb") }
+
+stages.each do |stage|
+  system("cap #{stage} fast_remote_cache:setup")
+  system("cap #{stage} fast_remote_cache:prepare")
+end

data/templates/config/edploy/scripts/edploygen/02_whenever_configs.erb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+REQUIRE_BUNDLE_EXEC = true
+require 'edployscripts'
+require 'open3'
+require 'fileutils'
+
+def run_process(cmd, target_file)
+  puts "writing #{target_file}.."
+  Open3.popen3(cmd) { |stdin, stdout, stderr|
+    err_output = stderr.read
+    std_output = stdout.readlines.map { |line| line =~ /^## \[message\] / ? nil : line.strip }.compact.join("\n").strip + "\n"
+    if err_output.empty?
+      File.open(target_file, "w") { |f| f.write std_output.gsub(RAILS_ROOT, File.join(DEPLOY_TO, 'current')) }
+    else
+      abort "error while running: #{cmd}\n#{err_output}"
+    end
+  }
+  File.chmod(0755, target_file)
+end
+
+Dir["#{RAILS_ROOT}/config/edploy/whenever/*.rb"].entries.each do |crontab_def_file|
+  config_base_name = File.basename(crontab_def_file, ".rb")
+  next if config_base_name.to_sym == :generic
+  stage = File.readlines(crontab_def_file).grep(/^set :stage/).first.split(", ").last.strip[1..-2]
+  
+  base_target_dir = File.join(RAILS_ROOT, 'config', 'edploy', 'copy', 'project_files', stage)
+  target_dir = config_base_name == stage ? base_target_dir : File.join(base_target_dir, "#{config_base_name}")
+  target_file = File.join(target_dir, 'config', "<%= application %>_cron")
+
+  FileUtils.mkdir_p(target_dir)
+  cmd = "whenever -f #{crontab_def_file}"
+  run_process(cmd, target_file)
+end
+
+system("git add #{RAILS_ROOT}/config/edploy/copy/project_files/production/*/config/*_cron #{RAILS_ROOT}/config/edploy/copy/project_files/{staging,testmachine,qa,tryout}/config/*_cron")

data/templates/config/edploy/templates/passenger/activate.rb.erb

@@ -0,0 +1,2 @@
+sudo "ln -nsf #{deploy_to}/passenger/apache_vhost /etc/apache2/sites-available/#{application}"
+sudo "a2ensite #{application}"

data/templates/config/edploy/templates/passenger/after_config.rb.erb

@@ -0,0 +1,2 @@
+sudo "ln -nsf #{deploy_to}/passenger/apache_vhost /etc/apache2/sites-available/#{application}"
+sudo "a2ensite #{application}"