deployinator 0.0.0 → 0.0.1

data/lib/deployinator/config.rb

@@ -1,17 +1,75 @@
-namespace :config do
-  set :stage, :staging
-  desc 'Write deploy_example.rb and <stage>_example.rb files'
-  task :write_examples do
-    run_locally do
-      execute "mkdir -p ./config/deploy"
+namespace :deployinator do
+
+#  desc 'Ensure all deployinator specific settings are set, and warn and raise if not.'
+#  task :check_settings do
+#    run_locally do
+#      deploy_rb         = File.expand_path("./config/deploy.rb")
+#      deploy_dir        = File.expand_path("./config/deploy")
+#      {
+#        "Do not \"set :bundle_binstubs, ....\", deployinator will overwrite it and you'll be confused." =>
+#          system("grep -R -q -E '^set\ :bundle_binstubs' #{deploy_rb} #{deploy_dir}"),
+#        "Do not \"set :bundle_gemfile, ....\", deployinator will overwrite it and you'll be confused." =>
+#          system("grep -R -q -E '^set\ :bundle_gemfile' #{deploy_rb} #{deploy_dir}"),
+#        "You need \"set :domain, 'your.domain.com'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:domain).nil?,
+#        "You need \"set :nginx_container_name, 'your_nginx_container_name'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:nginx_container_name).nil?,
+#        "You need \"set :external_socket_path, 'your_external_socket_path'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:external_socket_path).nil?,
+#        "You need \"set :postgres_container_name, 'your_postgres_container_name'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:postgres_container_name).nil?,
+#        "You need \"set :postgres_port, 'your_postgres_port_number'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:postgres_port).nil?,
+#        "You need \"set :ruby_image_name, 'your_ruby_image_name'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:ruby_image_name).nil?,
+#        "You need \"set :ruby_container_name, 'your_ruby_container_name'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:ruby_container_name).nil?,
+#        "You need \"set :ruby_container_max_mem_mb, 'your_ruby_container_max_mem_mb'\" in your config/deploy/#{fetch(:stage)}.rb file." =>
+#          fetch(:ruby_container_max_mem_mb).nil?
+#      }.each do |message, true_false|
+#        fatal(message) and raise if true_false
+#      end
+#    end
+#  end
+#  before 'deploy:starting', 'deployinator:check_settings'
 
-      # example deploy.rb
-      config = "set :application, 'example-app'"
-      File.open('./config/deploy_example.rb', 'w') { |f| f.write(config) }
+  # TODO make this better
+  task :check_templates do
+    run_locally do
+      keys_template     = File.expand_path("./templates/deploy/deployer_authorized_keys.erb")
+      bluepill_template = File.expand_path("./templates/deploy/#{fetch(:application)}_bluepill.rb.erb")
+      unicorn_template  = File.expand_path("./templates/deploy/#{fetch(:application)}_unicorn.rb.erb")
+      {
+        "You need a templates/deploy/deployer_authorized_keys.erb file."            => keys_template,
+        "You need a templates/deploy/#{fetch(:application)}_bluepill.rb.erb file."  => bluepill_template,
+        "You need a templates/deploy/#{fetch(:application)}_unicorn.rb.erb file."   => unicorn_template,
+      }.each do |message, file|
+        fatal(message) and raise unless File.exists? file
+      end
+    end
+  end
+  before 'deploy:starting', 'deployinator:check_templates'
 
-      # example <stage>.rb
-      config = "set :example_attr, true"
-      File.open('./config/deploy/stage_example.rb', 'w') { |f| f.write(config) }
+  desc 'Write example config files'
+  task :install do
+    run_locally do
+      execute "mkdir -p config/deploy templates/deploy"
+      {
+        "examples/Capfile"                                => "Capfile_example",
+        "examples/config/deploy.rb"                       => "config/deploy_example.rb",
+        "examples/config/deploy_deployinator.rb"          => "config/deploy_deployinator_example.rb",
+        "examples/config/deploy/staging.rb"               => "config/deploy/staging_example.rb",
+        "examples/config/deploy/staging_deployinator.rb"  => "config/deploy/staging_deployinator_example.rb",
+        "examples/Dockerfile"                             => "templates/deploy/Dockerfile_example",
+        "examples/deployer_authorized_keys.erb"           => "templates/deploy/deployer_authorized_keys_example.erb",
+        "examples/application_unicorn.rb.erb"             => "templates/deploy/#{fetch(:application, "my_app")}_unicorn_example.rb.erb",
+        "examples/application_bluepill.rb.erb"            => "templates/deploy/#{fetch(:application, "my_app")}_bluepill_example.rb.erb"
+      }.each do |source, destination|
+        config = File.read(File.dirname(__FILE__) + "/#{source}")
+        File.open("./#{destination}", 'w') { |f| f.write(config) }
+        info "Wrote '#{destination}'"
+      end
+      info "Now remove the '_example' portion of their names or diff with existing files and add the needed lines."
     end
   end
 end

data/lib/deployinator/deploy.rb

