vagrant-proxyconf 1.5.2 → 2.0.1

data/lib/vagrant-proxyconf/action.rb

@@ -31,13 +31,16 @@ module VagrantPlugins
       def self.configure_after_provisoner
         Vagrant::Action::Builder.new.tap do |b|
           b.use Builtin::Call, IsEnabled do |env, b2|
-            next if !env[:result]
+            # next if !env[:result]
 
-            b2.use ConfigureDockerProxy
-            b2.use ConfigureGitProxy
-            b2.use ConfigureNpmProxy
-            b2.use ConfigurePearProxy
-            b2.use ConfigureSvnProxy
+            # TODO: Do we really need to configure only specific proxies after the provisioner runs?
+            #       Shouldn't they already be configured by this point?
+            #       Cody Lane - Dec 2018
+            # b2.use ConfigureDockerProxy
+            # b2.use ConfigureGitProxy
+            # b2.use ConfigureNpmProxy
+            # b2.use ConfigurePearProxy
+            # b2.use ConfigureSvnProxy
           end
         end
       end
@@ -49,8 +52,13 @@ module VagrantPlugins
       def self.config_actions
         @config_actions ||= Proc.new do |b|
           b.use Builtin::Call, IsEnabled do |env, b2|
-            next if !env[:result]
+            # next if !env[:result]
 
+            # IsEnabled doesn't seem to be quiet right becuse it only seems to check if the proxy has been disabled
+            # globally which isn't always what we want. We don't want to skip configuring a service or services
+            # because of a disable toggle. Instead we defer to each action class because the implementation for
+            # skipping over a service or checking if it is disabled is implmeneted there. To be more clear the real
+            # implementation is actually in action/base.rb#call
             b2.use ConfigureAptProxy
             b2.use ConfigureChefProxy
             b2.use ConfigureDockerProxy

data/lib/vagrant-proxyconf/action/base.rb

@@ -14,10 +14,15 @@ module VagrantPlugins
         def call(env)
           @machine = env[:machine]
 
-          if disabled? || !config.enabled?
-            logger.info I18n.t("vagrant_proxyconf.#{config_name}.not_enabled")
+          if skip?
+            logger.info I18n.t("vagrant_proxyconf.#{config_name}.skip")
+            env[:ui].info I18n.t("vagrant_proxyconf.#{config_name}.skip")
           elsif !supported?
             logger.info I18n.t("vagrant_proxyconf.#{config_name}.not_supported")
+          elsif disabled?
+            logger.info I18n.t("vagrant_proxyconf.#{config_name}.not_enabled")
+            env[:ui].info I18n.t("vagrant_proxyconf.#{config_name}.unconfiguring") if supported?
+            unconfigure_machine
           else
             env[:ui].info I18n.t("vagrant_proxyconf.#{config_name}.configuring")
             configure_machine
@@ -66,6 +71,10 @@ module VagrantPlugins
           write_config(config)
         end
 
+        # Unconfigures the VM, expected to be added to overriden
+        def unconfigure_machine
+        end
+
         # Writes the config to the VM
         #
         # @param opts [Hash] optional file options
@@ -109,16 +118,49 @@ module VagrantPlugins
         def disabled?
           enabled = @machine.config.proxy.enabled
           return true if enabled == false || enabled == ''
+          return false if enabled == true
+
+          app_name = config_name.gsub(/_proxy/, '').to_sym
+
+          if enabled.respond_to?(:key)
+            return false if enabled.has_key?(app_name) == false
+
+            # if boolean value, return original behavior as mentioned in Readme
+            return enabled[app_name] == false if [true, false].include?(enabled[app_name])
+
+            return false if enabled[app_name].has_key?(:skip) == false
+
+            # otherwise assume new behavior using :enabled as a new hash key
+            return enabled[app_name][:enabled] == false
+          end
+
+          false
+        end
+
+        def skip?
+          enabled = @machine.config.proxy.enabled
+          return true if enabled == false || enabled == ''
+          return false if enabled == true
 
           app_name = config_name.gsub(/_proxy/, '').to_sym
