deployinator 0.1.2 → 0.1.3

data/lib/deployinator.rb

@@ -5,3 +5,4 @@ load 'deployinator/deploy.rb'
 load 'deployinator/check.rb'
 load 'deployinator/config.rb'
 load 'deployinator/helpers.rb'
+load 'deployinator/built-in.rb'

data/lib/deployinator/built-in.rb

@@ -0,0 +1,186 @@
+set :deploy_log_level,            "debug"
+set :webserver_socket_path,       -> { shared_path.join('run') }
+set :deploy_templates_path,       "templates/deploy"
+
+# Default deploy_to directory is /var/www/my_app
+# set :deploy_to, '/var/www/my_app'
+
+# Default value for :log_level is :debug
+# set :log_level, :debug
+
+# 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}
+
+# 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
+
+#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 will be overwritten by deployinator
+#set :bundle_gemfile, -> { release_path.join('Gemfile') }        # this will be overwritten by deployinator
+#set :bundle_path, -> { shared_path.join('bundle') }             # this is default
+#set :bundle_without, %w{development test}.join(' ')             # this is default
+#set :bundle_flags, '--deployment --quiet'                       # this is default
+#set :bundle_flags, '--deployment'
+#set :bundle_env_variables, {}                                   # this is default
+set :migration_role,                :db                   # 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
+
+# TODO: fix from_local, right now you have to copy-paste the set_scm method to your deploy.rb
+# 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.
+# You can set include_dir and exclude_dir settings (from capistrano-scm-copy gem).
+#   These will only apply when using the from_local=true option
+# set :include_dir, '../.*'
+# set :exclude_dir, ["../.$", "../..", '.././infrastructure']
+def set_scm
+  if ENV['from_local']
+    if "#{fetch(:stage)}" == "production"
+      run_locally do
+        fatal("You are trying to deploy to production using from_local, " +
+          "this should pretty much never be done.")
+      end
+      ask :yes_no, "Are you positive you want to continue?"
+      case fetch(:yes_no).chomp.downcase
+      when "yes"
+      when "no"
+        exit
+      else
+        warn "Please enter 'yes' or 'no'"
+        set_scm
+      end
+    end
+    set :scm, :copy
+  else
+    set :scm, :git
+  end
+end
+set_scm
+
+def deploy_run_bluepill(host)
+  execute(
+    "docker", "run", "--tty", "--detach",
+    "--name", fetch(:ruby_container_name),
+    "-e", "GEM_HOME=#{shared_path.join('bundle')}",
+    "-e", "GEM_PATH=#{shared_path.join('bundle')}",
+    "-e", "BUNDLE_GEMFILE=#{current_path.join('Gemfile')}",
+    "-e", "PATH=#{shared_path.join('bundle', 'bin')}:$PATH",
+    "--restart", "always", "--memory", "#{fetch(:ruby_container_max_mem_mb)}m",
+    "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+    "--entrypoint", shared_path.join('bundle', 'bin', 'bluepill'),
+    fetch(:ruby_image_name), "load",
+    current_path.join('config', 'bluepill.rb')
+  )
+end
+def deploy_run_cadvisor(host)
+  execute(
+    "docker", "run", "--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"
+  )
+end
+def deploy_rails_console(host)
+  [
+    "ssh", "-t", "#{host}", "\"docker", "exec", "--interactive", "--tty",
+    fetch(:ruby_container_name),
+    "bash", "-c", "'cd", current_path, "&&",
+    shared_path.join('bundle', 'bin', 'rails'),
+    "console", "#{fetch(:rails_env)}'\""
+  ].join(' ')
+end
+def deploy_rails_console_print(host)
+  [
+    "docker", "exec", "--interactive", "--tty",
+    fetch(:ruby_container_name),
+    "bash", "-c", "\"cd", current_path, "&&",
+    shared_path.join('bundle', 'bin', 'rails'),
+    "console", "#{fetch(:rails_env)}\""
+  ].join(' ')
+end
+def sshkit_bundle_command_map
+  [
+    "/usr/bin/env docker run --rm --tty",
+    "--user", fetch(:deployment_username),
+    "-e", "GEM_HOME=#{shared_path.join('bundle')}",
+    "-e", "GEM_PATH=#{shared_path.join('bundle')}",
+    "-e", "PATH=#{shared_path.join('bundle', 'bin')}:$PATH",
+    "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+    "--volume", "$SSH_AUTH_SOCK:/ssh-agent --env SSH_AUTH_SOCK=/ssh-agent",
+    "--volume", "/home:/home:rw",
+    "--volume", "/etc/passwd:/etc/passwd:ro",
+    "--volume", "/etc/group:/etc/group:ro",
+    "--entrypoint", "#{shared_path.join('bundle', 'bin', 'bundle')}",
+    fetch(:ruby_image_name)
+  ].join(' ')
+end
+def deploy_assets_precompile(host)
+  execute("docker", "run", "--rm", "--tty", "--user", fetch(:webserver_username),
+    "-w", release_path,
+    "--volume", "/home:/home:rw",
+    "--volume", "/etc/passwd:/etc/passwd:ro",
+    "--volume", "/etc/group:/etc/group:ro",
+    "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+    "--entrypoint", "/bin/bash",
+    fetch(:ruby_image_name), "-c",
+    "\"umask", "0007", "&&", "#{shared_path.join('bundle', 'bin', 'rake')}",
+    "assets:precompile\"")
+end
+def deploy_assets_cleanup(host)
+  execute("docker", "run", "--rm", "--tty",
+    "-e", "RAILS_ENV=#{fetch(:rails_env)}",
+    "-w", release_path,
+    "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+    "--entrypoint", shared_path.join('bundle', 'bin', 'bundle'),
+    fetch(:ruby_image_name), "exec", "rake", "assets:clean")
+end
+def deploy_rake_db_migrate(host)
+  execute("docker", "run", "--rm", "--tty",
+    "-w", release_path,
+    "-e", "RAILS_ENV=#{fetch(:rails_env)}",
+    "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+    "--entrypoint", shared_path.join('bundle', 'bin', 'rake'),
+    fetch(:ruby_image_name), "db:migrate")
+end
+def deploy_install_bundler(host)
+  execute("docker", "run", "--rm", "--tty", "--user", fetch(:deployment_username),
+    "-e", "GEM_HOME=#{shared_path.join('bundle')}",
+    "-e", "GEM_PATH=#{shared_path.join('bundle')}",
+    "-e", "PATH=#{shared_path.join('bundle', 'bin')}:$PATH",
+    "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
+    "--volume", "/home:/home:rw",
+    "--volume", "/etc/passwd:/etc/passwd:ro",
+    "--volume", "/etc/group:/etc/group:ro",
+    "--entrypoint", "/bin/bash",
+    fetch(:ruby_image_name), "-c",
+    "\"umask", "0007", "&&" "/usr/local/bin/gem", "install",
+    "--install-dir", "#{shared_path.join('bundle')}",
+    "--bindir", shared_path.join('bundle', 'bin'),
+    "--no-ri", "--no-rdoc", "--quiet", "bundler", "-v'#{fetch(:bundler_version)}'\"")
+end
+def deploy_bluepill_restart(host)
+  execute("docker", "exec", "--tty",
+    fetch(:ruby_container_name),
+    shared_path.join('bundle', 'bin', 'bluepill'),
+    fetch(:application), "restart")
+end
+def deploy_bluepill_stop(host)
+  execute("docker", "exec", "--tty",
+    fetch(:ruby_container_name),
+    shared_path.join('bundle', 'bin', 'bluepill'),
+    fetch(:application), "stop")
+end