@@ -1,119 +1,332 @@
 # config valid only for Capistrano 3.1
 lock '3.2.1'
 
-# Use `from_local=true bundle exec cap <stage> deploy` to deploy your
-#   locally changed code instead of the code in the git repo.
-#   TODO this is not working yet
-if ENV['from_local']
-  set :repo_url, 'file://.'
-  set :scm, :none
-else
-  set :repo_url, 'git@github.com:snarlysodboxer/example.git'
-  set :scm, :git
-end
+namespace :deploy do
 
-# Default branch is :master
-# ask :branch, proc { `git rev-parse --abbrev-ref HEAD`.chomp }.call
+  task :set_bundle_command_map => [:set_deployer_user_id] do
+    SSHKit.config.command_map[:bundle] = [
+      "/usr/bin/env docker run --rm --tty",
+      "--user", fetch(:deployer_user_id),
+      "-e", "GEM_HOME=#{fetch(:deploy_to)}/shared/bundle",
+      "-e", "GEM_PATH=#{fetch(:deploy_to)}/shared/bundle",
+      "-e", "PATH=#{fetch(:deploy_to)}/shared/bundle/bin:$PATH",
+      "--entrypoint", "#{fetch(:deploy_to)}/shared/bundle/bin/bundle",
+      "--volume #{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+      fetch(:ruby_image_name)
+    ].join(' ')
+  end
+  before 'bundler:install', 'deploy:set_bundle_command_map'
 
-# Default deploy_to directory is /var/www/my_app
-# set :deploy_to, '/var/www/my_app'
+  task :set_rm_command_map do
+    SSHKit.config.command_map[:rm] = "/usr/bin/env sudo rm"
+  end
+  before 'deploy:started', 'deploy:set_rm_command_map'
 
-# Default value for :format is :pretty
-# set :format, :pretty
+  # Append dependancy to existing cleanup task
+  task :cleanup => :set_rm_command_map
 
-# Default value for :log_level is :debug
-#set :log_level, :debug
-set :log_level, :info
+  # Overwrite :assets:precompile to use docker
+  Rake::Task["deploy:assets:precompile"].clear
+  namespace :assets do
+    task :precompile do
+      on roles(fetch(:assets_roles)) do
+        execute(
+          "docker", "run", "--rm", "--tty",
+          "-w", fetch(:release_path, "#{fetch(:deploy_to)}/current"),
+          "--entrypoint", "#{fetch(:deploy_to)}/shared/bundle/bin/rake",
+          "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+          fetch(:ruby_image_name), "assets:precompile"
+        )
+      end
+    end
+  end
 
-# Default value for :pty is false
-# set :pty, true
+  # Overwrite :cleanup_assets to use docker
+  Rake::Task["deploy:cleanup_assets"].clear
+  desc 'Cleanup expired assets'
+  task :cleanup_assets => [:set_rails_env] do
+    on roles(fetch(:assets_roles)) do
+      execute(
+        "docker", "run", "--rm", "--tty",
+        "-e", "RAILS_ENV=#{fetch(:rails_env)}",
+        "-w", fetch(:release_path, "#{fetch(:deploy_to)}/current"),
+        "--entrypoint", "#{fetch(:deploy_to)}/shared/bundle/bin/bundle",
+        "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+        fetch(:ruby_image_name), "exec", "rake", "assets:clean"
+      )
+    end
+  end
 
-# Default value for :linked_files is []
-# set :linked_files, %w{config/nginx.conf}
+  # Overwrite :migrate to use docker
+  Rake::Task["deploy:migrate"].clear
+  desc 'Runs rake db:migrate if migrations are set'
+  task :migrate => [:set_rails_env, :ensure_running_postgres] do
+    on primary fetch(:migration_role) do
+      conditionally_migrate = fetch(:conditionally_migrate)
+      info '[deploy:migrate] Checking changes in /db/migrate' if conditionally_migrate
+      if conditionally_migrate && test("diff -q #{release_path}/db/migrate #{current_path}/db/migrate")
+        info '[deploy:migrate] Skip `deploy:migrate` (nothing changed in db/migrate)'
+      else
+        info '[deploy:migrate] Run `rake db:migrate`' if conditionally_migrate
+        execute(
+          "docker", "run", "--rm", "--tty",
+          "--link", "#{fetch(:postgres_container_name)}:postgres",
+          "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+          "-e", "RAILS_ENV=#{fetch(:rails_env)}",
+          "--entrypoint", "#{fetch(:deploy_to)}/shared/bundle/bin/rake",
+          "-w", fetch(:release_path, "#{fetch(:deploy_to)}/current"),
+          fetch(:ruby_image_name), "db:migrate"
+        )
+      end
+    end
+  end
 
