caploy 0.1.0

data/lib/caploy/recipes/symlink.rb

@@ -0,0 +1,24 @@
+Capistrano::Configuration.instance.load do
+
+  namespace :deploy do
+    desc <<-DESC
+      Symlink shared directories and files.
+    DESC
+    task :symlink_dependencies, :roles => :web, :except => {:no_release => true} do
+      shared_directories_to_link   = fetch(:shared_directories_to_link, [])
+      directories_to_create        = fetch(:directories_to_create, [])
+      files_to_delete              = fetch(:files_to_delete, [])
+      files_to_link                = fetch(:files_to_link, {})
+      chmods_to_set                = fetch(:chmods_to_set, [])
+
+      directories_to_create.each        { |directory| run "mkdir -p #{directory}" }
+      shared_directories_to_link.each   { |source, target| run "ln -s #{source} #{target}" }
+      files_to_delete.each              { |file| run "rm #{file}" }
+      files_to_link.each                { |source, target| run "ln -s #{source} #{target}"}
+      chmods_to_set.each                { |target, chmod| run "chmod #{chmod} #{target}" }
+    end
+  end
+
+  after 'deploy:finalize_update', 'deploy:symlink_dependencies'
+
+end

data/lib/caploy/recipes/unicorn.rb

@@ -0,0 +1,43 @@
+Capistrano::Configuration.instance.load do
+
+  _cset :unicorn_bin, "bundle exec unicorn"
+  _cset :unicorn_pid, "#{deploy_to}/current/tmp/pids/unicorn.pid"
+  _cset :unicorn_std_log, "log/unicorn.stderr.log"
+  _cset :unicorn_err_log, "log/unicorn.stderr.log"
+  _cset :unicorn_worker_processes, 2
+  _cset :unicorn_listen_backlog, 2048
+
+  require "capistrano-unicorn"
+
+  namespace :unicorn do
+    desc "Setup unicorn"
+    task :setup, :roles => :app, :except => { :no_release => true } do
+    run "mkdir -p \"#{shared_path}/config/unicorn\""
+      config_path = "#{shared_path}/config/unicorn/#{rails_env}.rb"
+      template_path = File.expand_path('../../templates/unicorn/unicorn.rb.erb', __FILE__)
+      vars = {
+          'application'=> application,
+          'current_path' => current_path,
+          'unicorn_pid' => unicorn_pid,
+          'unicorn_std_log' => unicorn_std_log,
+          'unicorn_err_log' => unicorn_err_log,
+          'stage' => stage,
+          'unicorn_listen_backlog' => unicorn_listen_backlog,
+          'unicorn_worker_processes' => unicorn_worker_processes
+      }
+      put(render_erb_template(template_path, vars), config_path)
+    end
+  end
+
+  after :"deploy:setup", :"unicorn:setup";
+
+  namespace :deploy do
+    task :start, :roles => :app do
+      unicorn.start
+    end
+
+    task :stop, :roles => :app do
+      unicorn.stop
+    end
+  end
+end

data/lib/caploy/recipes/unicorn_bluepill.rb