-          return enabled[app_name] == false if enabled.respond_to?(:key)
+
+          if enabled.respond_to?(:key)
+            return false if enabled.has_key?(app_name) == false
+
+            # if boolean value, return original behavior as mentioned in Readme
+            return enabled[app_name] == false if [true, false].include?(enabled[app_name])
+
+            return false if enabled[app_name].has_key?(:skip) == false
+
+            # otherwise assume new behavior using :enabled as a new hash key
+            return enabled[app_name][:skip] == true
+          end
 
           false
         end
 
         def supported?
-          @machine.guest.capability?(cap_name) &&
-            @machine.guest.capability(cap_name)
+          @machine.guest.capability?(cap_name) && @machine.guest.capability(cap_name)
         end
 
         def config_path

data/lib/vagrant-proxyconf/action/configure_apt_proxy.rb

@@ -8,6 +8,23 @@ module VagrantPlugins
         def config_name
           'apt_proxy'
         end
+
+        private
+
+        def unconfigure_machine
+          if !supported?
+            logger.info "apt_proxy is not supported on '#{@machine.guest.name}'"
+            return false
+          end
+
+          logger.info "apt_proxy is supported on '#{@machine.guest.name}'"
+
+          # if we get here then machine should support unconfiguring
+          @machine.communicate.sudo("rm -f #{config_path}")
+
+          true
+        end
+
       end
     end
   end

data/lib/vagrant-proxyconf/action/configure_chef_proxy.rb

@@ -1,48 +1,34 @@
 require_relative '../logger'
 require_relative '../userinfo_uri'
+require_relative 'base'
 
 module VagrantPlugins
   module ProxyConf
     class Action
       # Action for configuring Chef provisioners
-      class ConfigureChefProxy
+      class ConfigureChefProxy < Base
 
         # Array of Chef provisioner types which include proxy configuration
         CHEF_PROVISIONER_TYPES = [:chef_client, :chef_solo, :chef_zero]
 
-        def initialize(app, env)
-          @app = app
+        def config_name
+          'chef_proxy'
         end
 
-        def call(env)
-          @machine = env[:machine]
-
-          if chef_provisioners.empty?
-            logger.info I18n.t("vagrant_proxyconf.chef_proxy.no_provisioners")
-          elsif !config.enabled?
-            logger.info I18n.t("vagrant_proxyconf.chef_proxy.not_enabled")
-          else
-            env[:ui].info I18n.t("vagrant_proxyconf.chef_proxy.configuring")
-            configure_chef_provisioners
-          end
+        private
 
-          @app.call env
+        def configure_machine
+          configure_chef_provisioners
         end
 
-        private
+        def unconfigure_machine
+          configure_chef_provisioners
 
-        # @return [Log4r::Logger]
-        def logger
-          ProxyConf.logger
+          true
         end
 
-        # @return [Config::Proxy] the `config.proxy` configuration
-        def config
-          return @config if @config
-
-          config = @machine.config.proxy
-          config.finalize! if Gem::Version.new(Vagrant::VERSION) < Gem::Version.new('1.2.5')
-          @config = config
+        def supported?
+          super && !chef_provisioners.empty?
         end
 
         # @return [Array] all Chef provisioners
@@ -67,6 +53,14 @@ module VagrantPlugins
         #
         # @param chef [VagrantPlugins::Chef::Config::Base] the Chef provisioner configuration
         def configure_chef(chef)
+          if disabled?
+            logger.info("chef_proxy is not enabled so we should unconfigure it")
+            unconfigure_chef_proxy(chef, 'http')
+            unconfigure_chef_proxy(chef, 'https')
+            return
+          end
+
+          logger.info("chef_proxy is enabled so we should configure it")
           configure_chef_proxy(chef, 'http', config.http)
           configure_chef_proxy(chef, 'https', config.https)
           chef.no_proxy ||= config.no_proxy if config.no_proxy
@@ -76,13 +70,24 @@ module VagrantPlugins
         # @param scheme [String] the http protocol (http or https)
         # @param uri [String] the URI with optional userinfo
         def configure_chef_proxy(chef, scheme, uri)