data/lib/deployinator/check.rb

@@ -4,20 +4,7 @@ namespace :deploy do
     task :bundle_command_map => ['deployinator:deployment_user'] do
       set :bundle_binstubs, -> { shared_path.join('bundle', 'bin') }
       set :bundle_gemfile,  -> { release_path.join('Gemfile') }
-      SSHKit.config.command_map[:bundle] = [
-        "/usr/bin/env docker run --rm --tty",
-        "--user", fetch(:deployment_user_id),
-        "-e", "GEM_HOME=#{shared_path.join('bundle')}",
-        "-e", "GEM_PATH=#{shared_path.join('bundle')}",
-        "-e", "PATH=#{shared_path.join('bundle', 'bin')}:$PATH",
-        "--entrypoint", "#{shared_path.join('bundle', 'bin', 'bundle')}",
-        "--volume $SSH_AUTH_SOCK:/ssh-agent --env SSH_AUTH_SOCK=/ssh-agent",
-        "--volume #{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
-        "--volume /etc/passwd:/etc/passwd:ro",
-        "--volume /etc/group:/etc/group:ro",
-        "--volume /home:/home:rw",
-        fetch(:ruby_image_name)
-      ].join(' ')
+      SSHKit.config.command_map[:bundle] = sshkit_bundle_command_map
     end
     before 'bundler:install', 'deploy:check:bundle_command_map'
 
@@ -26,6 +13,14 @@ namespace :deploy do
       SSHKit.config.command_map[:rm] = "/usr/bin/env sudo rm"
     end
 
+    before 'deploy:check', :brakeman_reminder do
+      run_locally do
+        warn "Remember to run brakeman before deploying!"
+        ask :return_to_continue, nil
+        set :nothing, fetch(:return_to_continue)
+      end
+    end
+
     if Rake::Task.task_defined?("deploy:cleanup")
       # Append dependancy to existing cleanup task
       task 'deploy:cleanup' => 'deploy:check:rm_command_map'
@@ -45,13 +40,13 @@ namespace :deploy do
     # TODO make this better
     before 'deploy:check', :templates do
       run_locally do
-        keys_template     = File.expand_path("./templates/deploy/deployment_authorized_keys.erb")
-        bluepill_template = File.expand_path("./templates/deploy/bluepill.rb.erb")
-        unicorn_template  = File.expand_path("./templates/deploy/unicorn.rb.erb")
+        keys_template     = File.expand_path("./#{fetch(:deploy_templates_path)}/deployment_authorized_keys.erb")
+        bluepill_template = File.expand_path("./#{fetch(:deploy_templates_path)}/bluepill.rb.erb")
+        unicorn_template  = File.expand_path("./#{fetch(:deploy_templates_path)}/unicorn.rb.erb")
         {
-          "You need a templates/deploy/deployment_authorized_keys.erb file."          => keys_template,
-          "You need a templates/deploy/bluepill.rb.erb file."  => bluepill_template,
-          "You need a templates/deploy/unicorn.rb.erb file."   => unicorn_template,
+          "You need a #{fetch(:deploy_templates_path)}/deployment_authorized_keys.erb file."          => keys_template,
+          "You need a #{fetch(:deploy_templates_path)}/bluepill.rb.erb file."  => bluepill_template,
+          "You need a #{fetch(:deploy_templates_path)}/unicorn.rb.erb file."   => unicorn_template,
         }.each do |message, file|
           fatal(message) and raise unless File.exists? file
         end
@@ -64,9 +59,9 @@ namespace :deploy do
     task :root_dir_permissions => ['deployinator:deployment_user', 'deployinator:webserver_user'] do
       on roles(:app) do
         as :root do
