vagrant-reverse-proxy 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58327c38d18a0e56fe6daaf3614ad13b748aee25
-  data.tar.gz: ab5b2297ac9c441bfe7f25c8efa6a3efd8dff978
+  metadata.gz: fc6bfbd2be5d73661529df41828a6f2bdbfacdc3
+  data.tar.gz: e3aad94f72a27c83b4c9cf4838109680ebb2d1fc
 SHA512:
-  metadata.gz: c2edcff7ab0cd85ee985c67aacbf3ce5f62079cb190c15761ca2ccfcf9491fff712a2a5a72a34ce89e3247e31413ed5189b241d566d12d34890a8d50619db9e1
-  data.tar.gz: 7207d37dfa085633b7a528cd5b6eb9d0a7b6df2af8ba78f082f8333a452ec9488a46703246f98cef72024d57dddabbe2e79d55565a503c9053f943e23d70ee7e
+  metadata.gz: 444eb3425dcea8535e3ee9bdbb9e9b305438f209829c3c90c317e7315188612ee210b0b1d0519d0e62357d5925c52bed4a8fb7970e3dd7161aa6a98c5d916802
+  data.tar.gz: 047e6b869a09fb2a68a59227243943eb1850c48924a022027f93e34461c8b1e5ca7b446d0f8fea7dfff6a274abc450b1aaf2809a7f8a992f50b6e91ae2d1057d

data/README.md

@@ -25,18 +25,19 @@ Install the plugin as usual:
 
 First, install NGINX and create a configuration as usual.  Then, in
 the `server` configuration block for the host you want to use for
-proxying, simply put `include "vagrant-proxy-config";` in the file.
+proxying, simply put `include "vagrant-proxy-config-locations";` in the file.
 
 If you don't need anything specific, just put the following in
 `/etc/nginx/sites-enabled/default`:
 
     server {
-        listen [::]:80 default ipv6only=off;
+        listen 80 default;
+        listen [::]:80 default;
         # This is the fallback server
         server_name default;
         # Redirect http://localhost/hostname/lalala
         # to http://hostname/lalala
-        include "vagrant-proxy-config";
+        include "vagrant-proxy-config-locations";
     }
 
 This will load the `/etc/nginx/vagrant-proxy-config` file which is
@@ -46,9 +47,21 @@ proxy to port 80 on the virtual machine with a `config.vm.hostname`
 value of `foo`.  This is only done for virtual machines that have
 `config.reverse_proxy.enabled` set to `true` in their config.
 