-          if uri && !chef.public_send("#{scheme}_proxy")
+          if uri && !chef.public_send("#{scheme}_proxy") && !disabled?
             u = UserinfoURI.new(uri)
             chef.public_send("#{scheme}_proxy_user=", u.user)
             chef.public_send("#{scheme}_proxy_pass=", u.pass)
             chef.public_send("#{scheme}_proxy=", u.uri)
+            logger.info("chef_proxy has been successfully configured")
           end
         end
+
+        # @param chef [VagrantPlugins::Chef::Config::Base] the Chef provisioner configuration
+        # @param scheme [String] the http protocol (http or https)
+        def unconfigure_chef_proxy(chef, scheme)
+          chef.public_send("#{scheme}_proxy_user=", nil)
+          chef.public_send("#{scheme}_proxy_pass=", nil)
+          chef.public_send("#{scheme}_proxy=", nil)
+          chef.no_proxy = nil
+          logger.info("chef_proxy has been successfully unconfigured")
+        end
       end
     end
   end

data/lib/vagrant-proxyconf/action/configure_docker_proxy.rb

@@ -13,15 +13,100 @@ module VagrantPlugins
 
         private
 
-        def config
-          # Use global proxy config
-          @config ||= finalize_config(@machine.config.proxy)
-        end
-
         def configure_machine
+          return if !supported?
+
           logger.info('Writing the proxy configuration to docker config')
           detect_export
           write_docker_config
+          update_docker_client_config
+
+          true
+        end
+
+        def unconfigure_machine
+          return if !supported?
+
+          config.http = nil
+          config.https = nil
+          config.no_proxy = nil
+
+          write_docker_config
+          update_docker_client_config
+
+          true
+        end
+
+        def docker_client_config_path
+          return @docker_client_config_path if @docker_client_config_path
+          return if !supports_config_json?
+
+          @docker_client_config_path = tempfile(Hash.new)
+
+          @machine.communicate.tap do |comm|
+            if comm.test("[ -f /etc/docker/config.json ]")
+              logger.info('Downloading file /etc/docker/config.json')
+              comm.sudo("chmod 0644 /etc/docker/config.json")
+              comm.download("/etc/docker/config.json", @docker_client_config_path.path)
+              logger.info("Downloaded /etc/docker/config.json to #{@docker_client_config_path.path}")
+            end
+          end
+
+          @docker_client_config_path = @docker_client_config_path.path
+        end
+
+        def update_docker_client_config
+          return if !supports_config_json? || !docker_client_config_path
+
+          content = File.read(@docker_client_config_path)
+          data  = JSON.load(content)
+
+          if disabled?
+            data['proxies'] = {
+              'default' => {}
+            }
+          else
+
+            data['proxies'] = {} unless data.key?('proxies')
+            data['proxies']['default'] = {} unless data['proxies'].key?('default')
+
+            data['proxies']['default'].delete('httpProxy')
+            data['proxies']['default'].delete('httpsProxy')
+            data['proxies']['default'].delete('noProxy')
+
+            unless config.http == false || config.http == "" || config.http.nil?
+              data['proxies']['default']['httpProxy'] = config.http
+            end
+
+            unless config.https == false || config.https == "" || config.https.nil?
+              data['proxies']['default']['httpsProxy'] = config.https
+            end
+
+            unless config.no_proxy == false || config.no_proxy == "" || config.no_proxy.nil?
+              data['proxies']['default']['noProxy'] = config.no_proxy
+            end
+
+          end
+
+          config_json = JSON.pretty_generate(data)
+
+          @docker_client_config_path = tempfile(config_json)
+
+          @machine.communicate.tap do |comm|
+            comm.upload(@docker_client_config_path.path, "/tmp/vagrant-proxyconf-docker-config.json")
+            comm.sudo("mkdir -p /etc/docker")
+            comm.sudo("chown root:root /etc/docker")
+            comm.sudo("mv /tmp/vagrant-proxyconf-docker-config.json /etc/docker/config.json")
+            comm.sudo("chown root:root /etc/docker/config.json")
+            comm.sudo("rm -f /tmp/vagrant-proxyconf-docker-config.json")
+
+            comm.sudo("sed -i.bak -e '/^DOCKER_CONFIG/d' /etc/environment")
+            if !disabled?
+              comm.sudo("echo DOCKER_CONFIG=/etc/docker >> /etc/environment")
+            end
+          end
+
+          config_json
         end
 
         def docker
