meataxe 0.5.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6c283dfff495121cc09751b3b324b41548a14a38
-  data.tar.gz: 937a201757543961e2ca52682cd74773c8f84fad
+SHA256:
+  metadata.gz: 9c50c66b46f3e9be7a11d31fd446291a9ee2225a85e024f489dadfa1da438bcf
+  data.tar.gz: b899e16f810426b8610d3af6cfe1253be06d38b0b72d19153df753c61579f0ec
 SHA512:
-  metadata.gz: 2c219f3df6013d5560e06f531580c1e706df152dc872c8e64499bdcac414c8ba672907efb6c1f28ef128101aa272b089b1bc0fd7a4a75778cf3ccca9ac7023f2
-  data.tar.gz: 0ab1cfc0f1e5acc740e7a9a015afb3fc98d00256dda7cbda0a119002c65eba8d954e315a92d0c833d7861ddc3dfe4c5e166dd59000d6ceba1fbd5f9e617042ba
+  metadata.gz: f3ae4bb181d3e74d8d8ca4361e5a167e93840d6928aab5ed728c61d258a91ffc05ad33656e9052d5ee40b5182a28e59a3ad59afdf7749869c45e1ffa4783119c
+  data.tar.gz: eb0c25853a74eccb18bcb57aedf0aa93f30c3be114f480ede7dbfda98e4ba1162fe19ea6721ecabb2cc9f6ae9394a82d0d27e5330a8821e7cb1aae98fa66c016

data/lib/meataxe.rb

@@ -1,9 +1 @@
-# require_relative "meataxe/version"
-#
-# # Load custom tasks from `lib/capistrano/*` if you have any defined
-# # Dir.glob('lib/capistrano/tasks/*.cap').each { |r| import r }
-# # Dir.glob('lib/capistrano/**/*.rb').each { |r| import r }
-#
-# module Meataxe
-#   # :)
-# end
+# :)

data/lib/meataxe/capistrano.rb

@@ -1,7 +1,7 @@
 Dir.glob(File.join(File.dirname(__FILE__), 'capistrano/tasks/*.cap')).each { |r| load r }
 
 # First try and copy the file `config/deploy/#{full_app_name}/#{from}.erb`
-# to `shared/config/to`
+# to `shared/config/#{to}`
 #
 # If the original source path doesn exist then it will search in:
 # `config/deploy/shared/#{from}.erb`
@@ -15,16 +15,20 @@ def smart_template(from, to=nil)
   if from_erb_path = template_file(from)
     from_erb = StringIO.new(ERB.new(File.read(from_erb_path)).result(binding))
     upload! from_erb, full_to_path
-    info "copying: #{from_erb} to: #{full_to_path}"
+    info "copying #{from_erb_path} to #{full_to_path}"
   else
     error "error #{from} not found"
   end
 end
 
+# Load templates from the local config directory, or fallback to default
+# templates.
 def template_file(name)
-  if File.exist?((file = "config/deploy/#{fetch(:full_app_name)}/#{name}.erb"))
+  if File.exist?((file = "config/deploy/shared/#{name}.erb"))
     return file
-  elsif File.exist?((file = "config/deploy/shared/#{name}.erb"))
+  elsif File.exist?((file = "config/deploy/templates/#{name}.erb"))
+    return file
+  elsif File.exist?((file = File.join(File.dirname(__FILE__), "capistrano/templates/#{name}.erb")))
     return file
   end
   return nil
@@ -46,6 +50,6 @@ def host_architecture
 end
 
 def update_repo(repo_url, target_path)
-  run "if [ -d #{target_path} ]; then (cd #{target_path} && git pull); else git clone #{repo_url} #{target_path}; fi"
+  execute "if [ -d #{target_path} ]; then (cd #{target_path} && git pull); else git clone #{repo_url} #{target_path}; fi"
   #run "cd #{target_path} && if [ -d #{target_path} ]; then (git pull); else (cd #{target_path} && cd.. && git clone #{repo_url} #{target_path}); fi"
 end

data/lib/meataxe/capistrano/dsl/rbenv_install.rb