-# Default value for linked_dirs is []
-# set :linked_dirs, %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle public/system}
+  # TODO make this better
+  task :ensure_running_postgres do
+    on primary fetch(:migration_role) do
+      unless capture("nc", "127.0.0.1", fetch(:postgres_port), "<", "/dev/null", ">", "/dev/null;", "echo", "$?").strip == "0"
+        fatal "Port #{fetch(:postgres_port)} is not responding, cannot db:migrate!"
+        raise
+      end
+    end
+  end
+#  task :ensure_running_postgres do
+#    on primary fetch(:migration_role) do
+#      if test "docker", "inspect", fetch(:postgres_container_name), "&>", "/dev/null"
+#        if (capture "docker", "inspect",
+#            "--format='{{.State.Running}}'",
+#            fetch(:postgres_container_name)).strip == "true"
+#        else
+#          execute "docker", "start", fetch(:postgres_container_name)
+#        end
+#      else
+#        set :run_pg_setup, ask("'true' or 'false', - #{fetch(:postgres_container_name)} is not running, would you like to run 'rake pg:setup'?", "false")
+#        if fetch(:run_pg_setup) == "true"
+#          #load Gem.bin_path('bundler', 'bundle')
+#          #import 'postgresinator'
+#          #load './infrastructure/Rakefile'
+#          Rake::Task['pg:setup'].invoke
+#        else
+#          raise "#{fetch(:postgres_container_name)} is not running, can't run db:migrate!"
+#        end
+#      end
+#    end
+#  end
+  before 'deploy:started', :ensure_running_postgres
 
-# Default value for default_env is {}
-# set :default_env, { path: "/opt/ruby/bin:$PATH" }
+  before 'deploy:check', :setup_deployer_user do
+    on "#{ENV['USER']}@#{fetch(:domain)}" do
+      as :root do
+        unless test "id", fetch(:deploy_username)
+          execute "adduser", "--disabled-password", "--gecos", "\"\"", fetch(:deploy_username)
+          execute "usermod", "-a", "-G", "sudo", fetch(:deploy_username)
+          execute "usermod", "-a", "-G", "docker", fetch(:deploy_username)
+        end
+        execute "mkdir", "-p", "/home/#{fetch(:deploy_username)}/.ssh"
+        # not actually using ERB interpolation, no need for an instance variable.
+        template_path = File.expand_path("./templates/deploy/#{fetch(:deploy_username)}_authorized_keys.erb")
+        generated_config_file = ERB.new(File.new(template_path).read).result(binding)
+        # upload! does not yet honor "as" and similar scoping methods
+        upload! StringIO.new(generated_config_file), "/tmp/authorized_keys"
+        execute "mv", "-b", "/tmp/authorized_keys", "/home/#{fetch(:deploy_username)}/.ssh/authorized_keys"
+        execute "chown", "-R", "#{fetch(:deploy_username)}:#{fetch(:deploy_username)}", "/home/#{fetch(:deploy_username)}/.ssh"
+        execute "chmod", "700", "/home/#{fetch(:deploy_username)}/.ssh"
+        execute "chmod", "600", "/home/#{fetch(:deploy_username)}/.ssh/authorized_keys"
+      end
+    end
+  end
 
-# Default value for keep_releases is 5
-# set :keep_releases, 5
+  task :ensure_www_data_user do
+    on "#{ENV['USER']}@#{fetch(:domain)}" do
+      as :root do
+        unless test "id", "www-data"
+          execute "adduser", "--disabled-password", "--gecos", "\"\"", "www-data"
+        end
+      end
+    end
+  end
+  after 'deploy:started', :ensure_www_data_user
 
-namespace :deploy do
+  task :set_deployer_user_id do
+    on roles(:app), in: :sequence, wait: 5 do
+      set :deployer_user_id, capture("id", "-u", fetch(:deploy_username)).strip
+    end
+  end
 
-  # :started is the hook before which to set/check your needed environment/settings
-  before :started, :ensure_setup
+  task :set_www_data_user_id do
+    on roles(:app), in: :sequence, wait: 5 do
+      set :www_data_user_id, capture("id", "-u", "www-data").strip
+    end
+  end
 
-  task :ensure_setup do
-    on roles(:web), :once => true do
-      raise "You need to use ruby 1.9 or higher where you are running this capistrano command." unless RUBY_VERSION >= "1.9"
-      test "bash", "-l", "-c", "'docker", "ps", "&>", "/dev/null", "||", "sudo", "usermod", "-a", "-G", "docker", "$USER'"
+  task :chown_log_dir => :set_www_data_user_id do
+    on roles(:app), in: :sequence, wait: 5 do
+      as :root do
+        unless test "[", "-d", "#{fetch(:deploy_to)}/shared/log", "]"
+          execute("mkdir", "-p", "#{fetch(:deploy_to)}/shared/log")
+        end
+        execute "chown", "-R", "#{fetch(:www_data_user_id)}:#{fetch(:www_data_user_id)}", "#{fetch(:deploy_to)}/shared/log"
+      end
     end
   end
+  before 'deploy:check:linked_dirs', :chown_log_dir
 