@@ -32,13 +117,39 @@ module VagrantPlugins
           end
         end
 
+        def docker_version
+          return if !supported?
+          return @version if @version
+
+          @version = nil
+          @machine.communicate.execute('docker --version') do |type, data|
+            version = data.sub(',', '').split(' ').select {|i| i.match /^\d+\.\d+/}
+            @version = version[0].split(".").map {|i| i.to_i} unless version.empty?
+          end
+
+          return @version
+        end
+
+        def supports_config_json?
+          return false if !supported? || !docker_version
+
+          major, minor, patch = @version
+
+          # https://docs.docker.com/network/proxy/#configure-the-docker-client
+          # if docker version >= 17.07 it supports config.json
+          return true if major >= 17 && minor >= 7
+
+          # docker version < 17.07 so it does not support config.json
+          return false
+        end
+
         def write_docker_config
           tmp = "/tmp/vagrant-proxyconf"
           path = config_path
 
           @machine.communicate.tap do |comm|
             sed_script = docker_sed_script
-            local_tmp = tempfile(docker_config)
+            local_tmp = !disabled? ? tempfile(docker_config) : tempfile("")
 
             comm.sudo("rm -f #{tmp}", error_check: false)
             comm.upload(local_tmp.path, tmp)
@@ -62,31 +173,38 @@ module VagrantPlugins
 
         def detect_export
           @machine.communicate.tap do |comm|
-            comm.test('which systemctl') ? @export = '' : @export = 'export '
+            comm.test('command -v systemctl') ? @export = '' : @export = 'export '
           end
         end
 
         def service_restart_command
-          ["systemctl restart #{docker}",
+          [
+            "kill -HUP `pgrep -f '#{docker}'`",
+            "systemctl restart #{docker}",
             "service #{docker} restart",
-            "/etc/init.d/#{docker} restart"].join(' || ')
+            "/etc/init.d/#{docker} restart",
+          ].join(' || ')
         end
 
         def docker_sed_script
           <<-SED.gsub(/^\s+/, '')
             /^#{@export}HTTP_PROXY=/ d
-            /^#{@export}NO_PROXY=/ d
             /^#{@export}http_proxy=/ d
+            /^#{@export}HTTPS_PROXY=/ d
+            /^#{@export}https_proxy=/ d
+            /^#{@export}NO_PROXY=/ d
             /^#{@export}no_proxy=/ d
           SED
         end
 
         def docker_config
           <<-CONFIG.gsub(/^\s+/, '')
-            #{@export}HTTP_PROXY=#{config.http || ''}
-            #{@export}NO_PROXY=#{config.no_proxy || ''}
-            #{@export}http_proxy=#{config.http || ''}
-            #{@export}no_proxy=#{config.no_proxy || ''}
+            #{@export}HTTP_PROXY=\"#{config.http || ''}\"
+            #{@export}http_proxy=\"#{config.http || ''}\"
+            #{@export}HTTPS_PROXY=\"#{config.https || ''}\"
+            #{@export}https_proxy=\"#{config.https || ''}\"
+            #{@export}NO_PROXY=\"#{config.no_proxy || ''}\"
+            #{@export}no_proxy=\"#{config.no_proxy || ''}\"
           CONFIG
         end
       end

data/lib/vagrant-proxyconf/action/configure_env_proxy.rb

@@ -23,11 +23,30 @@ module VagrantPlugins
           end
         end
 