@@ -0,0 +1,23 @@
+module Capistrano
+  module DSL
+    module RbenvInstall
+
+      def rbenv_ruby_build_path
+        "#{fetch(:rbenv_path)}/plugins/ruby-build"
+      end
+
+      def rbenv_bin_executable_path
+        "#{fetch(:rbenv_path)}/bin/rbenv"
+      end
+
+      def rbenv_repo_url
+        'https://github.com/sstephenson/rbenv.git'
+      end
+
+      def ruby_build_repo_url
+        'https://github.com/sstephenson/ruby-build.git'
+      end
+
+    end
+  end
+end

data/lib/meataxe/capistrano/tasks/compile_assets_locally.cap

@@ -1,17 +1,22 @@
 namespace :deploy do
-  desc "compiles assets locally then rsyncs"
+  # Rake::Task["deploy:assets:precompile"].clear_actions
+
+  desc "Compiles assets locally then rsync to server"
   task :compile_assets_locally do
+    asset_prefix = fetch(:asset_prefix, "assets")
     run_locally do
       execute "RAILS_ENV=#{fetch(:rails_env)} bundle exec rake assets:precompile"
     end
     on roles(:app) do |role|
       run_locally do
-        execute "rsync -av ./public/assets/ #{role.user}@#{role.hostname}:#{release_path}/public/assets/;"
+        execute "rsync -av --delete ./public/#{asset_prefix}/ #{role.user}@#{role.hostname}:#{shared_path}/public/#{asset_prefix}/;"
+        execute "rsync -av --delete ./public/packs/ #{role.user}@#{role.hostname}:#{shared_path}/public/packs/;"
       end
-      sudo "chmod -R 755 #{release_path}/public/assets/"
+      execute "chmod -R 755 #{shared_path}/public/#{asset_prefix}"
     end
     run_locally do
-      execute "rm -rf ./public/assets"
+      execute "rm -rf ./public/#{asset_prefix}"
+      execute "rm -rf ./public/packs"
     end
   end
 end

data/lib/meataxe/capistrano/tasks/monit.cap

@@ -7,9 +7,9 @@ namespace :monit do
       end
     end
   end
-  
+
   desc "Reload Monit"
-  task 'reload' do
+  task :reload do
     on roles(:app), in: :sequence, wait: 5 do
       sudo "monit reload"
     end

data/lib/meataxe/capistrano/tasks/nginx.cap

@@ -9,7 +9,7 @@ namespace :nginx do
   end
 
   desc "Remove default Nginx Virtual Host"
-  task "remove_default_vhost" do 
+  task :remove_default_vhost do 
     on roles(:app) do
       if test("[ -f /etc/nginx/sites-enabled/default ]")
       sudo "rm /etc/nginx/sites-enabled/default"

data/lib/meataxe/capistrano/tasks/postgres.cap