-  # do this so capistrano has permissions to remove old releases
-  before :updating, :revert_permissions do
-    on roles(:web) do
-      if test "[", "-d", "#{releases_path}", "]"
-        execute "bash", "-l", "-c", "'sudo", "chown", "-R", "deployer.", "#{releases_path}'"
+  task :setup_deploy_to_dir => :set_deployer_user_id do
+    on roles(:app), in: :sequence, wait: 5 do
+      as :root do
+        [
+          fetch(:deploy_to),
+          "#{fetch(:deploy_to)}/shared",
+          "#{fetch(:deploy_to)}/releases"
+        ].each do |dir|
+          unless test "[", "-d", dir, "]"
+            execute("mkdir", "-p", dir)
+          end
+          execute "chown", "#{fetch(:deployer_user_id)}:#{fetch(:deployer_user_id)}", dir
+        end
       end
     end
   end
+  after :setup_deployer_user, :setup_deploy_to_dir
 
-  before :restart, :ensure_permissions do
-    on roles(:web) do
-      execute "bash", "-l", "-c", "'sudo", "mkdir", "-p", "#{current_path}/data/cache'"
-      execute "bash", "-l", "-c", "'sudo", "chown", "-R", "www-data.", "#{current_path}/data'"
+  task :install_bundler => :set_deployer_user_id do
+    on roles(:app), in: :sequence, wait: 5 do
+      as :root do
+        unless test "[", "-f", "#{fetch(:deploy_to)}/shared/bundle/bin/bundle", "]"
+          execute(
+            "docker", "run", "--rm", "--tty",
+            "-e", "GEM_HOME=#{fetch(:deploy_to)}/shared/bundle",
+            "-e", "GEM_PATH=#{fetch(:deploy_to)}/shared/bundle",
+            "-e", "PATH=#{fetch(:deploy_to)}/shared/bundle/bin:$PATH",
+            "--entrypoint", "/usr/local/bin/gem",
+            "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+            fetch(:ruby_image_name), "install",
+            "--install-dir", "#{fetch(:deploy_to)}/shared/bundle",
+            "--bindir", "#{fetch(:deploy_to)}/shared/bundle/bin",
+            "--no-ri", "--no-rdoc", "--quiet", "bundler", "-v'#{fetch(:bundler_version)}'"
+          )
+        end
+        execute "chown", "-R", "#{fetch(:deployer_user_id)}:#{fetch(:deployer_user_id)}", "#{fetch(:deploy_to)}/shared/bundle"
+      end
     end
   end
+  before 'bundler:install', 'deploy:install_bundler'
 
-  #desc 'Install config files in current_path'
-  before :restart, :install_config_files do
-    on roles(:web) do |host|
-      require 'erb'
-      { 'config/nginx.conf.erb'   => "#{current_path}/config/#{fetch(:application)}-nginx.conf",
-        'config/php-fpm.conf.erb' => "#{current_path}/config/#{fetch(:application)}-php-fpm.conf",
-        'config/php.ini.erb'      => "#{current_path}/config/#{fetch(:application)}-php.ini"
-      }.each do |template, upload_path|
-        @worker_processes = fetch(:worker_processes)
-        template_path = File.expand_path(template)
-        host_config   = ERB.new(File.new(template_path).read).result(binding)
-        upload! StringIO.new(host_config), upload_path
+  desc 'Restart application'
+  task :restart => [:set_www_data_user_id, :install_config_files] do
+    on roles(:app), in: :sequence, wait: 5 do
+      if test "docker", "inspect", fetch(:ruby_container_name), "&>", "/dev/null"
+        if (capture "docker", "inspect",
+            "--format='{{.State.Restarting}}'",
+            fetch(:ruby_container_name)).strip == "true"
+          execute("docker", "stop", fetch(:ruby_container_name))
+          execute("docker", "wait", fetch(:ruby_container_name))
+        end
+        if (capture "docker", "inspect",
+            "--format='{{.State.Running}}'",
+            fetch(:ruby_container_name)).strip == "true"
+          execute(
+            "docker", "exec", "--tty",
+            fetch(:ruby_container_name),
+            "#{fetch(:deploy_to)}/shared/bundle/bin/bluepill",
+            fetch(:application), "stop"
+          )
+          sleep 5
+          execute("docker", "stop", fetch(:ruby_container_name))
+          execute("docker", "wait", fetch(:ruby_container_name))
+        end
+        sleep 2
+        begin
+          execute("docker", "rm",   fetch(:ruby_container_name))
+        rescue
+          sleep 5
+          begin
+            execute("docker", "rm",   fetch(:ruby_container_name))
+          rescue
+            fatal "We were not able to remove the container for some reason. Try running 'cap <stage> deploy:restart' again."
+          end
+        end
+      end
+      as :root do
+        [
+          fetch(:external_socket_path),
+          "#{fetch(:deploy_to)}/current/public",
+          "#{fetch(:deploy_to)}/shared/tmp",
+          "#{fetch(:deploy_to)}/shared/log/production.log"
+        ].each do |directory|
+          execute "chown", "-R", "#{fetch(:www_data_user_id)}:#{fetch(:www_data_user_id)}", directory
+        end
+        execute "chown", "-R", "#{fetch(:deployer_user_id)}:#{fetch(:deployer_user_id)}", "#{fetch(:deploy_to)}/shared/bundle"
       end