-          [fetch(:deploy_to), Pathname.new(fetch(:deploy_to)).join("../")].each do |dir|
+          [fetch(:deploy_to), Pathname.new(fetch(:deploy_to)).join("../"), shared_path].each do |dir|
             if directory_exists?(dir)
-              execute "chown", "#{fetch(:deployment_user_id)}:#{fetch(:webserver_user_id)}", dir
+              execute "chown", "#{fetch(:deployment_username)}:#{fetch(:webserver_username)}", dir
               execute "chmod", "2750", dir
             end
           end
@@ -75,53 +70,29 @@ namespace :deploy do
     end
     before 'deploy:check:directories', 'deploy:check:root_dir_permissions'
 
-    before 'deploy:check', :webserver_running do
-      on roles(:app) do
-        if container_exists?(fetch(:webserver_container_name))
-          unless container_is_running?(fetch(:webserver_container_name))
-            warn "The webserver container named #{fetch(:webserver_container_name)} exists but is not running. You can still deploy your code, but you need this, start it, or re-run setup with something like nginxinator."
-            ask :return_to_continue, nil
-            set :nothing, fetch(:return_to_continue)
-          end
-        else
-          warn "No webserver container named #{fetch(:webserver_container_name)} exists! You can still deploy your code, but you need this, set it up with something like nginxinator."
-          ask :return_to_continue, nil
-          set :nothing, fetch(:return_to_continue)
-        end
-      end
-    end
-
     before 'deploy:check', :postgres_running do
-      on primary fetch(:migration_role) do
-        if container_exists?(fetch(:postgres_container_name))
-          if container_is_running?(fetch(:postgres_container_name))
-            unless localhost_port_responding?(fetch(:postgres_port))
-              fatal "Port #{fetch(:postgres_port)} is not responding, we won't be able to db:migrate!"
-              raise
-            end
-          else
-            fatal "#{fetch(:postgres_container_name)} exists but is not running, we won't be able to db:migrate!"
-            raise
-          end
-        else
-          fatal "#{fetch(:postgres_container_name)} does not exist, we won't be able to db:migrate!"
+      on roles(:app) do
+        unless localhost_port_responding?(fetch(:postgres_port))
+          fatal "Port #{fetch(:postgres_port)} is not responding, we won't be able to db:migrate!"
           raise
         end
       end
     end
 
     before 'deploy:check', :ensure_cadvisor do
-      on roles(:app), in: :sequence, wait: 5 do
+      on roles(:app) do |host|
         if fetch(:use_cadvisor, true)
           if container_exists?("cadvisor")
             if container_is_running?("cadvisor")
               info "cadvisor is already running."
             else
-              info "Restarting existing cadvisor container."
-              execute "docker", "start", "cadvisor"
+              info "Starting existing cadvisor container."
+              start_container("cadvisor")
             end
           else
-            execute("docker", "run", fetch(:docker_run_cadvisor_command))
+            warn "Starting a new container named 'cadvisor' on #{host}"
+            deploy_run_cadvisor(host)
+            check_stayed_running("cadvisor")
           end
         else
           info "Not using cadvisor."

data/lib/deployinator/config.rb

@@ -1,24 +1,109 @@
+module Capistrano
+  module TaskEnhancements
+    alias_method :deploy_original_default_tasks, :default_tasks
+    def default_tasks
+      deploy_original_default_tasks + [
+        "deployinator:write_built_in",
+        "deployinator:write_example_configs",
+        "deployinator:write_example_configs:in_place"
+      ]
+    end
+  end
+end
+
 namespace :deployinator do
 
+  set :example, "_example"
+
   desc 'Write example config files'
   task :write_example_configs do
     run_locally do