@@ -0,0 +1,90 @@
+
+#
+# sudoers:
+# %deploy ALL=(ALL) NOPASSWD: /usr/local/bin/bluepill, /sbin/start my_app_bluepill , /sbin/stop my_app_bluepill
+# sudo chown root:root deploy_conf
+# sudo chmod 0440 deploy_conf
+# => /etc/sudoers.d
+#
+Capistrano::Configuration.instance.load do
+
+  namespace :deploy do
+
+    task :start, :roles => :app, :except => { :no_release => true } do
+      sudo 'start bluepill_conf'
+    end
+
+    task :stop, :roles => :app, :except => { :no_release => true } do
+      sudo "bluepill stop"
+      sudo "stop bluepill_conf"
+    end
+
+    task :restart, :roles => :app, :except => { :no_release => true } do
+      sudo "bluepill restart unicorn"
+    end
+
+    #desc "Restart Resque Workers"
+    #task :restart_workers do
+    #  sudo "bluepill stop resque"
+    #  sudo "bluepill start resque"
+    #end
+    #
+    #desc "Start Resque Workers"
+    #task :start_workers do
+    #  sudo "bluepill start resque"
+    #end
+    #
+    #desc "Stop Resque Workers"
+    #task :stop_workers do
+    #  sudo "bluepill stop resque"
+    #end
+
+  end
+
+  namespace :bluepill do
+    desc "Prints bluepills monitored processes statuses"
+    task :status, :roles => [:app] do
+      sudo "bluepill status"
+    end
+
+    desc "Setup blupill config"
+    task :setup, :roles => [:app] do
+    setup_init
+    setup_config
+    end
+
+    task :setup_init do
+      template_path = File.expand_path('../../templates/bluepill/init.erb', __FILE__)
+      vars = {
+          'application' => application,
+          'config_path' => fetch(:bluepill_config_path, "#{shared_path}/config/bluepill_config.pill")
+      }
+
+      config_path = "#{shared_path}/config/bluepill_init.conf"
+
+      put(render_erb_template(template_path, vars), config_path)
+      sudo "rm -f /etc/init/bluepill_#{application}_#{stage}.conf"
+      sudo "ln -s #{config_path} /etc/init/bluepill_#{application}_#{stage}.conf"
+    end
+
+    task :setup_config do
+      template_path = File.expand_path('../../templates/bluepill/default_config.rb.erb', __FILE__)
+      log_file = "#{latest_release}/log/bluepill.log"
+      unicorn_config_path = "#{shared_path}/config/unicorn/#{stage}.rb"
+      vars = {
+          'application' => application,
+          'stage' => stage,
+          'log_file' => log_file,
+          'unicorn_config_path' => unicorn_config_path
+      }
+
+      config_path = fetch(:bluepill_config_path, "#{shared_path}/config/bluepill_config.pill")
+      put(render_erb_template(template_path, vars), config_path)
+
+    end
+  end
+
+  #after "deploy:restart", "deploy:restart_workers"
+  after "deploy:setup", "bluepill:setup"
+
+end

data/lib/caploy/recipes/whenever.rb

@@ -0,0 +1,8 @@
+Capistrano::Configuration.instance.load do
+
+  #set :whenever_environment, defer { stage }
+  #set :whenever_identifier, defer { "#{application}_#{stage}" }
+  #set :whenever_command, "bundle exec whenever"
+  #require "whenever/capistrano"
+
+end

data/lib/caploy/render.rb

@@ -0,0 +1,8 @@
+require 'erubis'
+
+def render_erb_template(template_path, vars={})
+  raise "file '#{template_path}' not exists" unless File.exist? template_path
+
+  template = File.open(template_path, 'r').read
+  Erubis::Eruby.new(template).result(vars)
+end

data/lib/caploy/templates/bluepill/init.erb

@@ -0,0 +1,9 @@
+description "<%= application %>"
+
+start on runlevel [2]
+stop on runlevel [016]
+
+expect daemon
+exec bluepill load <%= config_path %>
+
+respawn

data/lib/caploy/templates/bluepill/unicorn_config.rb.erb

@@ -0,0 +1,43 @@
+ENV["RAILS_ENV"] = "<%= stage %>"
+
+Bluepill.application("<%= application %>-<%= stage %>", :log_file => '<%= log_file %>') do |app|
+
+        app.process("unicorn") do |process|
+        process.pid_file = '<%= unicorn_config_path %>'
+        process.working_dir = '/var/my_app/current'
+
+        process.start_command = "/usr/local/bin/bundle exec unicorn -c /var/my_app/current/config/unicorn.rb -E staging -D"
+        process.stop_command = "kill -QUIT {{PID}}"
+        process.restart_command = "kill -USR2 {{PID}}"
+
+        process.uid = process.gid = 'deploy'
+
+        process.start_grace_time = 30.seconds
+        process.stop_grace_time = 30.seconds
+        process.restart_grace_time = 30.seconds
+
+
+        process.monitor_children do |child_process|
+            child_process.stop_command = "kill -QUIT {{PID}}"
+
+            child_process.checks :mem_usage, :every => 30.seconds, :below => 200.megabytes, :times => [3, 4], :fires => :stop
+            child_process.checks :cpu_usage, :every => 30.seconds, :below => 40, :times => [3, 4], :fires => :stop
+        end
+    end
+
+    2.times do |i|
+        app.process("resque-#{i}") do |process|
+            process.working_dir = '/var/my_app/current'
+            process.group = "resque"
+            process.start_command = "/usr/local/bin/bundle exec rake resque:work"
+            process.pid_file = "/var/my_app/shared/pids/my_app-resque-#{i}.pid"
+            process.stop_command = "kill -QUIT {{PID}}"
+            process.daemonize = true
+
+            process.start_grace_time = 30.seconds
+            process.stop_grace_time = 30.seconds
+            process.uid = process.gid = 'deploy'
+
+        end
+    end
+end