+      execute("docker", "run", fetch(:docker_run_bluepill_command))
     end
   end
+  after :publishing, :restart
 
-  desc 'Restart or start application'
-  task :restart do
-    on roles(:web) do
-      ['php5', 'nginx'].each do |name|
-        container = {
-          :name         => fetch("#{name}_container_name".to_sym),
-          :run_options  => fetch("#{name}_run_options".to_sym).join(' '),
-          :image        => fetch("#{name}_image_name".to_sym)
-        }
-        exists      = "docker inspect #{container[:name]} &> /dev/null"
-        is_running  = "docker inspect --format='{{.State.Running}}' #{container[:name]} 2>&1 | grep -q true"
-        if test(exists)
-          if test(is_running)
-            execute "docker", "stop", container[:name]
+  after :publishing, :check_nginx_running do
+    on primary fetch(:migration_role) do
+      if test "docker", "inspect", fetch(:nginx_container_name), "&>", "/dev/null"
+        if (capture "docker", "inspect",
+            "--format='{{.State.Running}}'",
+            fetch(:nginx_container_name)).strip == "true"
+        else
+          warn "The nginx container named #{fetch(:nginx_container_name)} exists but is not running. (You need this, start it, or re-run setup with something like nginxinator.)"
+        end
+      else
+        warn "No nginx container named #{fetch(:nginx_container_name)} exists! (You need this, set it up with something like nginxinator.)"
+      end
+    end
+  end
+
+  after :publishing, :ensure_cadvisor do
+    on roles(:app), in: :sequence, wait: 5 do
+      if fetch(:use_cadvisor, true)
+        if test "docker", "inspect", "cadvisor", "&>", "/dev/null"
+          if (capture "docker", "inspect",
+              "--format='{{.State.Running}}'",
+              "cadvisor").strip == "true"
+            info "cadvisor is already running."
+          else
+            info "Restarting existing cadvisor container."
+            execute "docker", "start", "cadvisor"
           end
-          execute "docker", "rm", container[:name]
+        else
+          execute("docker", "run", fetch(:docker_run_cadvisor_command))
+        end
+      end
+    end
+  end
+
+  after :restart, :clear_cache do
+    on roles(:web), in: :groups, limit: 3, wait: 10 do
+      # Here we can do anything such as:
+      # within release_path do
+      #   execute :rake, 'cache:clear'
+      # end
+    end
+  end
+
+  task :install_config_files => [:set_deployer_user_id] do
+    on roles(:app), in: :sequence, wait: 5 do
+      set :bluepill_config, -> { "#{fetch(:application)}_bluepill.rb" }
+      set :unicorn_config,  -> { "#{fetch(:application)}_unicorn.rb" }
+      set :socket_path,     -> { fetch(:internal_socket_path) }
+      as 'root' do
+        [fetch(:bluepill_config), fetch(:unicorn_config)].each do |config_file|
+          @deploy_to            = fetch(:deploy_to)   # needed for ERB
+          @internal_socket_path = fetch(:socket_path) # needed for ERB
+          @application          = fetch(:application) # needed for ERB
+          template_path = File.expand_path("./templates/deploy/#{config_file}.erb")
+          current_path  = Pathname.new("#{fetch(:deploy_to)}/current")
+          generated_config_file = ERB.new(File.new(template_path).read).result(binding)
+          set :final_path, -> { fetch(:release_path, current_path).join('config', config_file) }
+          upload! StringIO.new(generated_config_file), "/tmp/#{config_file}"
+          execute("mv", "/tmp/#{config_file}", fetch(:final_path))
+          execute("chown", "#{fetch(:deployer_user_id)}:#{fetch(:deployer_user_id)}", fetch(:final_path))
+          execute("chmod", "664", fetch(:final_path))
         end
-        execute(
-          "docker", "run",
-          "--detach", "--tty",
-          "--name", container[:name],
-          container[:run_options],
-          container[:image]
-        )
-        sleep 2
-        error("Container #{container[:name]} did not stay running more than 2 seconds!") unless test(is_running)
       end
     end
   end
 
-  # :publishing is the hook after which to set our service restart commands
-  after :publishing, :restart
 end

data/lib/deployinator/examples/Capfile

@@ -0,0 +1,27 @@
+# Load DSL and Setup Up Stages
+require 'capistrano/setup'
+
+# Includes default deployment tasks
+require 'capistrano/deploy'
+
+# Includes tasks from other gems included in your Gemfile
+#
+# For documentation on these, see for example:
+#
+#   https://github.com/capistrano/rvm
+#   https://github.com/capistrano/rbenv
+#   https://github.com/capistrano/chruby
+#   https://github.com/capistrano/bundler
+#   https://github.com/capistrano/rails
+#
+# require 'capistrano/rvm'
+# require 'capistrano/rbenv'
+# require 'capistrano/chruby'
+require 'capistrano/bundler'
+require 'capistrano/rails/assets'
+require 'capistrano/rails/migrations'
+
+require 'deployinator'
+
+# Loads custom tasks from `lib/capistrano/tasks' if you have any defined.
+Dir.glob('lib/capistrano/tasks/*.rake').each { |r| import r }