@@ -0,0 +1,227 @@
+namespace :load do
+  task :defaults do
+    set :postgres_backup_dir, -> { 'postgres_backup' }
+    set :postgres_role, :db
+    set :postgres_env, -> { fetch(:rack_env, fetch(:rails_env, fetch(:stage))) }
+    set :postgres_keep_local_dumps, 0
+    set :postgres_backup_compression_level, 0
+    set :postgres_remote_sqlc_file_path, -> { nil }
+    set :postgres_local_database_config, -> { nil }
+    set :postgres_remote_database_config, -> { nil }
+    set :postgres_remote_cluster, -> { nil }
+  end
+end
+
+namespace :postgres do
+  namespace :backup do
+    desc 'Create database dump'
+    task :create do
+      on roles(fetch(:postgres_role)) do |role|
+        grab_remote_database_config
+        config = fetch(:postgres_remote_database_config)
+
+        unless fetch(:postgres_remote_sqlc_file_path)
+          file_name = "db_backup.#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}.sqlc"
+          set :postgres_remote_sqlc_file_path, "#{shared_path}/#{fetch(:postgres_backup_dir)}/#{file_name}"
+        end
+        execute [
+          "PGPASSWORD=#{config['password']}",
+          "pg_dump #{user_option(config)}",
+          "-h #{config['host']}",
+          config['port'] ? "-p #{config['port']}" : nil,
+          "-Fc",
+          "--file=#{fetch(:postgres_remote_sqlc_file_path)}",
+          "-Z #{fetch(:postgres_backup_compression_level)}",
+          fetch(:postgres_remote_cluster) ? "--cluster #{fetch(:postgres_remote_cluster)}" : nil,
+          "#{config['database']}"
+        ].compact.join(' ')
+      end
+    end
+
+    desc 'Download last database dump'
+    task :download do
+      on roles(fetch(:postgres_role)) do |role|
+        unless fetch(:postgres_remote_sqlc_file_path)
+          file_name = capture("ls -v #{shared_path}/#{fetch :postgres_backup_dir}").split(/\n/).last
+          set :postgres_remote_sqlc_file_path, "#{shared_path}/#{fetch :postgres_backup_dir}/#{file_name}"
+        end
+
+        download!(fetch(:postgres_remote_sqlc_file_path), "tmp/#{fetch :postgres_backup_dir}/#{Pathname.new(fetch(:postgres_remote_sqlc_file_path)).basename}")
+        begin
+          remote_file = fetch(:postgres_remote_sqlc_file_path)
+        rescue SSHKit::Command::Failed => e
+          warn e.inspect
+        ensure
+          execute "rm #{remote_file}"
+        end
+      end
+    end
+
+    desc "Import last dump"
+    task :import do
+      grab_local_database_config
+      run_locally do
+        config = fetch(:postgres_local_database_config)
+
+        unless fetch(:database_name)
+          ask(:database_name, config['database'])
+        end
+
+        with rails_env: :development do
+          file_name = capture("ls -v tmp/#{fetch :postgres_backup_dir}").split(/\n/).last
+          file_path = "tmp/#{fetch :postgres_backup_dir}/#{file_name}"
+          begin
+            pgpass_path = File.join(Dir.pwd, '.pgpass')
+            File.open(pgpass_path, 'w+', 0600) { |file| file.write("*:*:*:#{config['username'] || config['user']}:#{config['password']}") }
+            execute "PGPASSFILE=#{pgpass_path} pg_restore -c #{user_option(config)} --no-owner -h #{config['host']} -p #{config['port'] || 5432 } -d #{fetch(:database_name)} #{file_path}"
+          rescue SSHKit::Command::Failed => e
+            warn e.inspect
+            info 'Import performed successfully!'
+          ensure
+            File.delete(pgpass_path) if File.exist?(pgpass_path)
+            File.delete(file_path) if (fetch(:postgres_keep_local_dumps) == 0) && File.exist?(file_path)
+          end
+        end
+      end
+    end
+
+    # Ensure that remote dirs for postgres backup exist
+    before :create, :ensure_remote_dirs do
+      on roles(fetch(:postgres_role)) do |role|
+        execute :mkdir, "-p #{shared_path}/#{fetch(:postgres_backup_dir)}"
+      end
+    end
+
+    # Ensure that loca dirs for postgres backup exist
+    before :download, :ensure_local_dirs do
+      on roles(fetch(:postgres_role)) do |role|
+        run_locally do
+          execute :mkdir, "-p  tmp/#{fetch :postgres_backup_dir}"
+        end
+      end
+    end
+
+    desc "Cleanup old local dumps"
+    task :cleanup do
+      run_locally do
+        dir = "tmp/#{fetch :postgres_backup_dir}"
+        file_names = capture("ls -v #{dir}").split(/\n/).sort
+        file_names[0...-fetch(:postgres_keep_local_dumps)].each {|file_name| File.delete("#{dir}/#{file_name}") }
+      end
+    end
+  end
+
+  desc 'Replicate database locally'
+  task :replicate do
+    grab_local_database_config
+    config = fetch(:postgres_local_database_config)
+    ask(:database_name, config['database'])
+    invoke "postgres:backup:create"
+    invoke "postgres:backup:download"
+    invoke "postgres:backup:import"
+    invoke("postgres:backup:cleanup") if fetch(:postgres_keep_local_dumps) > 0
+  end
+
+  def user_option(config)
+    if config['user'] || config['username']
+      "-U #{config['user'] || config['username']}"
+    else
+      '' # assume ident auth is being used
+    end
+  end
+
+  # Grabs local database config before importing dump
+  def grab_local_database_config
+    return if fetch(:postgres_local_database_config)
+    on roles(fetch(:postgres_role)) do |role|
+      run_locally do
+        env = 'development'
+        preload_env_variables(env)
+        yaml_content = ERB.new(capture 'cat config/database.yml').result
+        set :postgres_local_database_config,  database_config_defaults.merge(YAML::load(yaml_content)[env])
+      end
+    end
+  end
+
+  # Grabs remote database config before creating dump
+  def grab_remote_database_config
+    return if fetch(:postgres_remote_database_config)
+    on roles(fetch(:postgres_role)) do |role|
+      within release_path do
+        env = fetch(:postgres_env).to_s.downcase
+        filename = "#{deploy_to}/current/config/database.yml"
+        eval_yaml_with_erb = <<-RUBY.strip
+          #{env_variables_loader_code(env)}
+          require 'erb'
+          puts ERB.new(File.read('#{filename}')).result
+        RUBY
+
+        capture_config_cmd = "ruby -e \"#{eval_yaml_with_erb}\""
+        yaml_content = test('ruby -v') ? capture(capture_config_cmd) : capture(:bundle, :exec, capture_config_cmd)
+        set :postgres_remote_database_config,  database_config_defaults.merge(YAML::load(yaml_content)[env])
+      end
+    end
+  end
+
+  def database_config_defaults
+    { 'host' => 'localhost' }
+  end
+
+  # Load environment variables for configurations.
+  # Useful for such gems as Dotenv, Figaro, etc.
+  def preload_env_variables(env)
+    safely_require_gems('dotenv', 'figaro')
+
+    if defined?(Dotenv)
+      load_env_variables_with_dotenv(env)
+    elsif defined?(Figaro)
+      load_env_variables_with_figaro(env)
+    end
+  end
+
+  def load_env_variables_with_dotenv(env)
+    Dotenv.load(
+      File.expand_path('.env.local'),
+      File.expand_path(".env.#{env}"),
+      File.expand_path('.env')
+    )
+  end
+
+  def load_env_variables_with_figaro(env)
+    config = 'config/application.yml'
+
+    Figaro.application = Figaro::Application.new(environment: env, path: config)
+    Figaro.load
+  end
+
+  def safely_require_gems(*gem_names)
+    gem_names.each do |name|
+      begin
+        require name
+      rescue LoadError
+        # Ignore if gem doesn't exist
+      end
+    end
+  end
+
+  # Requires necessary gems (Dotenv, Figaro, ...) if present
+  # and loads environment variables for configurations
+  def env_variables_loader_code(env)
+    <<-RUBY.strip
+      begin
+        require 'dotenv'
+        Dotenv.load(File.expand_path('.env.#{env}'), File.expand_path('.env'))
+      rescue LoadError
+      end
+
+      begin
+        require 'figaro'
+        config = File.expand_path('../config/application.yml', __FILE__)
+
+        Figaro.application = Figaro::Application.new(environment: '#{env}', path: config)
+        Figaro.load
+      rescue LoadError
+      end
+    RUBY
+  end
+end