data/lib/caploy/templates/nginx/vhost.erb

@@ -0,0 +1,130 @@
+
+<% if with_upstream_server %>
+
+upstream <%= application %>_<%= stage %>_<%= protocol %>_server {
+  # fail_timeout=0 means we always retry an upstream even if it failed
+  # to return a good HTTP response (in case the Unicorn master nukes a
+  # single worker for timing out).
+
+  # This is the socket we configured in unicorn.rb
+  server unix:/tmp/socket.<%= application %>_<%= stage %>.sock fail_timeout=0;
+
+  # for TCP setups, point these to your backend servers
+  # server 127.0.0.1:8080 fail_timeout=0;
+  # server 192.168.0.8:8080 fail_timeout=0;
+  # server 192.168.0.9:8080 fail_timeout=0;
+}
+<% end %>
+
+<%= optional_nginx_http_content if protocol == 'http' %>
+<%= optional_nginx_https_content if protocol == 'https' %>
+
+server {
+
+  server_name <%= domain %>;
+
+<% if protocol == 'https' %>
+
+  listen 443 ssl;
+
+  ssl_certificate      <%= nginx_cert_dir %>/<%= application %>_cert.<%= cert_type %>;
+  ssl_certificate_key  <%= nginx_cert_dir %>/<%= application %>_cert.<%= key_type %>;
+
+  #ssl_ciphers               SSLv3+HIGH:RC4+MEDIUM:!aNULL:!eNULL:!3DES:!MD5:@STRENGTH;
+  #ssl_prefer_server_ciphers on;
+  #ssl_protocols             SSLv3;
+  #ssl_session_cache         shared:SSL:10m;
+
+  keepalive_timeout    70;
+
+<% else %>
+
+  listen 80;
+
+  # ~2 seconds is often enough for most folks to parse HTML/CSS and
+  # retrieve needed images/icons/frames, connections are cheap in
+  # nginx so increasing this is generally safe...
+  #keepalive_timeout 5;
+
+<% end %>
+
+  client_max_body_size 4G;
+
+<% if serve_static_files %>
+
+  # path for static files
+  root <%= project_root %>/public;
+
+<% if with_file_expire_max %>
+  location ~* \.(ico|css|js|gif|jpe?g|png)(\?[0-9]+)?$ {
+    expires max;
+    break;
+  }
+<% end %>
+
+<% end %>
+
+  <%= optional_http_content if protocol == 'http' %>
+  <%= optional_https_content if protocol == 'https' %>
+
+  # Prefer to serve static files directly from nginx to avoid unnecessary
+  # data copies from the application server.
+  #
+  # try_files directive appeared in in nginx 0.7.27 and has stabilized
+  # over time.  Older versions of nginx (e.g. 0.6.x) requires
+  # "if (!-f $request_filename)" which was less efficient:
+  # http://bogomips.org/unicorn.git/tree/examples/nginx.conf?id=v3.3.1#n127
+  try_files $uri/index.html $uri.html $uri @app;
+
+  location / {
+    # an HTTP header important enough to have its own Wikipedia entry:
+    #   http://en.wikipedia.org/wiki/X-Forwarded-For
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+
+    # enable this if and only if you use HTTPS, this helps Rack
+    # set the proper protocol for doing redirects:
+    # proxy_set_header X-Forwarded-Proto https;
+
+    # pass the Host: header from the client right along so redirects
+    # can be set properly within the Rack application
+    proxy_set_header Host $http_host;
+
+    # we don't want nginx trying to do something clever with
+    # redirects, we set the Host: header above already.
+    proxy_redirect off;
+
+    # set "proxy_buffering off" *only* for Rainbows! when doing
+    # Comet/long-poll/streaming.  It's also safe to set if you're using
+    # only serving fast clients with Unicorn + nginx, but not slow
+    # clients.  You normally want nginx to buffer responses to slow
+    # clients, even with Rails 3.1 streaming because otherwise a slow
+    # client can become a bottleneck of Unicorn.
+    #
+    # The Rack application may also set "X-Accel-Buffering (yes|no)"
+    # in the response headers do disable/enable buffering on a
+    # per-response basis.
+    # proxy_buffering off;
+
+  <% if protocol == 'https' %>
+    # This makes sure that Rack::SslEnforcer knows it's being accessed over SSL.
+    proxy_set_header X-Forwarded-Proto https;
+  <% end %>
+
+    if (!-f $request_filename) {
+      proxy_pass http://<%= application %>_<%= stage %>_<%= protocol %>_server;
+      break;
+    }
+
+    <% if auth_basic_title %>
+    auth_basic            "<%= auth_basic_title %>";
+    auth_basic_user_file  <%= auth_basic_password_file %>;
+    <% end %>
+  }
+
+  # Rails error pages
+  error_page 500 502 503 504 /500.html;
+  location = /500.html {
+  root <%= project_root %>/public;
+  }
+}
+