data/lib/deployinator/examples/Dockerfile

@@ -0,0 +1,16 @@
+# vi: ft=config
+FROM ubuntu:12.04
+MAINTAINER david amick <docker@davidamick.com>
+
+ENV DEBIAN_FRONTEND noninteractive
+
+RUN /bin/bash -c "apt-get update -qq && apt-get install -qy wget curl bzip2 make gcc"
+RUN wget -O ruby-install-0.5.0.tar.gz https://github.com/postmodern/ruby-install/archive/v0.5.0.tar.gz
+RUN tar -xzvf ruby-install-0.5.0.tar.gz
+RUN cd ruby-install-0.5.0/ && make install && ruby-install --system ruby 1.9.3-p547
+RUN gem install bundler --no-ri --no-rdoc
+
+RUN /bin/bash -c "apt-get update -qq && apt-get install -qy libxml2 libxml2-dev libxslt1-dev nodejs postgresql-contrib libpq-dev"
+
+ENTRYPOINT ["/bin/bash"]
+CMD ["-l"]

data/lib/deployinator/examples/application_bluepill.rb.erb

@@ -0,0 +1,27 @@
+def red_unicorn_exec
+  "<%= @deploy_to %>/shared/bundle/bin/red_unicorn --env production --pid-file <%= @internal_socket_path %>/unicorn.pid --unicorn-exec <%= @deploy_to %>/shared/bundle/bin/unicorn_rails --unicorn-config <%= @deploy_to %>/current/config/<%= @application %>_unicorn.rb"
+end
+
+Bluepill.application("<%= @application %>", :log_file => "<%= @deploy_to %>/shared/log/bluepill.log", :foreground => true) do |app|
+  app.process("unicorn") do |process|
+    process.pid_file = "<%= @internal_socket_path %>/unicorn.pid"
+    process.working_dir = "<%= @deploy_to %>/current"
+    process.environment = {"BUNDLE_GEMFILE" => "<%= @deploy_to %>/current/Gemfile"}
+    process.start_command = "#{red_unicorn_exec} start"
+    process.stop_command = "#{red_unicorn_exec} stop"
+    process.restart_command = "'#{red_unicorn_exec} status; if [ $? = 0 ]; then #{red_unicorn_exec} restart; else #{red_unicorn_exec} start; fi'"
+
+    process.uid = process.gid = 'www-data'
+
+    process.start_grace_time = 30.seconds
+    process.stop_grace_time = 30.seconds
+    process.restart_grace_time = 60.seconds
+
+    process.monitor_children do |child_process|
+      child_process.stop_command = "kill -QUIT {{PID}}"
+
+      child_process.checks :mem_usage, :every => 30.seconds, :below => 300.megabytes, :times => [3,4], :fires => :stop
+      child_process.checks :cpu_usage, :every => 30.seconds, :below => 50, :times => [3,4], :fires => :stop
+    end
+  end
+end

data/lib/deployinator/examples/application_unicorn.rb.erb

@@ -0,0 +1,40 @@
+current_path = "<%= @deploy_to %>/current"
+shared_path = "<%= @deploy_to %>/shared"
+shared_bundler_gems_path = "<%= @deploy_to %>/shared/bundle"
+
+worker_processes 4
+working_directory current_path
+listen "<%= @internal_socket_path %>/unicorn.socket", :backlog => 64
+timeout 300
+pid "<%= @internal_socket_path %>/unicorn.pid"
+
+stderr_path "#{shared_path}/log/unicorn.stderr.log"
+stdout_path "#{shared_path}/log/unicorn.stdout.log"
+
+preload_app true
+GC.respond_to?(:copy_on_write_friendly=) and
+  GC.copy_on_write_friendly = true
+
+before_fork do |server, worker|
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+end
+
+after_fork do |server, worker|
+  worker.user('www-data', 'www-data') if Process.euid == 0
+
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+end
+
+before_exec do |server|
+  # Configure bundler to use proper paths if app provides a Gemfile
+  if(File.exists?("#{current_path}/Gemfile"))
+    paths = ENV["PATH"].to_s.split(':')
+    paths.unshift "#{shared_bundler_gems_path}/bin"
+    ENV["PATH"] = paths.uniq.join(':')
+
+    ENV['GEM_HOME'] = ENV['GEM_PATH'] = shared_bundler_gems_path
+    ENV['BUNDLE_GEMFILE'] = "#{current_path}/Gemfile"
+  end
+end

data/lib/deployinator/examples/config/deploy/staging.rb