data/lib/meataxe/capistrano/tasks/rbenv_install.cap

@@ -0,0 +1,67 @@
+require 'meataxe/capistrano/dsl/rbenv_install'
+
+include Capistrano::DSL::RbenvInstall
+
+# Heavily depends on 'capistrano-rbenv' variables:
+# https://github.com/capistrano/rbenv/blob/master/lib/capistrano/tasks/rbenv.rake#L33-49
+# set :rbenv_type               # :user or :system
+# set :rbenv_ruby, '2.5.3'      # ruby version
+# set :rbenv_roles, :all        # where rbenv should be installed
+# set :rbenv_path,              # ~/.rbenv or /usr/local/rbenv, depends on :rbenv_type
+# set :rbenv_ruby_dir           # "#{fetch(:rbenv_path)}/versions/#{fetch(:rbenv_ruby)}" }
+
+namespace :rbenv do
+  desc 'Install rbenv'
+  task :install_rbenv do
+    on roles fetch(:rbenv_roles) do
+      next if test "[ -d #{fetch(:rbenv_path)} ]"
+      execute :git, :clone, rbenv_repo_url, fetch(:rbenv_path)
+    end
+  end
+
+  desc 'Install ruby build - rbenv plugin'
+  task :install_ruby_build do
+    on roles fetch(:rbenv_roles) do
+      next if test "[ -d #{rbenv_ruby_build_path} ]"
+      execute :git, :clone, ruby_build_repo_url, rbenv_ruby_build_path
+    end
+  end
+
+  desc 'Update ruby build - rbenv plugin'
+  task :update_ruby_build do
+    on roles fetch(:rbenv_roles) do
+      next unless test "[ -d #{rbenv_ruby_build_path} ]"
+      within rbenv_ruby_build_path do
+        execute :git, :pull
+      end
+    end
+  end
+
+  desc 'Install ruby'
+  task :install_ruby do
+    on roles fetch(:rbenv_roles) do
+      next if test "[ -d #{fetch(:rbenv_ruby_dir)} ]"
+      invoke 'rbenv:update_ruby_build'
+      execute rbenv_bin_executable_path, :install, fetch(:rbenv_ruby)
+    end
+  end
+
+  desc 'Install bundler gem'
+  task install_bundler: ['rbenv:map_bins'] do
+    on roles fetch(:rbenv_roles) do
+      next if test :gem, :query, '--quiet --installed --name-matches ^bundler$'
+      execute :gem, :install, :bundler, '--quiet --no-rdoc --no-ri'
+    end
+  end
+
+  desc 'Install rbenv, ruby build and ruby version'
+  task :install do
+    invoke 'rbenv:install_rbenv'
+    invoke 'rbenv:install_ruby_build'
+    invoke 'rbenv:install_ruby'
+    invoke 'rbenv:install_bundler'
+  end
+
+  before 'rbenv:validate', 'rbenv:install'
+  before 'bundler:map_bins', 'rbenv:install' if Rake::Task.task_defined?('bundler:map_bins')
+end