-      execute "mkdir", "-p", "config/deploy", "templates/deploy"
+      execute "mkdir", "-p", "config/deploy", fetch(:deploy_templates_path, 'templates/deploy')
       {
-        "examples/Capfile"                        => "Capfile_example",
-        "examples/config/deploy.rb"               => "config/deploy_example.rb",
-        "examples/config/deploy/staging.rb"       => "config/deploy/staging_example.rb",
-        "examples/Dockerfile"                     => "templates/deploy/Dockerfile_example",
-        "examples/deployment_authorized_keys.erb" => "templates/deploy/deployment_authorized_keys_example.erb",
-        "examples/unicorn.rb.erb"                 => "templates/deploy/unicorn_example.rb.erb",
-        "examples/bluepill.rb.erb"                => "templates/deploy/bluepill_example.rb.erb"
+        "examples/Capfile"                        => "Capfile#{fetch(:example)}",
+        "examples/config/deploy.rb"               => "config/deploy#{fetch(:example)}.rb",
+        "examples/config/deploy/staging.rb"       => "config/deploy/staging#{fetch(:example)}.rb",
+        "examples/Dockerfile"                     => "#{fetch(:deploy_templates_path, 'templates/deploy')}/Dockerfile#{fetch(:example)}",
+        "examples/deployment_authorized_keys.erb" => "#{fetch(:deploy_templates_path, 'templates/deploy')}/deployment_authorized_keys#{fetch(:example)}.erb",
+        "examples/unicorn.rb.erb"                 => "#{fetch(:deploy_templates_path, 'templates/deploy')}/unicorn#{fetch(:example)}.rb.erb",
+        "examples/bluepill.rb.erb"                => "#{fetch(:deploy_templates_path, 'templates/deploy')}/bluepill#{fetch(: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."
+      unless fetch(:example).empty?
+        info "Now remove the '#{fetch(:example)}' portion of their names or diff with existing files and add the needed lines."
+      end
+    end
+  end
+
+  desc 'Write example config files (will overwrite any existing config files).'
+  namespace :write_example_configs do
+    task :in_place do
+      set :example, ""
+      Rake::Task['deployinator:write_example_configs'].invoke
+    end
+  end
+
+  desc 'Write a file showing the built-in overridable settings.'
+  task :write_built_in do
+    run_locally do
+      {
+        'built-in.rb'                         => 'built-in.rb',
+      }.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 examine the file and copy-paste into your deploy.rb or <stage>.rb and customize."
+    end
+  end
+
+  # These are the only two tasks using :preexisting_ssh_user
+  namespace :deployment_user do
+    #desc "Setup or re-setup the deployment user, idempotently"
+    task :setup do
+      on roles(:all) do |h|
+        on "#{fetch(:preexisting_ssh_user)}@#{h}" do |host|
+          as :root do
+            deployment_user_setup(fetch(:deploy_templates_path, 'templates/deploy'))
+          end
+        end
+      end
+    end
+  end
+
+  task :deployment_user do
+    on roles(:all) do |h|
+      on "#{fetch(:preexisting_ssh_user)}@#{h}" do |host|
+        as :root do
+          if unix_user_exists?(fetch(:deployment_username))
+            info "User #{fetch(:deployment_username)} already exists. You can safely re-setup the user with 'deployinator:deployment_user:setup'."
+          else
+            Rake::Task['deployinator:deployment_user:setup'].invoke
+          end
+        end
+      end
+    end
+  end
+
+  task :webserver_user do
+    on roles(:app) do
+      as :root do
+        unix_user_add(fetch(:webserver_username)) unless unix_user_exists?(fetch(:webserver_username))
+      end
+    end
+  end
+
+  task :file_permissions => [:deployment_user, :webserver_user] do
+    on roles(:app) do
+      as :root do
+        setup_file_permissions
+      end
     end
   end
+  after   'deploy:check',   'deployinator:file_permissions'
+  before  'deploy:restart', 'deployinator:file_permissions'
 
 end

data/lib/deployinator/deploy.rb

@@ -3,6 +3,22 @@ lock '3.2.1'
 
 namespace :deploy do
 
+  before :starting, :log_level do
+    SSHKit.config.output_verbosity = fetch(:deploy_log_level)
+  end
+
+  before :starting, 'deployinator:sshkit_umask'
+
+  # Default branch is :master
+  before :starting, :set_branch do
+    unless ENV['from_local']
+      # Always use the master branch in production:
+      unless "#{fetch(:stage)}" == "production"
+        ask :branch, proc { `git rev-parse --abbrev-ref HEAD`.chomp }.call
+      end
+    end
+  end
+
   #desc 'Copies .git folder to support .gemspecs that run git commands'
   task :copy_git do
     unless ENV['from_local'] == "true"
@@ -17,22 +33,11 @@ namespace :deploy do
 
   if Rake::Task.task_defined?("deploy:assets:precompile")
     # Overwrite :assets:precompile to use docker
-    Rake::Task["deploy:assets:precompile"].clear
+    Rake::Task["deploy:assets:precompile"].clear_actions
     namespace :assets do
       task :precompile => ['deployinator:deployment_user'] do
-        on roles(fetch(:assets_roles)) do
-          execute(
-            "docker", "run", "--rm", "--tty", "--user", fetch(:webserver_username),
-            "-w", release_path,
-            "--link", "#{fetch(:postgres_container_name)}:postgres",
-            "--entrypoint", "/bin/bash",
-            "--volume", "/etc/passwd:/etc/passwd:ro",
-            "--volume", "/etc/group:/etc/group:ro",
-            "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
-            fetch(:ruby_image_name), "-c",
-            "\"umask", "0007", "&&", "#{shared_path.join('bundle', 'bin', 'rake')}",
-            "assets:precompile\""
-          )
+        on roles(fetch(:assets_roles)) do |host|
+          deploy_assets_precompile(host)
         end
       end
     end
@@ -40,64 +45,37 @@ namespace :deploy do
 
   if Rake::Task.task_defined?("deploy:cleanup_assets")
     # Overwrite :cleanup_assets to use docker
-    Rake::Task["deploy:cleanup_assets"].clear
+    Rake::Task["deploy:cleanup_assets"].clear_actions
     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", release_path,
-          "--entrypoint", shared_path.join('bundle', 'bin', 'bundle'),
-          "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
-          fetch(:ruby_image_name), "exec", "rake", "assets:clean"
-        )
+      on roles(fetch(:assets_roles)) do |host|
+        deploy_assets_cleanup(host)
       end
     end
   end
 
   if Rake::Task.task_defined?("deploy:migrate")
     # Overwrite :migrate to use docker
-    Rake::Task["deploy:migrate"].clear
+    Rake::Task["deploy:migrate"].clear_actions
     desc 'Runs rake db:migrate if migrations are set'
     task :migrate => [:set_rails_env, 'deploy:check:postgres_running'] do
-      on primary fetch(:migration_role) do
+      on primary fetch(:migration_role) do |host|
         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", shared_path.join('bundle', 'bin', 'rake'),
-            "-w", release_path,
-            fetch(:ruby_image_name), "db:migrate"
-          )
+          deploy_rake_db_migrate(host)
         end
       end
     end
   end
 
   task :install_bundler => ['deployinator:deployment_user'] do
-    on roles(:app), in: :sequence, wait: 5 do
+    on roles(:app) do |host|
       unless file_exists?(shared_path.join('bundle', 'bin', 'bundle'))