@@ -0,0 +1,50 @@
+# Simple Role Syntax
+# ==================
+# Supports bulk-adding hosts to roles, the primary server in each group
+# is considered to be the first unless any hosts have the primary
+# property set.  Don't declare `role :all`, it's a meta role.
+
+set  :domain,           "my-app-staging.example.com"
+set  :deploy_username,  "deployer"
+set  :user_host,        "#{fetch(:deploy_username)}@#{fetch(:domain)}"
+
+role :app, fetch(:user_host)
+role :web, fetch(:user_host)
+role :db,  fetch(:user_host)
+
+# Extended Server Syntax
+# ======================
+# This can be used to drop a more detailed server definition into the
+# server list. The second argument is a, or duck-types, Hash and is
+# used to set extended properties on the server.
+
+#server 'example.com', user: 'deploy', roles: %w{web app}, my_property: :my_value
+
+
+# Custom SSH Options
+# ==================
+# You may pass any option but keep in mind that net/ssh understands a
+# limited set of options, consult[net/ssh documentation](http://net-ssh.github.io/net-ssh/classes/Net/SSH.html#method-c-start).
+#
+# Global options
+# --------------
+#  set :ssh_options, {
+#    keys: %w(/home/rlisowski/.ssh/id_rsa),
+#    forward_agent: false,
+#    auth_methods: %w(password)
+#  }
+#
+# And/or per server (overrides global)
+# ------------------------------------
+# server 'example.com',
+#   user: 'user_name',
+#   roles: %w{web app},
+#   ssh_options: {
+#     user: 'user_name', # overrides user setting above
+#     keys: %w(/home/user_name/.ssh/id_rsa),
+#     forward_agent: false,
+#     auth_methods: %w(publickey password)
+#     # password: 'please use keys'
+#   }
+
+require './config/deploy/staging_deployinator.rb'

data/lib/deployinator/examples/config/deploy/staging_deployinator.rb

@@ -0,0 +1,17 @@
+set :rails_env,                 'production'          # If the environment differs from the stage name
+set :migration_role,            'app'                 # Defaults to 'db'
+#set :conditionally_migrate,     true                  # Defaults to false. If true, it's skip migration if files in db/migrate not modified
+set :assets_roles,              [:app]                # Defaults to [:web]
+#set :assets_prefix,             'prepackaged-assets'  # Defaults to 'assets' this should match config.assets.prefix in your rails config/application.rb
+
+# If you are using nginxinator and postgresinator, your settings would look similar to this:
+set :nginx_container_name,      "my-app-staging.example.com-nginx-80-443"
+set :external_socket_path,      "/my-app-staging.example.com-nginx-80-443-conf/run"
+set :internal_socket_path,      "/var/run/unicorn"
+set :postgres_container_name,   "my-app-staging.example.com-postgres-5432-master"
+set :postgres_port,             "5432"
+set :ruby_image_name,           "snarlysodboxer/ruby:1.9.3-p547"
+set :ruby_container_name,       "my-app-staging.example.com-ruby-bluepill"
+set :ruby_container_max_mem_mb, "1024"
+set :bundler_version,           "1.7.4"
+#set :use_cadvisor,              true                  # this is default

data/lib/deployinator/examples/config/deploy.rb

@@ -0,0 +1,63 @@
+# config valid only for Capistrano 3.1
+lock '3.2.1'
+
+set :application, 'my_app_name'
+set :repo_url, 'git@example.com:me/my_repo.git'
+
+## Don't ask this here, only in staging or other non-production <stage>.rb files.
+# Default branch is :master
+# ask :branch, proc { `git rev-parse --abbrev-ref HEAD`.chomp }.call
+
+# Default deploy_to directory is /var/www/my_app
+# set :deploy_to, '/var/www/my_app'
+
+# Default value for :scm is :git
+# set :scm, :git
+
+# Default value for :format is :pretty
+# set :format, :pretty
+
+# Default value for :log_level is :debug
+# set :log_level, :debug
+
+# Default value for :pty is false
+# set :pty, true
+
+# Default value for :linked_files is []
+# set :linked_files, %w{config/database.yml}
+
+# Default value for linked_dirs is []
+# set :linked_dirs, %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle public/system}
+set :linked_dirs, %w{log tmp}
+
+# Default value for default_env is {}
+# set :default_env, { path: "/opt/ruby/bin:$PATH" }
+
+# Default value for keep_releases is 5
+# set :keep_releases, 5
+
+namespace :deploy do
+
+  ### No need to do anything here, deployinator defines this task.
+  desc 'Restart application'
+  task :restart do
+    on roles(:app), in: :sequence, wait: 5 do
+      # Your restart mechanism here, for example:
+      # execute :touch, release_path.join('tmp/restart.txt')
+    end
+  end
+
+  after :publishing, :restart
+
+  after :restart, :clear_cache do
+    on roles(:web), in: :groups, limit: 3, wait: 10 do
+      # Here we can do anything such as:
+      # within release_path do
+      #   execute :rake, 'cache:clear'
+      # end
+    end
+  end
+
+end
+
+require './config/deploy_deployinator.rb'