data/lib/meataxe/capistrano/tasks/run_tests.cap

@@ -1,18 +1,20 @@
 namespace :deploy do
-  desc "Runs test before deploying, can't deploy unless they pass"
+  desc "Runs test before deploying, and don't deploy unless they pass"
   task :run_tests do
     test_log = "log/capistrano.test.log"
     tests = fetch(:tests)
-    tests.each do |test|
-      puts "--> Running tests: '#{test}', please wait ..."
-      unless system "bundle exec rspec #{test} > #{test_log} 2>&1"
-        puts "--> Tests: '#{test}' failed. Results in: #{test_log} and below:"
-        system "cat #{test_log}"
-        exit;
+    if tests&.any?
+      tests.each do |test|
+        puts "--> Running tests: '#{test}', please wait ..."
+        unless system "bundle exec rspec #{test} > #{test_log} 2>&1"
+          puts "--> Tests: '#{test}' failed. Results in: #{test_log} and below:"
+          system "cat #{test_log}"
+          exit;
+        end
+        puts "--> '#{test}' passed"
       end
-      puts "--> '#{test}' passed"
+      puts "--> All tests passed"
+      system "rm #{test_log}"
     end
-    puts "--> All tests passed"
-    system "rm #{test_log}"
   end
 end

data/lib/meataxe/capistrano/tasks/setup_config.cap

@@ -1,32 +1,37 @@
 namespace :deploy do
   task :setup_config do
     on roles(:app) do
-      # make the config dir
+      # Make the config dir
       execute :mkdir, "-p #{shared_path}/config"
       full_app_name = fetch(:full_app_name)
 
-      # config files to be uploaded to shared/config, see the
-      # definition of smart_template for details of operation.
-      # Essentially looks for #{filename}.erb in deploy/#{full_app_name}/
-      # and if it isn't there, falls back to deploy/#{shared}. Generally
-      # everything should be in deploy/shared with params which differ
-      # set in the stage files
+      # Config files to be uploaded to shared/config, see the definition of
+      # `smart_template` for details of operation.
+      # Essentially looks for `#{filename}.erb` in `deploy/#{full_app_name}/`
+      # and if it isn't there, falls back to `deploy/#{shared}`. Generally
+      # everything should be in `deploy/shared` with params which differ
+      # set in the stage files.
       config_files = fetch(:config_files)
-      config_files.each do |file|
-        smart_template file
+      if config_files&.any?
+        config_files.each do |file|
+          smart_template file
+        end
       end
 
-      # which of the above files should be marked as executable
+      # Which of the above files should be marked as executable
       executable_files = fetch(:executable_config_files)
-      executable_files.each do |file|
-        execute :chmod, "+x #{shared_path}/config/#{file}"
+      if config_files&.any?
+        executable_files.each do |file|
+          execute :chmod, "+x #{shared_path}/config/#{file}"
+        end
       end
 
-      # symlink stuff which should be... symlinked
+      # Symlink stuff that should be... symlinked
       symlinks = fetch(:symlinks)