-        execute(
-          "docker", "run", "--rm", "--tty", "--user", fetch(:deployment_user_id),
-          "-e", "GEM_HOME=#{shared_path.join('bundle')}",
-          "-e", "GEM_PATH=#{shared_path.join('bundle')}",
-          "-e", "PATH=#{shared_path.join('bundle', 'bin')}:$PATH",
-          "--entrypoint", "/bin/bash",
-          "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
-          fetch(:ruby_image_name), "-c",
-          "\"umask", "0007", "&&" "/usr/local/bin/gem", "install",
-          "--install-dir", "#{shared_path.join('bundle')}",
-          "--bindir", shared_path.join('bundle', 'bin'),
-          "--no-ri", "--no-rdoc", "--quiet", "bundler", "-v'#{fetch(:bundler_version)}'\""
-        )
+        deploy_install_bundler(host)
       end
     end
   end
@@ -105,26 +83,24 @@ namespace :deploy do
 
   desc 'Restart application using bluepill restart inside the docker container.'
   task :restart => ['deployinator:webserver_user', :install_config_files] do
-    on roles(:app), in: :sequence, wait: 5 do
-      if container_exists?(fetch(:ruby_container_name))
-        if container_is_restarting?(fetch(:ruby_container_name))
-          execute("docker", "stop", fetch(:ruby_container_name))
+    on roles(:app) do |host|
+      name = fetch(:ruby_container_name)
+      if container_exists?(name)
+        if container_is_restarting?(name)
+          execute("docker", "stop", name)
         end
-        if container_is_running?(fetch(:ruby_container_name))
-          execute(
-            "docker", "exec", "--tty",
-            fetch(:ruby_container_name),
-            shared_path.join('bundle', 'bin', 'bluepill'),
-            fetch(:application), "restart"
-          )
+        if container_is_running?(name)
+          deploy_bluepill_restart(host)
         else
-          execute("docker", "start", fetch(:ruby_container_name))
+          execute("docker", "start", name)
         end
       else
         as :root do
           execute("rm", "-f", fetch(:webserver_socket_path).join('unicorn.pid'))
         end
-        execute("docker", "run", fetch(:docker_run_bluepill_command))
+        warn "Starting a new container named #{name} on #{host}"
+        deploy_run_bluepill(host)
+        check_stayed_running(name)
       end
     end
   end
@@ -133,15 +109,10 @@ namespace :deploy do
   desc 'Restart application by recreating the docker container.'
   namespace :restart do
     task :force do
-      on roles(:app), in: :sequence, wait: 5 do
+      on roles(:app) do |host|
         if container_exists?(fetch(:ruby_container_name))
           if container_is_running?(fetch(:ruby_container_name))
-            execute(
-              "docker", "exec", "--tty",
-              fetch(:ruby_container_name),
-              shared_path.join('bundle', 'bin', 'bluepill'),
-              fetch(:application), "stop"
-            )
+            deploy_bluepill_stop(host)
             sleep 5
             execute("docker", "stop", fetch(:ruby_container_name))
             execute("docker", "wait", fetch(:ruby_container_name))
@@ -173,33 +144,37 @@ namespace :deploy do
 #  end
 
   task :install_config_files => ['deployinator:deployment_user', 'deployinator:webserver_user'] do
-    on roles(:app), in: :sequence, wait: 5 do
+    on roles(:app) do |host|
       set :bluepill_config, -> { "bluepill.rb" }
       set :unicorn_config,  -> { "unicorn.rb" }
       set :socket_path,     -> { fetch(:webserver_socket_path) }
       [fetch(:bluepill_config), fetch(:unicorn_config)].each do |config_file|
-        template_path = File.expand_path("./templates/deploy/#{config_file}.erb")
+        template_path = File.expand_path("./#{fetch(:deploy_templates_path)}/#{config_file}.erb")
         generated_config_file = ERB.new(File.new(template_path).read).result(binding)
         set :final_path, -> { release_path.join('config', config_file) }
         upload! StringIO.new(generated_config_file), "/tmp/#{config_file}"
         execute("mv", "/tmp/#{config_file}", fetch(:final_path))
         as :root do
-          execute("chown", "#{fetch(:deployment_user_id)}:#{fetch(:webserver_user_id)}", fetch(:final_path))
+          execute("chown", "#{fetch(:deployment_username)}:#{fetch(:webserver_username)}", fetch(:final_path))
         end
       end
     end
   end
 
-  task :print_rails_console do
-    run_locally do
-      command = [
-        "docker", "exec", "--interactive", "--tty",
-        fetch(:ruby_container_name),
-        "bash", "-c", "\"cd", current_path, "&&",
-        shared_path.join('bundle', 'bin', 'rails'),
-        "console", "#{fetch(:rails_env)}\""
-      ].join(' ')
-      info command
+  desc "Enter the Rails console."
+  task :rails_console do
+    on roles(:app) do |host|
+      info "Entering Rails Console inside #{fetch(:ruby_container_name)} on #{host}"
+      system deploy_rails_console(host)
+    end
+  end
+
+  namespace :rails_console do
+    task :print do
+      on roles(:app) do |host|
+        info "You can SSH into #{host} and run the following command to enter the Rails Console."
+        info deploy_rails_console_print(host)
+      end
     end
   end
 

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

@@ -1,99 +1,21 @@
-# config valid only for Capistrano 3.1
+# config valid only for Capistrano 3.2.1
 lock '3.2.1'
 
-set :application,                 'my_app_name'
-set :repo_url,                    'git@example.com:me/my_repo.git'
-set :preexisting_ssh_user,        ENV['USER']
-set :deployment_username,         "deployer" # user with SSH access and passwordless sudo rights
-set :webserver_username,          "www-data" # less trusted web server user with limited write permissions
-
-set :webserver_owned_dirs,        [shared_path.join('tmp', 'cache'), shared_path.join('public', 'assets')]
-set :webserver_writeable_dirs,    [shared_path.join('run'), shared_path.join("tmp"), shared_path.join("log")]
-set :webserver_executable_dirs,   [shared_path.join("bundle", "bin")]
-set :ignore_permissions_dirs,     [shared_path.join("postgres"), shared_path.join("nginx")]
-set :webserver_socket_path,       shared_path.join('run')
-
-# Default branch is :master
-# 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
-
-# Default deploy_to directory is /var/www/my_app
-# set :deploy_to, '/var/www/my_app'
-
-# Default value for :log_level is :debug
-# set :log_level, :debug
-
-# Default value for :linked_files is []
-# set :linked_files, %w{config/database.yml}
+##### deployinator
+### ------------------------------------------------------------------
+set :repo_url,                      'git@example.com:me/my_repo.git'
+set :application,                   'my_app_name'
+set :preexisting_ssh_user,          ENV['USER']
+set :deployment_username,           "deployer" # user with SSH access and passwordless sudo rights
+set :webserver_username,            "www-data" # less trusted web server user with limited write permissions
+set :webserver_owned_dirs,          [shared_path.join('tmp', 'cache'), shared_path.join('public', 'assets')]
+set :webserver_writeable_dirs,      [shared_path.join('run'), shared_path.join("tmp"), shared_path.join("log")]
+set :webserver_executable_dirs,     [shared_path.join("bundle", "bin")]
+set :ignore_permissions_dirs,       [shared_path.join("postgres"), shared_path.join("nginx")]
 
 # Default value for linked_dirs is []
 # set :linked_dirs, %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle public/system}
 
-# 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
-
-
-#----------------------------------------------------
-## The values below shouldn't need changed under the majority of circumstances.
-
-# 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']
-  if fetch(:current_stage) == "production"
-    run_locally do
-      fatal "You are trying to deploy to production using from_local, this should pretty much never be done."
-    end
-    ask :yes_no, "Are you positive you want to continue?"
-    if fetch(:yes_no).chomp.downcase == "yes"
-      set :scm, :copy
-    else
-      exit
-    end
-  end
-else
-  set :scm, :git
-end
-
-#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 will be overwritten by deployinator
-#set :bundle_gemfile, -> { release_path.join('Gemfile') }        # this will be overwritten by deployinator
-#set :bundle_path, -> { shared_path.join('bundle') }             # this is default
-#set :bundle_without, %w{development test}.join(' ')             # this is default
-#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=#{shared_path.join('bundle')}",
-  "-e", "GEM_PATH=#{shared_path.join('bundle')}",
-  "-e", "BUNDLE_GEMFILE=#{current_path.join('Gemfile')}",
-  "-e", "PATH=#{shared_path.join('bundle', 'bin')}:$PATH",
-  "--link", "#{fetch(:postgres_container_name)}:postgres",
-  "--volume", "#{fetch(:deploy_to)}:#{fetch(:deploy_to)}:rw",
-  "--entrypoint", shared_path.join('bundle', 'bin', 'bluepill'),
-  "--restart", "always", "--memory", "#{fetch(:ruby_container_max_mem_mb)}m",
-  fetch(:ruby_image_name), "load",
-  current_path.join('config', '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"
-] }
+set :bundler_version,               "1.7.4"
+set :use_cadvisor,                  true
+### ------------------------------------------------------------------

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

@@ -1,21 +1,12 @@
-set  :domain,                   "my-app-staging.example.com"
-set  :user_host,                "#{fetch(:deployment_username)}@#{fetch(:domain)}"
-
-role :app,                      fetch(:user_host)
-role :web,                      fetch(:user_host)
-role :db,                       fetch(:user_host)
-
-set :rails_env,                 'production'
-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
-
-set :webserver_container_name,  "my-app-staging.example.com-nginx-80-443"
-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,       "#{fetch(:domain)}-ruby-bluepill"
-set :ruby_container_max_mem_mb, "1024"
-set :bundler_version,           "1.7.4"
-set :use_cadvisor,              true
+##### deployinator
+### ------------------------------------------------------------------
+set  :domain,                       "my-app-staging.example.com"
+server fetch(:domain),
+  :user                             => fetch(:deployment_username),
+  :roles                            => ["app", "web", "db"]
+set :rails_env,                     'production'
+set :ruby_image_name,               "snarlysodboxer/ruby:1.9.3-p547"
+set :ruby_container_name,           "#{fetch(:domain)}-ruby-bluepill"
+set :ruby_container_max_mem_mb,     "1024"
+set :postgres_port,                 "5432"
+### ------------------------------------------------------------------

data/lib/deployinator/helpers.rb

@@ -1,141 +1,95 @@
 namespace :deployinator do
 