data/lib/caploy/templates/unicorn/unicorn.rb.erb

@@ -0,0 +1,34 @@
+working_directory "<%= current_path %>"
+pid "<%= unicorn_pid %>"
+stderr_path "<%= unicorn_std_log %>"
+stdout_path "<%= unicorn_err_log %>"
+
+listen "/tmp/socket.<%= application %>_<%= stage %>.sock", :backlog => <%= unicorn_listen_backlog %>
+worker_processes <%= unicorn_worker_processes %>
+timeout 30
+
+preload_app true
+
+before_fork do |server, worker|
+    # Disconnect since the database connection will not carry over
+    if defined? ActiveRecord::Base
+        ActiveRecord::Base.connection.disconnect!
+    end
+
+    # Quit the old unicorn process
+    old_pid = "#{server.config[:pid]}.oldbin"
+    if File.exists?(old_pid) && server.pid != old_pid
+        begin
+            Process.kill("QUIT", File.read(old_pid).to_i)
+        rescue Errno::ENOENT, Errno::ESRCH
+            # someone else did our job for us
+        end
+    end
+end
+
+after_fork do |server, worker|
+    # Start up the database connection again in the worker
+    if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.establish_connection
+    end
+end

data/lib/caploy/version.rb

@@ -0,0 +1,3 @@
+module Caploy
+  VERSION = "0.1.0"
+end

data/lib/caploy.rb

@@ -0,0 +1 @@
+require "caploy/version"

data/lib/examples/deploy.rb