-
-      symlinks.each do |symlink|
-        sudo "ln -nfs #{shared_path}/config/#{symlink[:source]} #{sub_strings(symlink[:link])}"
+      if symlinks&.any?
+        symlinks.each do |symlink|
+          sudo "ln -nfs #{shared_path}/config/#{symlink[:source]} #{sub_strings(symlink[:link])}"
+        end
       end
     end
   end

data/lib/meataxe/capistrano/tasks/tasks.cap

@@ -1,5 +1,5 @@
 namespace :tasks do
-  desc "Invoke rake task"
+  desc "Invoke a rake task on the server"
   task :invoke do
     on roles(:app) do
       within release_path do

data/lib/meataxe/capistrano/templates/database.yml.erb

@@ -0,0 +1,8 @@
+<%= fetch(:rails_env) %>:
+  adapter: <%= fetch(:database_adapter) || 'postgresql' %>
+  encoding: <%= fetch(:database_encoding) || 'utf8' %>
+  database: <%= "#{fetch(:application)}_#{fetch(:rails_env)}" %>
+  pool: <%%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
+  username: <%%= ENV['DATABASE_USER'] %>
+  password: <%%= ENV['DATABASE_PASSWORD'] %>
+  host: <%= fetch(:database_host) || 'localhost' %>

data/lib/meataxe/capistrano/templates/log_rotation.erb