data/lib/deployinator/examples/config/deploy_deployinator.rb

@@ -0,0 +1,56 @@
+# Use `cap <stage> deploy from_local=true` to deploy your
+#   locally changed code instead of the code in the git repo. You can also add --trace.
+if ENV['from_local']
+  set :scm, :copy
+else
+  set :scm, :git
+end
+
+# Always use the master branch in production:
+set :current_stage, -> { fetch(:stage).to_s.strip }
+unless fetch(:current_stage) == "production"
+  ask :branch, proc { `git rev-parse --abbrev-ref HEAD`.chomp }.call
+end
+
+## The values in this file are not meant to be changed and shouldn't
+##  need to be under the majority of circumstances:
+
+#set :bundle_roles, :all                                         # this is default
+#set :bundle_servers, -> { release_roles(fetch(:bundle_roles)) } # this is default
+#set :bundle_binstubs, -> { shared_path.join('bin') }            # this is default
+set :bundle_binstubs, -> { shared_path.join('bundle', 'bin') }  # this is required for deployinator
+set :bundle_gemfile, -> { release_path.join('Gemfile') }        # this is required for deployinator
+#set :bundle_path, -> { shared_path.join('bundle') }             # this is default
+#set :bundle_without, %w{development test}.join(' ')             # this is default
+set :bundle_without, %w{development test deployment}.join(' ')
+#set :bundle_flags, '--deployment --quiet'                       # this is default
+#set :bundle_flags, '--deployment'
+#set :bundle_env_variables, {}                                   # this is default
+
+set :docker_run_bluepill_command, -> { [
+  "--tty", "--detach",
+  "--name", fetch(:ruby_container_name),
+  "-e", "GEM_HOME=#{fetch(:deploy_to)}/shared/bundle",
+  "-e", "GEM_PATH=#{fetch(:deploy_to)}/shared/bundle",
+  "-e", "BUNDLE_GEMFILE=#{fetch(:deploy_to)}/current/Gemfile",
+  "-e", "PATH=#{fetch(:deploy_to)}/shared/bundle/bin:$PATH",
+  "--link", "#{fetch(:postgres_container_name)}:postgres",
+  "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+  "--volume", "#{fetch(:external_socket_path)}:#{fetch(:internal_socket_path)}:rw",
+  "--entrypoint", "#{fetch(:deploy_to)}/shared/bundle/bin/bluepill",
+  "--restart", "always", "--memory", "#{fetch(:ruby_container_max_mem_mb)}m",
+  fetch(:ruby_image_name), "load",
+  "#{fetch(:deploy_to)}/current/config/#{fetch(:application)}_bluepill.rb"
+] }
+
+set :docker_run_cadvisor_command, -> { [
+  "--detach",
+  "--name", "cadvisor",
+  "--volume", "/:/rootfs:ro",
+  "--volume", "/var/run:/var/run:rw",
+  "--volume", "/sys:/sys:ro",
+  "--volume", "/var/lib/docker/:/var/lib/docker:ro",
+  "--publish", "127.0.0.1:8080:8080",
+  "--restart", "always",
+  "google/cadvisor:latest"
+] }

data/lib/deployinator/examples/deployer_authorized_keys.erb

@@ -0,0 +1 @@
+# Add your keys here:

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: deployinator
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
+  prerelease: 
 platform: ruby
 authors:
 - david amick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-11 00:00:00.000000000 Z
+date: 2014-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -20,6 +22,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -33,28 +36,38 @@ files:
 - lib/deployinator.rb
 - lib/deployinator/deploy.rb
 - lib/deployinator/config.rb
-homepage: http://rubygems.org/gems/deployinator
+- lib/deployinator/examples/Capfile
+- lib/deployinator/examples/config/deploy.rb
+- lib/deployinator/examples/config/deploy_deployinator.rb
+- lib/deployinator/examples/config/deploy/staging.rb
+- lib/deployinator/examples/config/deploy/staging_deployinator.rb
+- lib/deployinator/examples/Dockerfile
+- lib/deployinator/examples/deployer_authorized_keys.erb
+- lib/deployinator/examples/application_unicorn.rb.erb
+- lib/deployinator/examples/application_bluepill.rb.erb
+homepage: https://github.com/snarlysodboxer/deployinator
 licenses:
-- MIT
-metadata: {}
+- GNU
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 1.8.23.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Deploy Applications
 test_files: []

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 1118ca9720569f14d4453a2d96561b65395362f8
-  data.tar.gz: 1d9079e7d2e1a79ec2a612f2c47a0d14355a017a
-SHA512:
-  metadata.gz: a6fa60095a8adaa33144331cade009a5493def8f046f0d7d49c95bab97c0ecf686fce20c85efca467f67b79372b884ea9017b9e1aeaaab5ffc38b6a2a980457c
-  data.tar.gz: 9b8bf3e88297d083a9ef13de344a5b76455a23cf277a1d07c2a3fc961563eb148fedecd4fd9b0abc9744637fef53d7eca112424d978c51633a73b551e8c4874e