+        def unconfigure_machine
+          if windows_guest?
+            raise NotImplementedError, 'Sorry but I do not know how to disable a windows proxy yet, please open a feature request'
+          end
+
+          logger.info('Unconfiguring and or removing proxy configuration files')
+          unconfigure_linux
+        end
+
+        def unconfigure_linux
+          @machine.communicate.tap do |comm|
+            comm.sudo("rm -f /etc/sudoers.d/proxy")
+            comm.sudo("rm -f #{config_path}")
+          end
+
+          write_environment_config
+        end
+
         def configure_machine_windows
           set_windows_proxy('http_proxy', config.http)
           set_windows_proxy('https_proxy', config.https)
           set_windows_proxy('ftp_proxy', config.ftp)
           set_windows_proxy('no_proxy', config.no_proxy)
+          set_windows_system_proxy(config.http)
         end
 
         def set_windows_proxy(key, value)
@@ -40,6 +59,26 @@ module VagrantPlugins
           end
         end
 
+        def set_windows_system_proxy(proxy)
+          if proxy
+            path    = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"
+
+            proxy1  = "cmd.exe /C reg add \"#{path}\" /v ProxyEnable   /t REG_DWORD /d 1                          /f"
+            proxy2  = "cmd.exe /C reg add \"#{path}\" /v ProxyServer   /t REG_SZ    /d #{config.http.inspect}     /f"
+            proxy3  = "cmd.exe /C reg add \"#{path}\" /v ProxyOverride /t REG_SZ    /d #{config.no_proxy.inspect} /f"
+            proxy4  = "cmd.exe /C reg add \"#{path}\" /v AutoDetect    /t REG_DWORD /d 0                          /f"
+
+            logger.info('Setting system proxy settings')
+
+            @machine.communicate.sudo(proxy1)
+            @machine.communicate.sudo(proxy2)
+            @machine.communicate.sudo(proxy3)
+            @machine.communicate.sudo(proxy4)
+          else
+            logger.info("Not setting system proxy settings")
+          end
+        end
+
         def windows_guest?
           @machine.config.vm.guest.eql?(:windows)
         end
@@ -62,13 +101,15 @@ module VagrantPlugins
             comm.sudo("rm -f #{tmp}", error_check: false)
             comm.upload(local_tmp.path, tmp)
             comm.sudo("touch #{path}")
-            comm.sudo("sed -e '#{sed_script}' #{path} > #{path}.new")
+            comm.sudo("sed -e '#{sed_script}' -e '/^$/d' #{path} > #{path}.new")
             comm.sudo("cat #{tmp} >> #{path}.new")
             comm.sudo("chmod 0644 #{path}.new")
             comm.sudo("chown root:root #{path}.new")
             comm.sudo("mv -f #{path}.new #{path}")
             comm.sudo("rm -f #{tmp}")
           end
+
+          true
         end
 
         def environment_sed_script
@@ -85,16 +126,22 @@ module VagrantPlugins
         end
 
         def environment_config
-          <<-CONFIG.gsub(/^\s+/, '')
-            HTTP_PROXY=#{config.http || ''}
-            HTTPS_PROXY=#{config.https || ''}
-            FTP_PROXY=#{config.ftp || ''}
-            NO_PROXY=#{config.no_proxy || ''}
-            http_proxy=#{config.http || ''}
-            https_proxy=#{config.https || ''}
-            ftp_proxy=#{config.ftp || ''}
-            no_proxy=#{config.no_proxy || ''}
-          CONFIG
+          return "" if disabled?
+
+          env_config = Hash.new
+          env_config["FTP_PROXY"]   = config.ftp if config.ftp
+          env_config["HTTP_PROXY"]  = config.http if config.http
+          env_config["HTTPS_PROXY"] = config.https if config.https
+          env_config["NO_PROXY"]    = config.no_proxy if config.no_proxy
+
+          config_items = env_config.map do |k,v|
+            <<-CONFIG.gsub(/^\s+/, '')
+              #{k.upcase}="#{v}"
+              #{k.downcase}="#{v}"
+            CONFIG
+          end
+
+          config_items.join("\n")
         end
       end
     end