deploify 0.2.5

data/lib/deploify/recipes/nginx.rb

@@ -0,0 +1,122 @@
+# Copyright 2006-2008 by Mike Bailey. All rights reserved.
+# Copyright 2012 by Richard Riman. All rights reserved.
+
+Capistrano::Configuration.instance(:must_exist).load do
+
+  set :nginx_vhost_dir,             "/etc/nginx/sites-available"
+  set :nginx_enabled_vhost_dir,     "/etc/nginx/sites-enabled"
+  set :nginx_client_max_body_size,  "100M"
+  set :nginx_vhost_type,            :http_only
+  set :nginx_vhost_listen_ip,       "0.0.0.0"
+  set :nginx_upstream_servers,      []
+  # secured sites stuff
+  set :nginx_secured_site,          false
+  set :nginx_secure_user,           "developer"
+  set(:nginx_secure_password) { Capistrano::CLI.password_prompt "Enter password for securing this site:" }
+
+  set :ssl_certs_source_dir,        "config/ssl"
+
+  namespace :deploify do
+
+    namespace :nginx do
+
+      CHOICES_VHOST_TYPES = [:http_only, :http_with_ssl, :http_force_ssl]
+
+      PROJECT_CONFIG_FILES[:nginx] = [
+        { :template => "logrotate.conf.erb",
+          :path => "logrotate.conf",
+          :mode => 0640,
+          :owner => "root:root" }
+        ]
+
+      def project_config_files
+        PROJECT_CONFIG_FILES[:nginx] + [{
+          :template => "vhost_#{nginx_vhost_type}.conf.erb",
+          :path => "vhost.conf",
+          :mode => 0640,
+          :owner => "root:root"
+        }]
+      end
+
+      desc <<-DESC
+        Generate nginx config from one of the templates depending on situation.
+        Note that this does not push the config to the server, it merely generates
+        required configuration files. These should be kept under source control.
+        The can be pushed to the server with the :config task.
+      DESC
+      task :config_gen_project do
+        set :nginx_upstream_name, Digest::SHA1.hexdigest(application)
+        if nginx_upstream_servers.empty?
+          if app_server_type.eql?(:passenger)
+            set :nginx_upstream_servers, %W(unix:#{shared_path}/pids/#{app_server_type}.sock)
+          elsif app_server_type.eql?(:thin)
+            upstreams = []
+            set :nginx_upstream_servers,
+                (0..fetch(:thin_servers) - 1).collect { |idx| "unix:#{shared_path}/pids/#{app_server_type}.#{idx}.sock" }
+          end
+        end
+        project_config_files.each do |file|
+          _deploify.render_template(:nginx, file)
+        end
+      end
+
+      desc "Push nginx config files to server, enable (symlink) vhost and logrotate"
+      task :config_project, :roles => :web do
+        _deploify.push_configs(:nginx, project_config_files)
+        if [:http_with_ssl, :http_force_ssl].include?(nginx_vhost_type)
+          # SSL is demanded, push certificates
+          target_path = "#{deploy_to}/nginx/#{rails_env}"
+          std.su_put(File.read("#{ssl_certs_source_dir}/#{rails_env}.crt"), "#{target_path}.crt", "/tmp", :mode => 0600)
+          std.su_put(File.read("#{ssl_certs_source_dir}/#{rails_env}.key"), "#{target_path}.key", "/tmp", :mode => 0600)
+        end
+        top.deploify.nginx.generate_htaccess_file if nginx_secured_site
+      end
+
+      desc "Generate .htaccess file for site securing"
+      task :generate_htaccess_file, :roles => :web do
+        pwd = `openssl passwd -apr1 #{nginx_secure_password}`
+        std.su_put("#{nginx_secure_user}:#{pwd}", "#{deploy_to}/nginx/.htaccess", "/tmp", :mode => 0644)
+      end
+
+      desc "Activate nginx application vhost and logrotate"
+      task :activate, :roles => :web do
+        # logrotate
+        run "#{try_sudo} ln -sf #{deploy_to}/nginx/logrotate.conf /etc/logrotate.d/nginx-#{application}"
+        # nginx
+        run "#{try_sudo} ln -sf #{deploy_to}/nginx/vhost.conf #{nginx_vhost_dir}/#{application}"
+        run "#{try_sudo} ln -sf #{nginx_vhost_dir}/#{application} #{nginx_enabled_vhost_dir}/#{application}"
+      end
+
+      desc "Start Nginx"
+      task :start, :roles => :web do
+        # Nginx returns error code if you try to start it when it's already running.
+        # We don't want this to kill Capistrano.
+        send(run_method, "service nginx start; exit 0")
+      end
+
+      desc "Stop Nginx"
+      task :stop, :roles => :web do
+        # Nginx returns error code if you try to stop when it's not running.
+        # We don't want this to kill Capistrano.
+        send(run_method, "service nginx stop; exit 0")
+      end
+
+      desc "Restart Nginx"
+      task :restart, :roles => :web do
+        # Nginx returns error code if you try to reload when it's not running.
+        # We don't want this to kill Capistrano.
+        send(run_method, "service nginx restart; exit 0")
+      end
+
+      desc "Reload Nginx"
+      task :reload, :roles => :web do
+        # Nginx returns error code if you try to reload when it's not running.
+        # We don't want this to kill Capistrano.
+        send(run_method, "service nginx reload; exit 0")
+      end
+
+    end # namespace :nginx
+
+  end # namespace :deploify
+
+end

data/lib/deploify/recipes/passenger.rb

@@ -0,0 +1,130 @@
+# Copyright 2006-2008 by Mike Bailey. All rights reserved.
+# Copyright 2012 by Richard Riman. All rights reserved.
+
+Capistrano::Configuration.instance(:must_exist).load do
+
+  set :passenger_mode, :standalone
+  set :passenger_max_pool_size, 2   # in standalone mode means max. instances, but as nginx/apache module
+                                    # this means size of the entire application pool
+  set :passenger_min_instances, 1   # specifies minimum instances for application
+
+  set :passenger_port, nil          # standalone mode only: application port,
+                                    # if not specified, passenger is started as unix socket
+
+  set :passenger_spawn_method, "smart-lv2" # smart-lv2 | smart | conservative
+
+  # TODO: passenger as a nginx/apache module
+  # TODO: passenger installation on server
+
+  namespace :deploify do
+
+    namespace :passenger do
+
+      SYSTEM_CONFIG_FILES[:passenger] = [
+        { :template => "passengerctl-lib.erb",
+          :path => "/usr/local/lib/passengerctl",
+          :mode => 0644,
+          :owner => "root:root" }
+        ]
+
+      PROJECT_CONFIG_FILES[:passenger] = [
+        { :template => "passengerctl.erb",
+          :path => "passengerctl",
+          :mode => 0754,
+          :owner => "root:root" },
+
+        { :template => "logrotate.conf.erb",
+          :path => "logrotate.conf",
+          :mode => 0644,
+          :owner => "root:root" }
+        ]
+
+      desc "Install Passenger"
+      task :install, :roles => :app do
+        # TODO: install passenger things, there's only configuration part yet
+        # run "rvm gemset use global && gem install passenger --no-ri --no-rdoc"
+        # TODO: how to compile standalone passenger?
+        config_gen_system
+        config_system
+      end
+
+      desc "Generate Passenger configs (system & project level)."
+      task :config_gen do
+        # config_gen_system
+        config_gen_project
+      end
+
+      desc "Generate Passenger configs (system level) from template."
+      task :config_gen_system do
+        SYSTEM_CONFIG_FILES[:passenger].each do |file|
+          _deploify.render_template(:passenger, file)
+        end
+      end
+
+      desc "Generate Passenger configs (project level) from template."
+      task :config_gen_project do
+        PROJECT_CONFIG_FILES[:passenger].each do |file|
+          _deploify.render_template(:passenger, file)
+        end
+      end
+
+      desc "Push Passenger config files (system & project level) to server"
+      task :config, :roles => :app do
+        # config_system
+        config_project
+      end
+
+      desc "Push Passenger configs (system level) to server"
+      task :config_system, :roles => :app do
+        # TODO: passenger as nginx/apache module
+        _deploify.push_configs(:passenger, SYSTEM_CONFIG_FILES[:passenger])
+      end
+
+      desc "Push Passenger configs (project level) to server"
+      task :config_project, :roles => :app do
+        _deploify.push_configs(:passenger, PROJECT_CONFIG_FILES[:passenger])
+        # TODO: passenger as nginx/apache module
+        symlink_logrotate_config
+      end
+
+      task :activate, :roles => :app do
+        # activate_system
+        activate_project
+      end
+
+      task :activate_project, :roles => :app do
+        # TODO: passenger as nginx/apache module
+        case passenger_mode
+        when :standalone
+          symlink_and_activate_passengerctl
+          top.deploify.app.restart
+        end
+        top.deploify.web.reload
+      end
+
+      task :symlink_and_activate_passengerctl, :roles => :app do
+        run "#{try_sudo} ln -sf #{deploy_to}/passenger/passengerctl /etc/init.d/passenger-#{application}"
+        run "#{try_sudo} update-rc.d passenger-#{application} defaults"
+      end
+
+      task :symlink_logrotate_config, :roles => :app do
+        run "#{try_sudo} ln -sf #{deploy_to}/passenger/logrotate.conf /etc/logrotate.d/passenger-#{application}"
+      end
+
+      # Passenger runs Rails as the owner of this file.
+      task :set_owner_of_environment_rb, :roles => :app do
+        unless passenger_mode.eql?(:standalone)
+          run "#{sudo} chown #{app_user} #{current_path}/config/environment.rb"
+        end
+      end
+
+      desc "Restart Application"
+      task :restart, :roles => :app do
+        run "test -d #{current_path} && #{sudo} service passenger-#{application} restart; exit 0"
+      end
+
+    end # namespace :passenger
+
+  end # namespace :deploify
+
+end

data/lib/deploify/recipes/puma.rb

@@ -0,0 +1,15 @@
+# Copyright 2012 by Richard Riman. All rights reserved.
+
+Capistrano::Configuration.instance(:must_exist).load do
+
+  namespace :deploify do
+
+    namespace :puma do
+
+
+
+    end # namespace :puma
+
+  end # namespace :deploify
+
+end

data/lib/deploify/recipes/rails.rb

@@ -0,0 +1,221 @@
+# Copyright 2006-2008 by Mike Bailey. All rights reserved.
+# Copyright 2012 by Richard Riman. All rights reserved.
+
+Capistrano::Configuration.instance(:must_exist).load do
+
+  set(:deploy_to) { "/var/www/" + application }
+
+  set :app_user_prefix, "app_"
+  set(:app_user) { app_user_prefix + application }
+  set :app_group_prefix, "app_"
+  set(:app_group) { app_group_prefix + application }
+  set(:app_user_homedir) { deploy_to }
+  set :database_yml_in_scm, false
+  set :app_symlinks, nil
+  set :rails_env, "production"
+  set :shared_dirs, []  # Array of directories that should be created under shared/
+                        # and linked to in the project
+
+  # hook into the default capistrano deploy tasks
+  before "deploy:setup", :except => { :no_release => true } do
+    top.deploify.rails.setup_perms
+    top.deploify.rails.setup_paths
+    top.deploify.rails.setup_shared_dirs
+  end
+
+  after "deploy:setup", :except => { :no_release => true } do
+    top.deploify.rails.create_config_dir
+    top.deploify.rails.config_gen
+    top.deploify.rails.config
+    top.deploify.rails.set_perms_and_make_writable_by_app
+
+    top.deploify.rails.activate_services
+    top.deploify.web.reload
+    top.deploify.rails.setup_database
+  end
+
+  after "deploy:update_code", :roles => :app do
+    top.deploify.rails.symlink_database_yml unless database_yml_in_scm
+  end
+
+  after "deploy:create_symlink", :roles => :app do
+    top.deploify.rails.symlink_shared_dirs
+    top.deploify.rails.set_perms_on_shared_and_release
+    top.deploify.rails.set_perms_and_make_writable_by_app
+    top.deploify.passenger.set_owner_of_environment_rb if app_server_type.to_s.eql?("passenger")
+  end
+
+  after :deploy, "deploy:cleanup"
+
+  # If database.yml is not kept in scm and it is present in local
+  # config dir then push it out to server.
+  before "deploify:rails:symlink_database_yml", :roles => :app do
+    top.deploify.rails.push_database_yml unless database_yml_in_scm
+  end
+
+  namespace :deploify do
+
+    namespace :rails do
+
+      desc "Create deployment group and add current user to it, create user and group for application to run as"
+      task :setup_perms, :roles => [:app, :web] do
+        _deploify.groupadd(group)
+        _deploify.add_user_to_group(user, group)
+        _deploify.groupadd(app_group)
+        _deploify.add_user_to_group(user, app_group)
+        # # we've just added ourself to a group - need to teardown connection
+        # # so that next command uses new session where we belong in group
+        _deploify.teardown_connections
+        # create user and group for application to run as
+        _deploify.useradd(app_user, :group => app_group, :homedir => false)
+        # Set the primary group for the user the application runs as (in case
+        # user already existed when previous command was run)
+        sudo "usermod --gid #{app_group} --home #{app_user_homedir} #{app_user}"
+      end
+
+      # setup extra paths required for deployment
+      task :setup_paths, :roles => [:app, :web] do
+        _deploify.mkdir(deploy_to, :mode => 0775, :group => group, :via => :sudo)
+        _deploify.mkdir(shared_path, :mode => 0775, :group => group, :via => :sudo)
+        _deploify.mkdir("#{deploy_to}/releases", :mode => 0755, :group => group, :via => :sudo)
+      end
+
+      # create directories by the list of shared files and dirs
+      # TODO: check, how this works with a files
+      desc "Setup shared dirs"
+      task :setup_shared_dirs, :roles => [:app, :web] do
+        if shared_dirs.any?
+          shared_dirs.each do |dir|
+            _deploify.mkdir(File.join(shared_path, dir), :via => :sudo)
+          end
+        end
+      end
+
+      task :create_config_dir, :roles => :app do
+        _deploify.mkdir(File.join(shared_path, "config"), :group => group, :mode => 0775, :via => :sudo)
+      end
+
+      desc "Generate config files for rails app."
+      task :config_gen do
+        top.deploify.web.config_gen_project
+        top.deploify.app.config_gen_project
+        top.deploify.monit.config_gen_project if use_monit
+      end
+
+      desc "Push out config files for rails app."
+      task :config do
+        top.deploify.web.config_project
+        top.deploify.app.config_project
+        top.deploify.monit.config_project if use_monit
+      end
+
+      desc "Activate web, app and monit (if used)"
+      task :activate_services do
+        top.deploify.web.activate
+        top.deploify.app.activate
+        top.deploify.monit.activate if use_monit
+      end
+
+      task :setup_database, :roles => :db do
+        unless roles[:db].servers.empty? # Some apps don't use database!
+          top.deploify.db.create_database
+          top.deploify.db.grant_user_access_to_database
+        end
+      end
+
+      desc "Symlink shared dirs"
+      task :symlink_shared_dirs, :roles => :app do
+        if shared_dirs
+          shared_dirs.each do |dir|
+            path = File.split(dir)[0]
+            if path != '.'
+              _deploify.mkdir(File.join(current_path, path))
+            end
+            run "#{sudo} test -d #{current_path}/#{dir} && mv #{current_path}/#{dir} #{current_path}/#{dir}.moved_by_deploify; exit 0"
+            run "ln -nfs #{shared_path}/#{dir} #{current_path}/#{dir}"
+          end
+        end
+      end
+
+      task :set_perms_on_shared_and_release, :roles => :app do
+        run "#{sudo} chgrp -R #{app_group} #{shared_path} #{release_path}"
+        run "#{sudo} chown -Rf #{app_user}:#{app_group} #{release_path}/tmp/cache/assets; exit 0"
+        run "#{sudo} chmod -R g+w #{shared_path} #{release_path}"
+      end
+
+      desc "set group ownership and permissions on dirs app server needs to write to"
+      task :set_perms_and_make_writable_by_app, :roles => :app do
+        dirs = %W(
+          #{shared_path}/log
+          #{shared_path}/pids
+          #{shared_path}/uploads
+          #{current_path}/tmp
+          #{current_path}/public
+        ).join(' ')
+        run "#{sudo} chgrp -Rf #{app_group} #{dirs}; exit 0"
+        run "#{sudo} chmod -Rf g+w #{dirs}; exit 0"
+      end
+
+      # database things
+
+      set :db_host, "localhost"
+      set :db_socket, "/var/run/mysqld/mysqld.sock"
+      set(:db_adapter) do
+        Capistrano::CLI.ui.ask("Enter database adapter") do |q|
+          q.default = "mysql2"
+        end
+      end
+      set(:db_user) { application[0..15] }
+      set(:db_password) { Capistrano::CLI.ui.ask "Enter database password" }
+      set(:db_name) { application }
+      set :db_encoding, "utf8"
+
+      desc "Link in the production database.yml"
+      task :symlink_database_yml, :roles => :app do
+        run "#{sudo} ln -nfs #{shared_path}/config/database.yml #{release_path}/config/database.yml"
+      end
+
+      desc "Copy database.yml to shared/config/database.yml. Useful if not kept in scm."
+      task :push_database_yml, :roles => :app do
+        database_yml = ERB.new <<-EOF
+#{rails_env}:
+  adapter:  #{db_adapter}
+  username: #{db_user}
+  password: #{db_password}
+  database: #{db_name}
+  encoding: #{db_encoding}
+  host:     #{db_host}
+  socket:   #{db_socket}
+EOF
+        std.su_put(database_yml.result, "#{shared_path}/config/database.yml", "/tmp/")
+      end
+
+    end # namespace :rails
+
+    namespace :database do
+
+      desc "Create database"
+      task :create, :roles => :app do
+        run "cd #{deploy_to}/current && rake db:create RAILS_ENV=#{rails_env}"
+      end
+
+      desc "Run database migrations"
+      task :migrate, :roles => :app do
+        run "cd #{deploy_to}/current && rake db:migrate RAILS_ENV=#{rails_env}"
+      end
+
+      desc "Run database migrations"
+      task :schema_load, :roles => :app do
+        run "cd #{deploy_to}/current && rake db:schema:load RAILS_ENV=#{rails_env}"
+      end
+
+      desc "Roll database back to previous migration"
+      task :rollback, :roles => :app do
+        run "cd #{deploy_to}/current && rake db:rollback RAILS_ENV=#{rails_env}"
+      end
+
+    end # namespace :database
+
+  end # namespace :deploify
+
+end

data/lib/deploify/recipes/thin.rb

@@ -0,0 +1,104 @@
+# Copyright 2012 by Richard Riman. All rights reserved.
+
+Capistrano::Configuration.instance(:must_exist).load do
+
+  set :thin_applications_dir, "/var/www"
+  set :thin_servers,          2
+  set :thin_port,             nil # port is optional, if not specified, thin is started as unix socket
+
+  namespace :deploify do
+
+    namespace :thin do
+
+      SYSTEM_CONFIG_FILES[:thin] = [
+        { :template => "thinctl-lib.erb",
+          :path => "/usr/local/lib/thinctl",
+          :mode => 0644,
+          :owner => "root:root" }
+        ]
+
+      PROJECT_CONFIG_FILES[:thin] = [
+        { :template => "thinctl.erb",
+          :path => "thinctl",
+          :mode => 0754,
+          :owner => "root:root" },
+
+        { :template => "logrotate.conf.erb",
+          :path => "logrotate.conf",
+          :mode => 0644,
+          :owner => "root:root" }
+        ]
+
+      desc "Install Thin"
+      task :install, :roles => :app do
+        run "rvm gemset use global && gem install thin --no-ri --no-rdoc"
+        config_gen_system
+        config_system
+      end
+
+      desc "Generate Thin configs (system & project level)."
+      task :config_gen do
+        # config_gen_system
+        config_gen_project
+      end
+
+      desc "Generate Thin configs (system level) from template."
+      task :config_gen_system do
+        SYSTEM_CONFIG_FILES[:thin].each do |file|
+          _deploify.render_template(:thin, file)
+        end
+      end
+
+      desc "Generate Thin configs (project level) from template."
+      task :config_gen_project do
+        PROJECT_CONFIG_FILES[:thin].each do |file|
+          _deploify.render_template(:thin, file)
+        end
+      end
+
+      desc "Push Thin config files (system & project level) to server"
+      task :config, :roles => :app do
+        # config_system
+        config_project
+      end
+
+      desc "Push Thin configs (system level) to server"
+      task :config_system, :roles => :app do
+        _deploify.push_configs(:thin, SYSTEM_CONFIG_FILES[:thin])
+      end
+
+      desc "Push Thin configs (project level) to server"
+      task :config_project, :roles => :app do
+        _deploify.push_configs(:thin, PROJECT_CONFIG_FILES[:thin])
+        symlink_logrotate_config
+      end
+
+      task :activate, :roles => :app do
+        activate_project
+      end
+
+      task :activate_project, :roles => :app do
+        symlink_and_activate_thinctl
+        top.deploify.app.restart
+        top.deploify.web.reload
+      end
+
+      task :symlink_and_activate_thinctl, :roles => :app do
+        run "#{try_sudo} ln -sf #{deploy_to}/thin/thinctl /etc/init.d/thin-#{application}"
+        run "#{try_sudo} update-rc.d thin-#{application} defaults"
+      end
+
+      task :symlink_logrotate_config, :roles => :app do
+        run "#{try_sudo} ln -sf #{deploy_to}/thin/logrotate.conf /etc/logrotate.d/thin-#{application}"
+      end
+
+      desc "Restart Application"
+      task :restart, :roles => :app do
+        run "test -d #{current_path} && #{sudo} service thin-#{application} restart; exit 0"
+      end
+
+    end # namespace :thin
+
+  end # namespace :deploify
+
+end

data/lib/deploify/recipes.rb

@@ -0,0 +1,13 @@
+unless Capistrano::Configuration.respond_to?(:instance)
+  abort "Deploify requires Capistrano ~> 2.13.3"
+end
+
+require "#{File.dirname(__FILE__)}/recipes/deploify"
+# require "#{File.dirname(__FILE__)}/recipes/mongodb"
+require "#{File.dirname(__FILE__)}/recipes/monit"
+require "#{File.dirname(__FILE__)}/recipes/mysql"
+require "#{File.dirname(__FILE__)}/recipes/nginx"
+require "#{File.dirname(__FILE__)}/recipes/passenger"
+# require "#{File.dirname(__FILE__)}/recipes/puma"
+require "#{File.dirname(__FILE__)}/recipes/rails"
+require "#{File.dirname(__FILE__)}/recipes/thin"

data/lib/deploify/templates/monit/monit.conf.erb

@@ -0,0 +1,5 @@
+check process <%= app_server_type %>-<%= application %> with pidfile <%= shared_path %>/pids/<%= app_server_type %>.pid
+  start program = "/usr/sbin/service <%= app_server_type %>-<%= application %> start" with timeout <%= monit_timeout_interval %> seconds
+  stop program = "/usr/sbin/service <%= app_server_type %>-<%= application %> stop"
+  if 5 restarts within 5 cycles then timeout
+  group <%= app_server_type %>

data/lib/deploify/templates/nginx/logrotate.conf.erb

@@ -0,0 +1,12 @@
+<%= shared_path %>/log/access.log, <%= shared_path %>/log/error.log {
+  daily
+  missingok
+  rotate 15
+  compress
+  delaycompress
+  sharedscripts
+  dateext
+  postrotate
+    service nginx reload
+  endscript
+}