@@ -0,0 +1,73 @@
+
+set :application, ''
+set :domain, ''
+set :deploy_domain, ''
+set :vhost_domain, ''
+
+# set application folder
+set :deploy_to, "/var/projects/#{application}/xxx"
+
+set :rails_root, File.expand_path('../../', __FILE__)
+set :rails_env, :production # use 'stage' to differ between stage environments
+
+set :user,  'deploy'
+
+server domain, :web, :app, :db, :primary => true
+
+# Multistage settings
+#set :stage_dir, File.dirname(__FILE__) + '/deploy/stages'
+#set :default_stage, "vagrant"
+#require 'capistrano/ext/multistage'
+
+# database
+set :db_name, ''
+set :db_user_name, ''
+set :db_user_password, ''
+
+set :branch, ENV['BRANCH'] || 'develop'
+set :repository, 'xxx.git'
+
+set(:shared_directories_to_create) {
+  %W(#{shared_path}/bundle #{shared_path}/cache)
+}
+
+set(:shared_directories_to_link) {
+  {
+      "#{shared_path}/bundle/" => "#{release_path}/vendor/bundle"
+  }
+}
+
+set(:directories_to_create) {
+  %W()
+}
+
+set(:files_to_link) {
+  {
+      "#{shared_path}/config/config.#{stage}.yml" => "#{release_path}/config/config.local.yml",
+      "#{shared_path}/config/unicorn.#{stage}.rb" => "#{release_path}/config/unicorn.production.rb"
+  }
+}
+
+set(:files_to_delete) {
+  %W()
+}
+
+set(:chmods_to_set) {
+  {
+#    "#{shared_path}/data/pdf"         => 755
+  }
+}
+
+require 'caploy/recipes/defaults'
+
+require 'caploy/recipes/rbenv'
+require 'caploy/recipes/assets'
+require 'caploy/recipes/nginx'
+require 'caploy/recipes/bundler'
+require 'caploy/recipes/symlink'
+require 'caploy/recipes/unicorn'
+require 'caploy/recipes/setup'
+require 'caploy/recipes/monitoring'
+require 'caploy/recipes/seeding'
+#require 'caploy/recipes/paperclip'
+#require 'caploy/recipes/airbrake'

data/lib/mysql.rb

@@ -0,0 +1,109 @@
+module Database
+  class Base 
+    attr_accessor :config, :output_file
+    def initialize(cap_instance)
+      @cap = cap_instance
+    end
+    
+    def mysql?
+      @config['adapter'] == 'mysql' || @config['adapter'] == 'mysql2'
+    end
+    
+    def credentials
+      " -u #{@config['username']} " + (@config['password'] ? " -p\"#{@config['password']}\" " : '') + (@config['host'] ? " -h #{@config['host']}" : '')
+    end
+    
+    def database
+      @config['database']
+    end
+    
+    def output_file
+      @output_file ||= "db/dump_#{database}.sql.bz2"
+    end
+    
+  private
+    def dump_cmd
+      "mysqldump #{credentials} #{database}"
+    end
+
+    def import_cmd(file)
+      "mysql #{credentials} -D #{database} < #{file}"
+    end
+  end
+
+  class Remote < Base
+    def initialize(cap_instance)
+      super(cap_instance)
+      @cap.run("cat #{@cap.current_path}/config/database.yml") { |c, s, d| @config = YAML.load(d)[(@cap.rails_env || 'production').to_s] }
+    end
+          
+    def dump
+      @cap.run "cd #{@cap.current_path}; #{dump_cmd} | bzip2 - - > #{output_file}"
+      self
+    end
+    
+    def download(local_file = "#{output_file}")
+      remote_file = "#{@cap.current_path}/#{output_file}"
+      @cap.get remote_file, local_file
+    end
+    
+    # cleanup = true removes the mysqldump file after loading, false leaves it in db/
+    def load(file, cleanup)
+      unzip_file = File.join(File.dirname(file), File.basename(file, '.bz2'))
+      @cap.run "cd #{@cap.current_path}; bunzip2 -f #{file} && RAILS_ENV=#{@cap.rails_env} rake db:drop db:create && #{import_cmd(unzip_file)}"
+      File.unlink(unzip_file) if cleanup
+    end
+  end
+
+  class Local < Base
+    def initialize(cap_instance)
+      super(cap_instance)
+      @config = YAML.load_file(File.join('config', 'database.yml'))[@cap.local_rails_env]
+    end
+    
+    # cleanup = true removes the mysqldump file after loading, false leaves it in db/
+    def load(file, cleanup)
+      unzip_file = File.join(File.dirname(file), File.basename(file, '.bz2'))
+      system("bunzip2 -f #{file} && rake db:drop db:create && #{import_cmd(unzip_file)} && rake db:migrate") 
+      File.unlink(unzip_file) if cleanup
+    end
+    
+    def dump
+      system "#{dump_cmd} | bzip2 - - > #{output_file}"
+      self
+    end
+    
+    def upload
+      remote_file = "#{@cap.current_path}/#{output_file}"
+      @cap.upload output_file, remote_file
+    end
+  end
+  
+  class << self
+    def check(local_db, remote_db) 
+      unless local_db.mysql? && remote_db.mysql?
+        raise 'Only mysql on remote and local server is supported' 
+      end
+    end
+
+    def remote_to_local(instance) 
+      local_db  = Database::Local.new(instance)
+      remote_db = Database::Remote.new(instance)
+
+      check(local_db, remote_db)
+    
+      remote_db.dump.download
+      local_db.load(remote_db.output_file, instance.fetch(:db_local_clean))
+    end
+    
+    def local_to_remote(instance)
+      local_db  = Database::Local.new(instance)
+      remote_db = Database::Remote.new(instance)
+
+      check(local_db, remote_db)
+      
+      local_db.dump.upload
+      remote_db.load(local_db.output_file, instance.fetch(:db_local_clean))
+    end
+  end
+end

data/lib/util.rb

@@ -0,0 +1,10 @@
+module Util
+  def self.prompt(msg, prompt = "(y)es, (n)o ")
+    answer = Capistrano::CLI.ui.ask("#{msg} #{prompt} ? ") do |q|
+      q.overwrite = false
+      q.validate = /^y$|^yes$|^n$|^no$/i
+      q.responses[:not_valid] = prompt
+    end
+    (answer =~ /^y$|^yes$/i) == 0
+  end
+end