@@ -0,0 +1,11 @@
+<%= fetch(:deploy_to) %>/shared/log/*.log {
+    daily
+    missingok
+    rotate 52
+    compress
+    delaycompress
+    notifempty
+    sharedscripts
+    endscript
+    copytruncate
+}

data/lib/meataxe/capistrano/templates/monit.conf.erb

@@ -0,0 +1,30 @@
+<% if fetch(:puma_pid) %>
+check process <%= fetch(:full_app_name) %>_puma
+  with pidfile "<%= fetch(:puma_pid) %>"
+  start program = "/usr/bin/sudo -iu <%= fetch(:user) %> /bin/bash -c 'cd <%= current_path %> && <%= SSHKit.config.command_map[:puma] %> -C <%= fetch(:puma_conf) %> --daemon'"
+  stop program = "/usr/bin/sudo -iu <%= fetch(:user) %> /bin/bash -c 'cd <%= current_path %> && <%= SSHKit.config.command_map[:pumactl] %> -S <%= fetch(:puma_state) %> stop'"
+  if mem is greater than 300.0 MB for 1 cycles then restart       # eating up memory?
+  if cpu is greater than 50% for 2 cycles then alert              # send an email to admin
+  if cpu is greater than 80% for 30 cycles then restart           # hung process?
+<% end %>
+
+<% if fetch(:delayed_job_pid) %>
+check process <%= fetch(:full_app_name) %>_delayed_job
+  with pidfile "<%= fetch(:delayed_job_pid) %>"
+  start program = "/usr/bin/sudo -iu <%= fetch(:user) %> /bin/bash -c 'cd <%= current_path %> && RAILS_ENV=<%= fetch(:rails_env) %> <%= SSHKit.config.command_map[:bundle] %> exec bin/delayed_job start'"
+  stop program = "/usr/bin/sudo -iu <%= fetch(:user) %> /bin/bash -c 'cd <%= current_path %> && RAILS_ENV=<%= fetch(:rails_env) %> <%= SSHKit.config.command_map[:bundle] %> exec bin/delayed_job stop'"
+  if mem is greater than 300.0 MB for 1 cycles then restart       # eating up memory?
+  if cpu is greater than 50% for 2 cycles then alert              # send an email to admin
+  if cpu is greater than 80% for 30 cycles then restart           # hung process?
+<% end %>
+
+<% if fetch(:node_pid) %>
+# Using systemd to manage node server
+# check process <%= fetch(:full_app_name) %>_node
+#   with pidfile "<%= fetch(:node_pid) %>"
+#   start program = "/etc/init/<%= fetch(:full_app_name) %>_node start"
+#   stop program = "/etc/init/<%= fetch(:full_app_name) %>_node stop"
+#   if mem is greater than 300.0 MB for 1 cycles then restart       # eating up memory?
+#   if cpu is greater than 50% for 2 cycles then alert              # send an email to admin
+#   if cpu is greater than 80% for 30 cycles then restart           # hung process?
+<% end %>

data/lib/meataxe/capistrano/templates/nginx.conf.erb

@@ -0,0 +1,75 @@
+upstream puma_<%= fetch(:full_app_name) %> { <%
+  flags = 'fail_timeout=0'
+  @backends = [fetch(:puma_bind)].flatten.map do |m|
+  etype, address  = /(tcp|unix|ssl):\/{1,2}(.+)/.match(m).captures
+  if etype =='unix'
+    "server #{etype}:#{address} #{fetch(:nginx_socket_flags)};"
+  else
+    "server #{address.gsub(/0\.0\.0\.0(.+)/, "127.0.0.1\\1")} #{fetch(:nginx_http_flags)};"
+  end
+end
+%><% @backends.each do |server|  %>
+  <%= server %><% end %>
+}
+
+server {
+  listen 80;
+  server_name <%= fetch(:server_name) %>;
+
+  root <%= current_path %>/public;
+  try_files $uri/index.html $uri @puma_<%= fetch(:full_app_name) %>;
+
+  location @puma_<%= fetch(:full_app_name) %> {
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header Host $http_host;
+    proxy_redirect off;
+    proxy_pass http://puma_<%= fetch(:full_app_name) %>;
+    # limit_req zone=one;
+    access_log <%= shared_path %>/log/nginx.access.log;
+    error_log <%= shared_path %>/log/nginx.error.log;
+  }
+
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+  client_max_body_size 10M;
+  keepalive_timeout 10;
+
+  error_page 500 502 504 /500.html;
+  error_page 503 @503;
+
+  location = /50x.html {
+    root html;
+  }
+
+  location = /404.html {
+    root html;
+  }
+
+  location @503 {
+    error_page 405 = /system/maintenance.html;
+    if (-f $document_root/system/maintenance.html) {
+      rewrite ^(.*)$ /system/maintenance.html break;
+    }
+    rewrite ^(.*)$ /503.html break;
+  }
+
+  if ($request_method !~ ^(GET|HEAD|PUT|PATCH|POST|DELETE|OPTIONS)$ ){
+    return 405;
+  }
+
+  if (-f $document_root/system/maintenance.html) {
+    return 503;
+  }
+
+  location ~ \.(php)$ {
+    return 405;
+  }
+}
+
+<% if fetch(:enable_ssl) %>
+ <% raise 'SSL not implemented' %>
+<% end %>

data/lib/meataxe/capistrano/templates/nginx_ssl.conf.erb

@@ -0,0 +1,92 @@
+upstream puma_<%= fetch(:full_app_name) %> { <%
+  flags = 'fail_timeout=0'
+  @backends = [fetch(:puma_bind)].flatten.map do |m|
+  etype, address  = /(tcp|unix|ssl):\/{1,2}(.+)/.match(m).captures
+  if etype =='unix'
+    "server #{etype}:#{address} #{fetch(:nginx_socket_flags)};"
+  else
+    "server #{address.gsub(/0\.0\.0\.0(.+)/, "127.0.0.1\\1")} #{fetch(:nginx_http_flags)};"
+  end
+end
+%><% @backends.each do |server|  %>
+  <%= server %><% end %>
+}
+
+server {
+  listen 80;
+  listen [::]:80;
+  server_name <%= fetch(:server_name) %> www.<%= fetch(:server_name) %>;
+  return 301 https://$server_name$request_uri;
+}
+
+server {
+  listen 443 ssl;
+  server_name <%= fetch(:server_name) %>;
+
+  root <%= current_path %>/public;
+  try_files $uri/index.html $uri @puma_<%= fetch(:full_app_name) %>;
+
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    access_log off;
+    add_header Cache-Control public;
+  }
+
+  location @puma_<%= fetch(:full_app_name) %> {
+    proxy_set_header   Host $http_host;
+    proxy_set_header   X-Real-IP        $remote_addr;
+    proxy_set_header   X-Forwarded-For  $proxy_add_x_forwarded_for;
+    proxy_set_header   X-Forwarded-Proto $scheme;
+    proxy_redirect off;
+    proxy_pass http://puma_<%= fetch(:full_app_name) %>;
+    # limit_req zone=one;
+  }
+
+  # Setup SSL certs
+  ssl                   on;
+  ssl_certificate       <%= fetch(:ssl_certificate) %>;
+  ssl_certificate_key   <%= fetch(:ssl_certificate_key) %>;
+
+  include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
+  ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
+
+  # Logging and miscellaneous settings
+  access_log            <%= shared_path %>/log/nginx.access.log;
+  error_log             <%= shared_path %>/log/nginx.error.log;
+  rewrite_log           on;
+
+  client_max_body_size 25m;
+  keepalive_timeout 10;
+
+  # Redirect server error pages to the static page /50x.html
+  error_page 500 502 503 504 /50x.html;
+
+  location = /50x.html {
+    root html;
+  }
+
+  location = /404.html {
+    root html;
+  }
+
+  location @503 {
+    error_page 405 = /system/maintenance.html;
+    if (-f $document_root/system/maintenance.html) {
+      rewrite ^(.*)$ /system/maintenance.html break;
+    }
+    rewrite ^(.*)$ /503.html break;
+  }
+
+  if ($request_method !~ ^(GET|HEAD|PUT|PATCH|POST|DELETE|OPTIONS)$ ){
+    return 405;
+  }
+
+  if (-f $document_root/system/maintenance.html) {
+    return 503;
+  }
+
+  location ~ \.(php)$ {
+    return 405;
+  }
+}

data/lib/meataxe/capistrano/templates/node_server.service.erb

@@ -0,0 +1,22 @@
+[Unit]
+Description=<%= fetch(:full_app_name) %>
+After=network.target
+
+[Service]
+Environment=NODE_ENV=<%= fetch(:node_env, 'production') %> NODE_PORT=3001
+# HOME=/home/<%= fetch(:user) %>
+StandardOutput=file:<%= shared_path %>/log/node_<%= fetch(:node_env, 'production') %>.log
+StandardError=file:<%= shared_path %>/log/node_<%= fetch(:node_env, 'production') %>.log
+User=<%= fetch(:user) %>
+WorkingDirectory=<%= current_path %>/<%= fetch(:node_prefix) %>/
+ExecStart=/usr/bin/node <%= fetch(:node_file) %>
+Restart=on-failure
+
+# limit CPU and RAM quota for our service
+# CPUAccounting=true
+# CPUQuota=10%
+# MemoryAccounting=true
+# MemoryLimit=50M
+
+[Install]
+WantedBy=multi-user.target

data/lib/meataxe/capistrano/templates/puma.rb.erb

@@ -0,0 +1,10 @@
+#!/usr/bin/env puma
+
+directory '<%= current_path %>'
+environment '<%= fetch(:rails_env) %>'
+daemonize
+#quiet
+threads <%= fetch(:puma_threads) %>
+pidfile '<%= fetch(:puma_pid) %>'
+state_path '<%= fetch(:puma_state) %>'
+bind '<%= fetch(:puma_bind) %>'

data/lib/meataxe/version.rb

@@ -1,3 +1,3 @@
 module Meataxe
-  VERSION = "0.5.0"
+  VERSION = "0.6.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meataxe
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Kam Low
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-12 00:00:00.000000000 Z
+date: 2019-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,14 +52,24 @@ files:
 - Rakefile
 - lib/meataxe.rb
 - lib/meataxe/capistrano.rb
+- lib/meataxe/capistrano/dsl/rbenv_install.rb
 - lib/meataxe/capistrano/tasks/check_revision.cap
 - lib/meataxe/capistrano/tasks/compile_assets_locally.cap
 - lib/meataxe/capistrano/tasks/logs.cap
 - lib/meataxe/capistrano/tasks/monit.cap
 - lib/meataxe/capistrano/tasks/nginx.cap
+- lib/meataxe/capistrano/tasks/postgres.cap
+- lib/meataxe/capistrano/tasks/rbenv_install.cap
 - lib/meataxe/capistrano/tasks/run_tests.cap
 - lib/meataxe/capistrano/tasks/setup_config.cap
 - lib/meataxe/capistrano/tasks/tasks.cap
+- lib/meataxe/capistrano/templates/database.yml.erb
+- lib/meataxe/capistrano/templates/log_rotation.erb
+- lib/meataxe/capistrano/templates/monit.conf.erb
+- lib/meataxe/capistrano/templates/nginx.conf.erb
+- lib/meataxe/capistrano/templates/nginx_ssl.conf.erb
+- lib/meataxe/capistrano/templates/node_server.service.erb
+- lib/meataxe/capistrano/templates/puma.rb.erb
 - lib/meataxe/version.rb
 - meataxe.gemspec
 homepage: http://github.com/sourcey/meataxe
@@ -82,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Killer Capistrano 3 deployment scripts.