-  # These are the only two tasks using :preexisting_ssh_user
-  namespace :deployment_user do
-    #desc "Setup or re-setup the deployment user, idempotently"
-    task :setup do
-      on "#{fetch(:preexisting_ssh_user)}@#{fetch(:domain)}" do
-        as :root do
-          unix_user_add(fetch(:deployment_username)) unless unix_user_exists?(fetch(:deployment_username))
-          execute "usermod", "-a", "-G", "sudo,docker,#{fetch(:webserver_username)}", fetch(:deployment_username)
-          execute "mkdir", "-p", "/home/#{fetch(:deployment_username)}/.ssh"
-          template_path = File.expand_path("./templates/deploy/deployment_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(:deployment_username)}/.ssh/authorized_keys"
-          execute "chown", "-R", "#{fetch(:deployment_username)}:#{fetch(:deployment_username)}", "/home/#{fetch(:deployment_username)}/.ssh"
-          execute "chmod", "700", "/home/#{fetch(:deployment_username)}/.ssh"
-          execute "chmod", "600", "/home/#{fetch(:deployment_username)}/.ssh/authorized_keys"
-        end
-      end
-    end
-  end
-
-  task :deployment_user do
-    on "#{fetch(:preexisting_ssh_user)}@#{fetch(:domain)}" do
-      as :root do
-        if unix_user_exists?(fetch(:deployment_username))
-          info "User #{fetch(:deployment_username)} already exists. You can safely re-setup the user with 'deployinator:deployment_user:setup'."
-        else
-          Rake::Task['deployinator:deployment_user:setup'].invoke
-        end
-        set :deployment_user_id, unix_user_get_id(fetch(:deployment_username))
-      end
-    end
-  end
-
-  task :webserver_user do
-    on roles(:app) do
-      as :root do
-        unix_user_add(fetch(:webserver_username)) unless unix_user_exists?(fetch(:webserver_username))
-        set :webserver_user_id, unix_user_get_id(fetch(:webserver_username))
-      end
-    end
-  end
-
   task :sshkit_umask do
     SSHKit.config.umask = "0027"
   end
-  if Rake::Task.task_defined?('deploy:started')
-    before 'deploy:started', 'deployinator:sshkit_umask'
-  end
-
-  task :file_permissions => [:deployment_user, :webserver_user] do
-    on roles(:app) do
-      as :root do
-        ignore_options = fetch(:ignore_permissions_dirs).collect do |dir|
-          ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
-        end
-
-        chown_ignore_options = fetch(:webserver_owned_dirs).collect do |dir|
-          ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
-        end
-
-        # chown webserver owned
-        fetch(:webserver_owned_dirs).each do |dir|
-          if directory_exists?(dir)
-            execute "find", dir, ignore_options,
-              "-exec", "chown", "#{fetch(:webserver_user_id)}:#{fetch(:webserver_user_id)}", "{}", "+"
-          end
-        end
-
-        # chown
-        execute "find", fetch(:deploy_to), ignore_options, chown_ignore_options,
-          "-exec", "chown", "#{fetch(:deployment_user_id)}:#{fetch(:webserver_user_id)}", "{}", "+"
-
-        # chmod executable
-        fetch(:webserver_executable_dirs).each do |dir|
-          if directory_exists?(dir)
-            execute "find", dir, "-type", "f",
-              "-exec", "chmod", "0750", "{}", "+"
-          end
-          ignore_options += ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
-        end
-
-        # chmod writable
-        fetch(:webserver_writeable_dirs).each do |dir|
-          if directory_exists?(dir)
-            execute "find", "-L", dir, "-type", "d",
-              "-exec", "chmod", "2770", "{}", "+"
-            execute "find", "-L", dir, "-type", "f",
-              "-exec", "chmod", "0660", "{}", "+"
-          end
-          ignore_options += ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
-        end
-
-        # chmod
-        execute "find", fetch(:deploy_to), "-type", "d", ignore_options,
-          "-exec", "chmod", "2750", "{}", "+"
-        execute "find", fetch(:deploy_to), "-type", "f", ignore_options,
-          "-exec", "chmod", "0640", "{}", "+"
-      end
-    end
-  end
-  after   'deploy:check',   'deployinator:file_permissions'
-  before  'deploy:restart', 'deployinator:file_permissions'
-
 
   task :settings, [:absolute_path, :relative_path] do |t, args|
     run_locally do
+      if fetch(:print_all)
+        lines = "\nThe following settings are needed in your config (#{args.relative_path}).\n"
+        lines += File.read(args.absolute_path)
+        info lines
+        break
+      end
+
       need_moar_settings = false
       settings = File.read(args.absolute_path).split("\nset").collect do |line|
         "set#{line}" if line =~ /^ :/
       end.compact
-      if fetch(:print_all, false)
-        lines = "\nThe following settings are needed in your config (#{args.relative_path}).\n"
-      else
-        lines = "\nAdd the following setting(s) to your config (#{args.relative_path}) and try again:\n"
-      end
+      lines = "\nAdd the following setting(s) to your config (#{args.relative_path}) and try again:\n"
       settings.each do |setting|
-        if fetch(setting.split(',')[0].split(':')[1].to_sym).nil? or fetch(:print_all, false)
+        if fetch(setting.split(',')[0].split(':')[1].to_sym).nil?
           lines += setting.chomp == setting ? "#{setting}\n" : setting
           need_moar_settings = true
         end
       end
-      if need_moar_settings
-        if fetch(:print_all, false)
-          info lines
-        else
-          fatal lines if lines.lines.count > 2
-          exit
-        end
-      end
+      fatal(lines) if(lines.lines.count > 2) if(need_moar_settings)
+      exit if need_moar_settings
     end
   end
 
 end
 
+
+def deployment_user_setup(templates_path)
+  require 'erb' unless defined?(ERB)
+  name = fetch(:deployment_username)
+  unix_user_add(name) unless unix_user_exists?(name)
+  execute "usermod", "-a", "-G", "sudo,docker,#{fetch(:webserver_username)}", name
+  execute "mkdir", "-p", "/home/#{name}/.ssh"
+  template_path = File.expand_path("./#{templates_path}/deployment_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/#{name}/.ssh/authorized_keys"
+  execute "chown", "-R", "#{name}:#{name}", "/home/#{name}"
+  execute "chmod", "700", "/home/#{name}/.ssh"
+  execute "chmod", "600", "/home/#{name}/.ssh/authorized_keys"
+end
+
+def setup_file_permissions
+  ignore_options = fetch(:ignore_permissions_dirs).collect do |dir|
+    ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
+  end
+  chown_ignore_options = fetch(:webserver_owned_dirs).collect do |dir|
+    ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
+  end
+  # chown webserver owned
+  fetch(:webserver_owned_dirs).each do |dir|
+    if directory_exists?(dir)
+      execute "find", dir, ignore_options,
+        "-exec", "chown", "#{fetch(:webserver_username)}:#{fetch(:webserver_username)}", "{}", "+"
+    end
+  end
+  # chown
+  execute "find", fetch(:deploy_to), ignore_options, chown_ignore_options,
+    "-exec", "chown", "#{fetch(:deployment_username)}:#{fetch(:webserver_username)}", "{}", "+"
+  # chmod executable
+  fetch(:webserver_executable_dirs).each do |dir|
+    if directory_exists?(dir)
+      execute "find", dir, "-type", "f",
+        "-exec", "chmod", "0750", "{}", "+"
+    end
+    ignore_options += ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
+  end
+  # chmod writable
+  fetch(:webserver_writeable_dirs).each do |dir|
+    if directory_exists?(dir)
+      execute "find", "-L", dir, "-type", "d",
+        "-exec", "chmod", "2770", "{}", "+"
+      execute "find", "-L", dir, "-type", "f",
+        "-exec", "chmod", "0660", "{}", "+"
+    end
+    ignore_options += ["-not", "-path", "\"#{dir}\"", "-not", "-path", "\"#{dir}/*\""]
+  end
+  # chmod
+  execute "find", fetch(:deploy_to), "-type", "d", ignore_options,
+    "-exec", "chmod", "2750", "{}", "+"
+  execute "find", fetch(:deploy_to), "-type", "f", ignore_options,
+    "-exec", "chmod", "0640", "{}", "+"
+end
+
 def container_exists?(container_name)
   test "bash", "-c", "\"docker", "inspect", container_name, "&>", "/dev/null\""
 end
@@ -150,6 +104,30 @@ def container_is_restarting?(container_name)
     container_name, "2>&1`\"", "=", "\"true\"", "]"
 end
 
+def check_stayed_running(name)
+  sleep 3
+  unless container_is_running?(name)
+    fatal "Container #{name} on #{fetch(:domain)} did not stay running more than 3 seconds"
+    exit
+  end
+  if container_is_restarting?(name)
+    fatal "Container #{name} on #{fetch(:domain)} is stuck restarting itself."
+    exit
+  end
+end
+
+def start_container(name)
+  warn "Starting an existing but non-running container named #{name}"
+  execute("docker", "start", name)
+  check_stayed_running(name)
+end
+
+def restart_container(name)
+  warn "Restarting a running container named #{name}"
+  execute("docker", "restart", name)
+  check_stayed_running(name)
+end
+
 def localhost_port_responding?(port)
   test "nc", "127.0.0.1", port, "<", "/dev/null", ">", "/dev/null;",
     "[", "`echo", "$?`", "-eq", "0", "]"
@@ -163,10 +141,14 @@ def unix_user_add(user)
   execute "adduser", "--disabled-password", "--gecos", "\"\"", user
 end
 
-def unix_user_get_id(user)
+def unix_user_get_uid(user)
   capture("id", "-u", user).strip
 end
 
+def unix_user_get_gid(user)
+  capture("id", "-g", user).strip
+end
+
 def file_exists?(file)
   test "[", "-f", file, "]"
 end
@@ -175,32 +157,6 @@ def directory_exists?(dir)
   test "[", "-d", dir, "]"
 end
 
-def check_stayed_running(name)
-  sleep 3
-  unless container_is_running?(name)
-    fatal "Container #{name} on #{fetch(:domain)} did not stay running more than 3 seconds"
-    exit
-  end
-  if container_is_restarting?(name)
-    fatal "Container #{name} on #{fetch(:domain)} is stuck restarting itself."
-    exit
-  end
-end
-
-def create_container(name, command)
-  warn "Starting a new container named #{name} on #{fetch(:domain)}"
-  execute("docker", "run", command)
-  check_stayed_running(name)
-end
-
-def start_container(name)
-  warn "Starting an existing but non-running container named #{name}"
-  execute("docker", "start", name)
-  check_stayed_running(name)
-end
-
-def restart_container(name)
-  warn "Restarting a running container named #{name}"
-  execute("docker", "restart", name)
-  check_stayed_running(name)
+def files_in_directory?(dir)
+  test("[", "\"$(ls", "-A", "#{dir})\"", "]")
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deployinator
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,14 +9,14 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-06 00:00:00.000000000 Z
+date: 2015-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 3.2.1
   type: :runtime
@@ -24,10 +24,42 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 3.2.1
-description: An Opinionated Deployment gem
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: sshkit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+description: Deploy Ruby on Rails using Capistrano and Docker
 email: davidamick@ctisolutionsinc.com
 executables: []
 extensions: []
@@ -38,6 +70,7 @@ files:
 - lib/deployinator/check.rb
 - lib/deployinator/config.rb
 - lib/deployinator/helpers.rb
+- lib/deployinator/built-in.rb
 - lib/deployinator/examples/Capfile
 - lib/deployinator/examples/config/deploy.rb
 - lib/deployinator/examples/config/deploy/staging.rb
@@ -57,14 +90,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- Docker ~> 1.3.1
 rubyforge_project: 
 rubygems_version: 1.8.23.2
 signing_key: