nginxinator 0.0.3 → 0.1.0

data/lib/nginxinator/config.rb

@@ -1,23 +1,21 @@
-namespace :nginx do
-
-  task :ensure_setup do |t, args|
-    @settings = NginxInstance.new
-    # use 'rake pg:COMMAND debug=true' for debugging (you can also add --trace if you like)
-    SSHKit.config.output_verbosity = Logger::DEBUG if ENV['debug'] == "true"
-  end
+namespace :nginxinator do
 
   desc 'Write example config files'
   task :write_example_configs do
     run_locally do
-      execute "mkdir -p templates/nginx/sites-enabled"
+      execute "mkdir -p config/deploy templates/nginx/sites-enabled"
       {
-        'examples/Dockerfile'               => 'Dockerfile_example',
-        'examples/nginxinator_example.rb'   => 'nginxinator_example.rb',
-        'examples/nginx_example.conf.erb'   => 'templates/nginx/nginx_example.conf.erb',
-        'examples/site-enabled_example.erb' => 'templates/nginx/sites-enabled/client-app_example.erb',
-        'examples/ssl.crt_example.erb'      => 'templates/nginx/ssl.crt_example.erb',
-        'examples/ssl.key_example.erb'      => 'templates/nginx/ssl.key_example.erb',
-        'examples/mime.types_example.erb'   => 'templates/nginx/mime.types_example.erb'
+        'examples/Capfile'                              => 'Capfile_example',
+        'examples/config/deploy.rb'                     => 'config/deploy_example.rb',
+        'examples/config/deploy_nginxinator.rb'         => 'config/deploy_nginxinator_example.rb',
+        'examples/config/deploy/staging.rb'             => 'config/deploy/staging_example.rb',
+        'examples/config/deploy/staging_nginxinator.rb' => 'config/deploy/staging_nginxinator_example.rb',
+        'examples/Dockerfile'                           => 'templates/nginx/Dockerfile_example',
+        'examples/nginx.conf.erb'                       => 'templates/nginx/nginx_example.conf.erb',
+        'examples/site-enabled.erb'                     => 'templates/nginx/sites-enabled/client-app_example.erb',
+        'examples/ssl.crt.erb'                          => 'templates/nginx/ssl.crt_example.erb',
+        'examples/ssl.key.erb'                          => 'templates/nginx/ssl.key_example.erb',
+        'examples/mime.types.erb'                       => 'templates/nginx/mime.types_example.erb'
       }.each do |source, destination|
         config = File.read(File.dirname(__FILE__) + "/#{source}")
         File.open("./#{destination}", 'w') { |f| f.write(config) }

data/lib/nginxinator/examples/Capfile

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

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

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

data/lib/nginxinator/examples/config/deploy/staging_nginxinator.rb

@@ -0,0 +1,58 @@
+## For a standard Ubuntu 12.04 Nginx Docker image you should only
+##  need to change the following values to get started:
+set :domain,                      "client.example.com"
+set :sites_enabled,               ['client-app']
+set :publish_ports,               [
+  {
+    "external" => "80",
+    "internal" => "80"
+  },
+  {
+    "external" => "443",
+    "internal" => "443"
+  }
+]
+set :image_name,                  "snarlysodboxer/nginx:0.0.0"
+set :external_data_path,          "/var/www/client-app/current"
+set :external_logs_path,          "/var/www/client-app/shared/log/nginx"
+
+
+
+## The values below may be commonly changed to match specifics
+##  relating to a particular Docker image or setup:
+set :config_files,                ["nginx.conf", "ssl.crt", "ssl.key", "mime.types"]
+set :internal_data_path,          -> { fetch(:external_data_path) }
+set :internal_conf_path,          "/etc/nginx"
+set :internal_sites_enabled_path, "/etc/nginx/sites-enabled"
+set :internal_logs_path,          "/var/log/nginx"
+set :internal_sock_path,          "/var/run/unicorn"
+set :ssh_user,                    ENV["USER"]
+
+
+
+## The values below are not meant to be changed and shouldn't
+##  need to be under the majority of circumstances:
+set :nginx_container_name,        "#{fetch(:domain)}-nginx-#{fetch(:publish_ports).collect { |p| p['external'] }.join('-')}"
+set :external_conf_path,          "/#{fetch(:nginx_container_name)}-conf"
+set :external_sites_enabled_path, "#{fetch(:external_conf_path)}/sites-enabled"
+set :external_sock_path,          "#{fetch(:external_conf_path)}/run"
+set :ports_options,               -> {
+  options = []
+  fetch(:publish_ports).each do |port_set|
+    options += ["--publish", "0.0.0.0:#{port_set['external']}:#{port_set['internal']}"]
+  end
+  options
+}
+set :docker_run_command,          -> { [
+  "--detach", "--tty",
+  "--name",   fetch(:nginx_container_name),
+  "--volume", "#{fetch(:external_data_path)}:#{fetch(:internal_data_path)}:rw",
+  "--volume", "#{fetch(:external_conf_path)}:#{fetch(:internal_conf_path)}:rw",
+  "--volume", "#{fetch(:external_sock_path)}:#{fetch(:internal_sock_path)}:rw",
+  "--volume", "#{fetch(:external_logs_path)}:#{fetch(:internal_logs_path)}:rw",
+  "--restart", "always",
+  fetch(:ports_options),
+  fetch(:image_name)
+].flatten }
+set :local_templates_path,        "templates/nginx"
+set :local_site_templates_path,   -> { "#{fetch(:local_templates_path)}/sites-enabled" }

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

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

data/lib/nginxinator/examples/config/deploy_nginxinator.rb

@@ -0,0 +1 @@
+# Only stage-specific nginxinator config options are needed.

data/lib/nginxinator/examples/{nginx_example.conf.erb → nginx.conf.erb}

@@ -4,7 +4,7 @@ daemon off;
 user www-data;
 worker_processes  4;
 
-error_log  <%= @settings.internal_logs_path %>/error.log warn;
+error_log  <%= @internal_logs_path %>/error.log warn;
 pid        /var/run/nginx.pid;
 
 events {
@@ -12,10 +12,10 @@ events {
 }
 
 http {
-  include     <%= @settings.internal_conf_path %>/mime.types;
+  include     <%= @internal_conf_path %>/mime.types;
   default_type  application/octet-stream;
 
-  access_log	<%= @settings.internal_logs_path %>/access.log;
+  access_log	<%= @internal_logs_path %>/access.log;
 
   sendfile on;
   tcp_nopush on;
@@ -34,6 +34,6 @@ http {
   types_hash_bucket_size 64;
 
 
-  include <%= @settings.internal_conf_path %>/conf.d/*.conf;
-  include <%= @settings.internal_sites_enabled_path %>/*;
+  include <%= @internal_conf_path %>/conf.d/*.conf;
+  include <%= @internal_sites_enabled_path %>/*;
 }

data/lib/nginxinator/examples/{site-enabled_example.erb → site-enabled.erb}

@@ -1,25 +1,25 @@
 upstream unicorn {
-  server unix:<%= @settings.internal_sock_path %>/unicorn.socket fail_timeout=0;
+  server unix:<%= @internal_sock_path %>/unicorn.socket fail_timeout=0;
 }
 
 
 server {
   listen 80;
   location / {
-    rewrite ^/(.*)$ https://<%= @settings.domain %>/$1 redirect;
+    rewrite ^/(.*)$ https://<%= @domain %>/$1 redirect;
   }
 }
 
 server {
   listen 443;
-  set $public_root <%= @settings.internal_data_path %>/public;
-  set $rails_root <%= @settings.internal_data_path %>;
+  set $public_root <%= @internal_data_path %>/public;
+  set $rails_root <%= @internal_data_path %>;
 
   root $public_root;
 
   ssl on;
-  ssl_certificate <%= @settings.internal_conf_path %>/ssl.crt;
-  ssl_certificate_key <%= @settings.internal_conf_path %>/ssl.key;
+  ssl_certificate <%= @internal_conf_path %>/ssl.crt;
+  ssl_certificate_key <%= @internal_conf_path %>/ssl.key;
   ssl_ciphers HIGH;
   ssl_protocols SSLv3 TLSv1;
   ssl_prefer_server_ciphers on;

data/lib/nginxinator/nginx.rb

@@ -1,7 +1,5 @@
 require 'erb'
 
-require './nginxinator.rb' if File.exists?('./nginxinator.rb')
-
 ## NOTES:
 # tasks without 'desc' description lines are for manual debugging of this
 #   deployment code.
@@ -11,42 +9,41 @@ require './nginxinator.rb' if File.exists?('./nginxinator.rb')
 
 namespace :nginx do
 
-  desc "Idempotently setup one or more Nginx instances using values in ./nginxinator.rb"
-  task :setup => :ensure_setup do
-    # instance variables are lost inside SSHKit's 'on' block, so
-    #   at the beginning of each task we assign 'settings' to @settings.
-    settings = @settings
+  desc "Idempotently setup an Nginx instance using values in ./config/deploy/<stage>_nginxinator.rb"
+  task :setup do
     Rake::Task['nginx:ensure_access_docker'].invoke
     Rake::Task['nginx:open_firewall'].invoke
     # 'on', 'run_locally', 'as', 'execute', 'info', 'warn', and 'fatal' are from SSHKit
-    on "#{settings.ssh_user}@#{settings.domain}" do
+    on roles(:app) do
       config_file_changed = false
-      settings.config_files.each do |config_file|
-        if nginx_config_file_differs?(settings, settings.local_templates_path, settings.external_conf_path, config_file)
-          warn "Config file #{config_file} on #{settings.domain} is being updated."
-          Rake::Task['nginx:install_config_file'].invoke(settings.local_templates_path, settings.external_conf_path, config_file)
+      fetch(:config_files).each do |config_file|
+        if nginx_config_file_differs?(fetch(:local_templates_path), fetch(:external_conf_path), config_file)
+          warn "Config file #{config_file} on #{fetch(:domain)} is being updated."
+          Rake::Task['nginx:install_config_file'].invoke(fetch(:local_templates_path), fetch(:external_conf_path), config_file)
           Rake::Task['nginx:install_config_file'].reenable
           config_file_changed = true
         end
       end
-      settings.sites_enabled.each do |config_file|
-        if nginx_config_file_differs?(settings, settings.local_site_templates_path, settings.external_sites_enabled_path, config_file)
-          warn "Config file #{config_file} on #{settings.domain} is being updated."
-          Rake::Task['nginx:install_config_file'].invoke(settings.local_site_templates_path, settings.external_sites_enabled_path, config_file)
+      fetch(:sites_enabled).each do |config_file|
+        if nginx_config_file_differs?(fetch(:local_site_templates_path), fetch(:external_sites_enabled_path), config_file)
+          warn "Config file #{config_file} on #{fetch(:domain)} is being updated."
+          Rake::Task['nginx:install_config_file'].invoke(fetch(:local_site_templates_path), fetch(:external_sites_enabled_path), config_file)
           Rake::Task['nginx:install_config_file'].reenable
           config_file_changed = true
         end
       end
-      unless nginx_container_exists?(settings.container_name)
+      execute "sudo", "mkdir", "-p", fetch(:external_sock_path)
+      execute "sudo", "chown", "-R", "www-data:www-data", fetch(:external_sock_path)
+      unless nginx_container_exists?
         Rake::Task['nginx:create_container'].invoke
       else
-        unless nginx_container_is_running?(settings.container_name)
+        unless nginx_container_is_running?
           Rake::Task['nginx:start_container'].invoke
         else
           if config_file_changed
             Rake::Task['nginx:restart_container'].invoke
           else
-            info "No config file changes for #{settings.container_name} and it is already running; we're setup!"
+            info "No config file changes for #{fetch(:nginx_container_name)} and it is already running; we're setup!"
           end
         end
       end
@@ -54,75 +51,69 @@ namespace :nginx do
   end
 
   desc "Check the status of the Nginx instance."
-  task :status => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
+  task :status do
+    on roles(:app) do
       info ""
-      if nginx_container_exists?(settings.container_name)
-        info "#{settings.container_name} exists on #{settings.domain}"
+      if nginx_container_exists?
+        info "#{fetch(:nginx_container_name)} exists on #{fetch(:domain)}"
         info ""
-        if nginx_container_is_running?(settings.container_name)
-          info "#{settings.container_name} is running on #{settings.domain}"
+        if nginx_container_is_running?
+          info "#{fetch(:nginx_container_name)} is running on #{fetch(:domain)}"
           info ""
         else
-          info "#{settings.container_name} is not running on #{settings.domain}"
+          info "#{fetch(:nginx_container_name)} is not running on #{fetch(:domain)}"
           info ""
         end
       else
-        info "#{settings.container_name} does not exist on #{settings.domain}"
+        info "#{fetch(:nginx_container_name)} does not exist on #{fetch(:domain)}"
         info ""
       end
     end
   end
 
-  task :create_container => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
-      warn "Starting a new container named #{settings.container_name} on #{settings.domain}"
-      execute("docker", "run", settings.docker_run_command)
+  task :create_container do
+    on roles(:app) do
+      warn "Starting a new container named #{fetch(:nginx_container_name)} on #{fetch(:domain)}"
+      execute("docker", "run", fetch(:docker_run_command))
       sleep 2
-      fatal nginx_stay_running_message(settings) and raise unless nginx_container_is_running?(settings.container_name)
+      fatal nginx_stay_running_message and raise unless nginx_container_is_running?
     end
   end
 
-  task :start_container => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
-      warn "Starting an existing but non-running container named #{settings.container_name}"
-      execute("docker", "start", settings.container_name)
+  task :start_container do
+    on roles(:app) do
+      warn "Starting an existing but non-running container named #{fetch(:nginx_container_name)}"
+      execute("docker", "start", fetch(:nginx_container_name))
       sleep 2
-      fatal nginx_stay_running_message(settings) and raise unless nginx_container_is_running?(settings.container_name)
+      fatal nginx_stay_running_message and raise unless nginx_container_is_running?
     end
   end
 
-  task :restart_container => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
-      warn "Restarting a running container named #{settings.container_name}"
-      execute("docker", "restart", settings.container_name)
+  task :restart_container do
+    on roles(:app) do
+      warn "Restarting a running container named #{fetch(:nginx_container_name)}"
+      execute("docker", "restart", fetch(:nginx_container_name))
       sleep 2
-      fatal nginx_stay_running_message(settings) and raise unless nginx_container_is_running?(settings.container_name)
+      fatal nginx_stay_running_message and raise unless nginx_container_is_running?
     end
   end
 
-  task :ensure_access_docker => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
-      as settings.ssh_user do
+  task :ensure_access_docker do
+    on roles(:app) do
+      as fetch(:ssh_user) do
         unless test("bash", "-c", "\"docker", "ps", "&>", "/dev/null\"")
-          execute("sudo", "usermod", "-a", "-G", "docker", settings.ssh_user)
+          execute("sudo", "usermod", "-a", "-G", "docker", fetch(:ssh_user))
           fatal "Newly added to docker group, this run will fail, next run will succeed. Simply try again."
         end
       end
     end
   end
 
-  task :install_config_file, [:template_path, :config_path, :config_file] => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
+  task :install_config_file, [:template_path, :config_path, :config_file] do |t, args|
+    on roles(:app) do
       as 'root' do
         execute("mkdir", "-p", args.config_path) unless test("test", "-d", args.config_path)
-        generated_config_file = nginx_generate_config_file(settings, "#{args.template_path}/#{args.config_file}.erb")
+        generated_config_file = nginx_generate_config_file("#{args.template_path}/#{args.config_file}.erb")
         upload! StringIO.new(generated_config_file), "/tmp/#{args.config_file}"
         execute("mv", "/tmp/#{args.config_file}", "#{args.config_path}/#{args.config_file}")
         execute("chown", "-R", "root:root", args.config_path)
@@ -131,12 +122,11 @@ namespace :nginx do
     end
   end
 
-  task :open_firewall => :ensure_setup do |t, args|
-    settings = @settings
-    on "#{settings.ssh_user}@#{settings.domain}" do
+  task :open_firewall do
+    on roles(:app) do
       as "root" do
         if test "ufw", "status"
-          settings.publish_ports.collect { |port_set| port_set['external'] }.each do |port|
+          fetch(:publish_ports).collect { |port_set| port_set['external'] }.each do |port|
             raise "Error during opening UFW firewall" unless test("ufw", "allow", "#{port}/tcp")
           end
         end
@@ -149,12 +139,12 @@ namespace :nginx do
     # Temporarily added 'nginx_' to the beginning of each of these methods to avoid
     #   getting them overwritten by other gems with methods with the same names, (E.G. postgresinator.)
     ## TODO Figure out how to do this the right or better way.
-    def nginx_stay_running_message(settings)
-      "Container #{settings.container_name} on #{settings.domain} did not stay running more than 2 seconds"
+    def nginx_stay_running_message
+      "Container #{fetch(:nginx_container_name)} on #{fetch(:domain)} did not stay running more than 2 seconds"
     end
 
-    def nginx_config_file_differs?(settings, local_templates_path, external_config_path, config_file)
-      generated_config_file = nginx_generate_config_file(settings, "#{local_templates_path}/#{config_file}.erb")
+    def nginx_config_file_differs?(local_templates_path, external_config_path, config_file)
+      generated_config_file = nginx_generate_config_file("#{local_templates_path}/#{config_file}.erb")
       as 'root' do
         config_file_path = "#{external_config_path}/#{config_file}"
         if nginx_file_exists?(config_file_path)
@@ -165,20 +155,31 @@ namespace :nginx do
       end
     end
 
-    def nginx_generate_config_file(settings, template_file_path)
-      @settings     = settings # needed for ERB
+    def nginx_generate_config_file(template_file_path)
+      set :logs_path,               -> { fetch(:internal_logs_path) }
+      set :conf_path,               -> { fetch(:internal_conf_path) }
+      set :sock_path,               -> { fetch(:internal_sock_path) }
+      set :data_path,               -> { fetch(:internal_data_path) }
+      set :sites_path,              -> { fetch(:internal_sites_enabled_path) }
+      set :cdomain,                 -> { fetch(:domain) }
+      @internal_logs_path           = fetch(:logs_path)
+      @internal_conf_path           = fetch(:conf_path)
+      @internal_sock_path           = fetch(:sock_path)
+      @internal_data_path           = fetch(:data_path)
+      @internal_sites_enabled_path  = fetch(:sites_path)
+      @domain                       = fetch(:cdomain)
       template_path = File.expand_path(template_file_path)
       ERB.new(File.new(template_path).read).result(binding)
     end
 
-    def nginx_container_exists?(container_name)
-      test "docker", "inspect", container_name, ">", "/dev/null"
+    def nginx_container_exists?
+      test "docker", "inspect", fetch(:nginx_container_name), ">", "/dev/null"
     end
 
-    def nginx_container_is_running?(container_name)
+    def nginx_container_is_running?
       (capture "docker", "inspect",
         "--format='{{.State.Running}}'",
-        container_name).strip == "true"
+        fetch(:nginx_container_name)).strip == "true"
     end
 
     def nginx_file_exists?(file_name_path)

data/lib/nginxinator.rb

@@ -1,6 +1,5 @@
-require 'rake'
-require 'sshkit'
-require 'sshkit/dsl'
+require 'capistrano/setup'
+require 'capistrano/deploy'
 
 load 'nginxinator/nginx.rb'
 load 'nginxinator/config.rb'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nginxinator
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-05 00:00:00.000000000 Z
+date: 2014-11-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,12 +68,16 @@ files:
 - lib/nginxinator.rb
 - lib/nginxinator/nginx.rb
 - lib/nginxinator/config.rb
-- lib/nginxinator/examples/nginxinator_example.rb
-- lib/nginxinator/examples/nginx_example.conf.erb
-- lib/nginxinator/examples/site-enabled_example.erb
-- lib/nginxinator/examples/ssl.crt_example.erb
-- lib/nginxinator/examples/ssl.key_example.erb
-- lib/nginxinator/examples/mime.types_example.erb
+- lib/nginxinator/examples/Capfile
+- lib/nginxinator/examples/config/deploy.rb
+- lib/nginxinator/examples/config/deploy_nginxinator.rb
+- lib/nginxinator/examples/config/deploy/staging.rb
+- lib/nginxinator/examples/config/deploy/staging_nginxinator.rb
+- lib/nginxinator/examples/nginx.conf.erb
+- lib/nginxinator/examples/site-enabled.erb
+- lib/nginxinator/examples/ssl.crt.erb
+- lib/nginxinator/examples/ssl.key.erb
+- lib/nginxinator/examples/mime.types.erb
 - lib/nginxinator/examples/Dockerfile
 homepage: https://github.com/snarlysodboxer/nginxinator
 licenses:

data/lib/nginxinator/examples/nginxinator_example.rb

@@ -1,116 +0,0 @@
-class NginxInstance
-
-  ## For a standard Ubuntu 12.04 Nginx Docker image you should only
-  ##  need to change the following values to get started:
-    def domain
-      "client.example.com"
-    end
-
-    def sites_enabled
-      ['client-app']
-    end
-
-    def publish_ports
-      [
-        {
-          "external" => "80",
-          "internal" => "80"
-        },
-        {
-          "external" => "443",
-          "internal" => "443"
-        }
-      ]
-    end
-
-    def image_name
-      "snarlysodboxer/nginx:0.0.0"
-    end
-
-    def external_data_path
-      "/var/www/current"
-    end
-
-    def external_logs_path
-      "/var/log/nginx"
-    end
-
-
-
-  ## The values below may be commonly changed to match specifics
-  ##  relating to a particular Docker image or setup:
-    def config_files
-      ["nginx.conf", "ssl.crt", "ssl.key", "mime.types"]
-    end
-
-    def internal_data_path
-      "/var/www/current"
-    end
-
-    def internal_conf_path
-      "/etc/nginx"
-    end
-
-    def internal_sites_enabled_path
-      "/etc/nginx/sites-enabled"
-    end
-
-    def internal_logs_path
-      "/var/log/nginx"
-    end
-
-    def internal_sock_path
-      "/var/run/unicorn"
-    end
-
-    def ssh_user
-      ENV["USER"]
-    end
-
-
-
-  ## The values below are not meant to be changed and shouldn't
-  ##  need to be under the majority of circumstances:
-
-  def external_conf_path
-    "/#{container_name}-conf"
-  end
-
-  def external_sites_enabled_path
-    "#{external_conf_path}/sites-enabled"
-  end
-
-  def external_sock_path
-    "#{external_conf_path}/run"
-  end
-
-  def container_name
-    "#{domain}-nginx-#{publish_ports.collect { |p| p['external'] }.join('-')}"
-  end
-
-  def docker_run_command
-    ports_options = []
-    publish_ports.each do |port_set|
-      ports_options += ["--publish", "0.0.0.0:#{port_set['external']}:#{port_set['internal']}"]
-    end
-    [ "--detach", "--tty",
-      "--name",   container_name,
-      "--volume", "#{external_data_path}:#{internal_data_path}:rw",
-      "--volume", "#{external_conf_path}:#{internal_conf_path}:rw",
-      "--volume", "#{external_sock_path}:#{internal_sock_path}:rw",
-      "--volume", "#{external_logs_path}:#{internal_logs_path}:rw",
-      "--restart", "always",
-      ports_options,
-      image_name
-    ].flatten
-  end
-
-  def local_templates_path
-    "templates/nginx"
-  end
-
-  def local_site_templates_path
-    "#{local_templates_path}/sites-enabled"
-  end
-
-end