-Whenever you bring up or halt a machine, the plugin updates the proxy
-config file and invokes `sudo systemctl reload nginx` to make the
-change immediately visible.
+#### Server Blocks
+
+The plugin also writes `server` block configuration for the enabled
+VMs so that they can be accessed directly via their hostname (as long
+as the hostname resolves to the host machine's IP address).
+
+To include these, simply include the generated file inside your main NGINX `http` block:
+
+    http {
+        include "vagrant-proxy-config-servers";
+    }
+
+
+Whenever you bring up, halt, or reload a machine, the plugin updates the proxy
+config files and invokes `sudo nginx -s reload` to make the change immediately visible.
 
 ### Custom host names
 
@@ -72,15 +85,25 @@ an array:
 As you can see, this allows you to define which port to connect to
 instead of the default port (which is port 80).
 
-### Specifying the NGINX configuration file path
+### Specifying the NGINX configuration file paths
+
+If you want to change the location of the managed NGINX configuration
+files, set the `config.reverse_proxy.nginx_locations_config_file` or
+`config.reverse_proxy.nginx_servers_config_file` values to paths on
+your host machine in the Vagrantfile configuration:
 
-If you want to change the location of the managed nginx configuration file, set the `config.reverse_proxy.nginx_config_file` value to a path on your host machine in the Vagrantfile configuration:
+    config.reverse_proxy.nginx_locations_config_file = '/usr/local/etc/nginx/vagrant-proxy-config-locations'
+    config.reverse_proxy.nginx_servers_config_file = '/usr/local/etc/nginx/vagrant-proxy-config-servers'
 
-    config.reverse_proxy.nginx_config_file = '/usr/local/etc/nginx/vagrant-proxy-config'
+If you don't want to generate one of the locations or server configuration files, set the appropriate config value to `nil`.
 
 ### Specifying the NGINX reload command
 
-After the NGINX configuration file is generated, a reload command is executed so that the changes take effect. By default the command executed is `sudo nginx -s reload`. If you need to change this, set the `config.reverse_proxy.nginx_reload_command` option to the command to be executed:
+After the NGINX configuration file is generated, a reload command is
+executed so that the changes take effect. By default the command
+executed is `sudo nginx -s reload`. If you need to change this, set
+the `config.reverse_proxy.nginx_reload_command` option to the command
+to be executed:
 
     config.reverse_proxy.nginx_reload_command = 'sudo service nginx reload'
 
@@ -113,6 +136,11 @@ add a bit of custom code there if you need to override the base URL.
 
 ## Changelog
 
+- 0.4.0 Add support for `vagrant reload`, add support for host-based instead
+  of location-based dispatching (both thanks to Sam Stevens). NOTE: This is a
+  backwards incompatible change: the default name of the config file has
+  changed, so you must update the `include` statement in your NGINX config.
+- 0.3.1 Allow overriding the NGINX reload command (thanks to Sam Stevens).
 - 0.3 Allow overriding the location of the NGINX configuration file
   (thanks to Sam Stevens).  Support multiple VMs in a single Vagrant
   config (suggested by Nicholas Alipaz).

data/lib/vagrant-reverse-proxy/action/write_nginx_config.rb

@@ -10,26 +10,39 @@ module VagrantPlugins
         def call(env)
           @app.call(env)
 
+          # Get the plugin config for the machine
+          rp_config = env[:machine].config.reverse_proxy
+
           # Does this make much sense?  What if we disable it later
           # for one specific machine?  Then, the config should still
           # be removed.
-          return unless env[:machine].config.reverse_proxy.enabled?
+          return unless rp_config.enabled?
+
+          env[:ui].info('Updating nginx configuration. Administrator privileges will be required...')
+
+          # Generate the config files
+          generate_config_file(env, rp_config.nginx_locations_config_file, location_block(env[:machine]))
+          generate_config_file(env, rp_config.nginx_servers_config_file, server_block(env[:machine]))
+
+          # And reload nginx
+          nginx_reload_command = rp_config.nginx_reload_command || 'sudo nginx -s reload'
+          Kernel.system(nginx_reload_command)
+        end
 
-          # Determine temp file and target file
-          nginx_config_file = env[:machine].config.reverse_proxy.nginx_config_file || '/etc/nginx/vagrant-proxy-config'
+        def generate_config_file(env, target_file, config_block)
 
-          # Get the directory of the config file
-          nginx_config_dir = File.dirname(nginx_config_file)
+          return unless target_file
 
-          unless File.directory?(nginx_config_dir)
-            env[:ui].error("Could not update nginx configuration: directory '#{nginx_config_dir}' does not exist.  Continuing without proxy...")
+          # Get the directory of the file being written to
+          file_dir = File.dirname(target_file)
+
+          unless File.directory?(file_dir)
+            env[:ui].error("Could not update nginx configuration file '#{target_file}' : directory '#{file_dir}' does not exist. Continuing...")
             return
           end
 
           tmp_file = env[:machine].env.tmp_path.join('nginx.vagrant-proxies')
 
-          env[:ui].info('Updating nginx configuration. Administrator privileges will be required...')
-
           sm = start_marker(env[:machine])
           em = end_marker(env[:machine])
 
@@ -39,7 +52,7 @@ module VagrantPlugins
           # changed, and might not have been present originally.
           File.open(tmp_file, 'w') do |new|
             begin
-              File.open(nginx_config_file, 'r') do |old|
+              File.open(target_file, 'r') do |old|
                 # First, remove old entries for this machine.
                 while ln = old.gets() do
                   if sm == ln.chomp
@@ -61,20 +74,17 @@ module VagrantPlugins
             if @action == :add # Removal is already (always) done above
               # Write the config for this machine
               if env[:machine].config.reverse_proxy.enabled?
-                new.write(sm+"\n"+server_block(env[:machine])+em+"\n")
+                new.write(sm+"\n"+config_block+em+"\n")
               end
             end
           end
 
           # Finally, copy tmp config to actual config
-          Kernel.system('sudo', 'cp', tmp_file.to_s, nginx_config_file)
+          Kernel.system('sudo', 'cp', tmp_file.to_s, target_file)
 
-          # And reload nginx
-          nginx_reload_command = env[:machine].config.reverse_proxy.nginx_reload_command || 'sudo nginx -s reload'
-          Kernel.system(nginx_reload_command)
         end
 
-        def server_block(machine)
+        def location_block(machine)
           if machine.config.reverse_proxy.vhosts
             vhosts = machine.config.reverse_proxy.vhosts
           else
@@ -92,6 +102,8 @@ location /#{path}/ {
     proxy_set_header X-Forwarded-For $remote_addr;
     proxy_set_header X-Forwarded-Host $host;
     proxy_set_header X-Forwarded-Port $server_port;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-Proto $scheme;
     proxy_set_header X-Base-Url http://$host:$server_port/#{path}/;
 
     proxy_pass http://#{ip}#{port_suffix}/;
@@ -101,6 +113,40 @@ EOF
           end.join("\n")
         end
 
+        def server_block(machine)
+          if machine.config.reverse_proxy.vhosts
+            vhosts = machine.config.reverse_proxy.vhosts
+          else
+            host = machine.config.vm.hostname || machine.name
+            vhosts = {host => host}
+          end
+          ip = get_ip_address(machine)
+          vhosts.collect do |path, vhost|
+            # Rewrites are matches literally by nginx, which means
+            # http://host:80/... will NOT match http://host/...!
+            port_suffix = vhost[:port] == 80 ? '' : ":#{vhost[:port]}"
+            <<EOF
+server {
+    listen 80;
+    listen [::]:80;
+    listen 443 ssl;
+    listen [::]:443 ssl;
+
+    server_name #{path};
+    location / {
+        proxy_set_header Host #{vhost[:host]};
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Host $host;
+        proxy_set_header X-Forwarded-Port $server_port;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_pass http://#{ip}#{port_suffix}/;
+    }
+}
+EOF
+          end.join("\n")
+        end
+
         def start_marker(m)
           "# BEGIN #{m.id} #"
         end

data/lib/vagrant-reverse-proxy/config.rb

@@ -2,13 +2,14 @@ module VagrantPlugins
   module ReverseProxy
     class Plugin
       class Config < Vagrant.plugin(2, :config)
-        attr_accessor :enabled, :vhosts, :nginx_config_file, :nginx_reload_command
+        attr_accessor :enabled, :vhosts, :nginx_locations_config_file, :nginx_servers_config_file, :nginx_reload_command
         alias_method :enabled?, :enabled
 
         def initialize
           @enabled = UNSET_VALUE
           @vhosts = UNSET_VALUE
-          @nginx_config_file = UNSET_VALUE
+          @nginx_locations_config_file = UNSET_VALUE
+          @nginx_servers_config_file = UNSET_VALUE
           @nginx_reload_command = UNSET_VALUE
         end
 
@@ -31,8 +32,11 @@ module VagrantPlugins
               end
             end
           end
-          if @nginx_config_file == UNSET_VALUE
-            @nginx_config_file = nil
+          if @nginx_locations_config_file == UNSET_VALUE
+            @nginx_locations_config_file = '/etc/nginx/vagrant-proxy-config-locations'
+          end
+          if @nginx_servers_config_file == UNSET_VALUE
+            @nginx_servers_config_file = '/etc/nginx/vagrant-proxy-config-servers'
           end
           if @nginx_reload_command == UNSET_VALUE
             @nginx_reload_command = nil
@@ -69,8 +73,16 @@ module VagrantPlugins
             errors << 'vhosts must be an array of hostnames, a string=>string hash or nil'
           end
 
-          unless @nginx_config_file.instance_of?(String) || @nginx_config_file == nil || @nginx_config_file == UNSET_VALUE
-            errors << 'nginx_config_file must be a string'
+          unless @nginx_locations_config_file.instance_of?(String) || @nginx_locations_config_file == nil || @nginx_locations_config_file == UNSET_VALUE
+            errors << 'nginx_locations_config_file must be a string'
+          end
+
+          unless @nginx_servers_config_file.instance_of?(String) || @nginx_servers_config_file == nil || @nginx_servers_config_file == UNSET_VALUE
+            errors << 'nginx_servers_config_file must be a string'
+          end
+
+          if @nginx_locations_config_file == nil && @nginx_servers_config_file == nil
+            errors << 'only one of nginx_locations_config_file and nginx_servers_config_file can be nil'
           end
 
           unless @nginx_reload_command.instance_of?(String) || @nginx_reload_command == nil || @nginx_reload_command == UNSET_VALUE

data/lib/vagrant-reverse-proxy/plugin.rb

@@ -32,6 +32,10 @@ module VagrantPlugins
       action_hook(:reverse_proxy, :machine_action_halt) do |hook|
         hook.append(Action.remove_machine)
       end
+
+      action_hook(:reverse_proxy, :machine_action_reload) do |hook|
+        hook.append(Action.add_machine)
+      end
     end
   end
 end

data/lib/vagrant-reverse-proxy/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module ReverseProxy
-    VERSION = "0.3.1"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-reverse-proxy
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Peter Bex
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-22 00:00:00.000000000 Z
+date: 2016-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler