vagrant-unbundled 2.0.4.0 → 2.1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f05389ae1ff4023e08b4a240e16afc13f24fb766254196f09ce91cf0f0c70b4
-  data.tar.gz: e76853469f4db645991f1b98bebca28cffc1cbfbe4d29f4c11033dc1e1099ce4
+  metadata.gz: 7b7d6c7467de5bfab5f4e3503f8cc1dab8ef0917a3373c3c42bda4519e86c0f3
+  data.tar.gz: c7912ae83539b93705099b5daad5481f247ed8b8abc9bee8ef996c8ccd58cb79
 SHA512:
-  metadata.gz: 499aa7f81c240e7b9e313ffc2dc2f6c9d85a8d0b06d8582e16fb05e5b6b762a56b35ba3c738bfb506fb7f085048a4c239dd47861b25cd1c949d214618e68e43a
-  data.tar.gz: e1dede9125879c569429a21d1c4f698f2d13c8cbad9bc84616a5a784ddfb30dce10ade705bbc1a0bf408fbe2ea23ae97ede54b44de71c942b4f1c8c1c004a131
+  metadata.gz: b0374c64f53956fff0665b76baf2ff155f299b60d87664b7eb6d9f7cbae9fb53b6e1cd3f1a02d04a98555de4a4e708d70b21ea12a31a7c0a8530d050be6c9000
+  data.tar.gz: 8be3443a6d1a51a4f8c7ddd86aeb6deb839dfe5f63dde7fe209a6dcd9c5ab2884fe2ebc193d2d3706702a3a0d22d2af1253294eb9f8a72921c31d0e9f875be09

data/CHANGELOG.md

@@ -1,3 +1,46 @@
+## 2.1.1 (May 7, 2018)
+
+IMPROVEMENTS:
+
+- guest/linux: Support builtin vboxsf module for shared folders [GH-9800]
+- host/windows: Update SMB capability to work without Get-SmbShare cmdlet [GH-9785]
+
+BUG FIXES:
+
+- core/triggers: Initialize internal trigger object for machine before initializing provider [GH-9784]
+- core/triggers: Ensure internal trigger fire does not get called if plugin installed [GH-9799]
+- provider/hyperv: Call import script with switchid instead of switchname [GH-9781]
+
+## 2.1.0 (May 3, 2018)
+
+FEATURES:
+
+- core: Integrate vagrant-triggers plugin functionality into core Vagrant [GH-9713]
+
+IMPROVEMENTS:
+
+- core: Improve messaging around not finding requested provider [GH-9735]
+- core: Disable exception reports by default [GH-9738]
+- core: Continue on if vagrant fails to parse metadata box for update [GH-9760]
+- hosts/linux: Support RDP capability within WSL [GH-9758]
+- hosts/windows: Add SMB default mount options capability and set default version to 2.0 [GH-9734]
+- provider/hyperv: Include neighbor check for MAC on guest IP detection [GH-9737]
+- provider/virtualbox: Do not require VirtualBox availability within WSL [GH-9759]
+- provisioner/chef_zero: Support arrays for data_bags_path [GH-9669]
+- util/downloader: Don't raise error if response is HTTP 416 [GH-9729]
+- util/platform: Update Hyper-V enabled check [GH-9746]
+
+BUG FIXES:
+
+- communicators/ssh: Log error and proceed on Windows private key permissions [GH-9769]
+- middleware/authentication: Prevent URL modification when no changes are required [GH-9730]
+- middleware/authentication: Ignore URLs which cannot be parsed [GH-9739]
+- provider/hyperv: Reference switches by ID instead of name [GH-9747]
+- provider/docker: Use Util::SafeExec if docker-exec is run with `-t` option [GH-9761]
+- provisioner/chef: Trim drive letter from path on Windows [GH-9766]
+- provisioner/puppet: Properly finalize structured_facts config option [GH-9720]
+- util/platform: Fix original WSL to Windows path for "root" directory [GH-9696]
+
 ## 2.0.4 (April 20, 2018)
 
 FEATURES:

data/Gemfile.lock

@@ -11,7 +11,7 @@ GIT
 PATH
   remote: .
   specs:
-    vagrant-unbundled (2.0.4.0)
+    vagrant-unbundled (2.1.1.0)
       childprocess (~> 0.6.0)
       erubis (~> 2.7.0)
       hashicorp-checkpoint (~> 0.1.5)
@@ -160,4 +160,4 @@ DEPENDENCIES
   webmock (~> 2.3.1)
 
 BUNDLED WITH
-   1.16.1
+   1.16.2

data/bin/vagrant

@@ -5,6 +5,11 @@
 # initializing which have historically resulted in stack traces.
 Signal.trap("INT") { abort }
 
+# Disable exception reporting by default if available
+if Thread.respond_to?(:report_on_exception=)
+  Thread.report_on_exception = false
+end
+
 # Split arguments by "--" if its there, we'll recombine them later
 argv = ARGV.dup
 argv_extra = []

data/lib/vagrant/action/builtin/box_check_outdated.rb

@@ -58,6 +58,9 @@ module Vagrant
             env[:ui].warn(I18n.t(
               "vagrant.box_outdated_metadata_download_error",
               message: e.extra_data[:message]))
+          rescue Errors::BoxMetadataMalformed  => e
+            @logger.warn(e.to_s)
+            env[:ui].warn(I18n.t("vagrant.box_malformed_continue_on_update"))
           rescue Errors::VagrantError => e
             raise if !env[:box_outdated_ignore_errors]
             env[:ui].detail(I18n.t(

data/lib/vagrant/errors.rb

@@ -580,6 +580,10 @@ module Vagrant
       error_key(:provider_not_found)
     end
 
+    class ProviderNotFoundSuggestion < VagrantError
+      error_key(:provider_not_found_suggestion)
+    end
+
     class ProviderNotUsable < VagrantError
       error_key(:provider_not_usable)
     end
@@ -776,6 +780,18 @@ module Vagrant
       error_key(:synced_folder_unusable)
     end
 
+    class TriggersGuestNotRunning < VagrantError
+      error_key(:triggers_guest_not_running)
+    end
+
+    class TriggersNoBlockGiven < VagrantError
+      error_key(:triggers_no_block_given)
+    end
+
+    class TriggersNoStageGiven < VagrantError
+      error_key(:triggers_no_stage_given)
+    end
+
     class UIExpectsTTY < VagrantError
       error_key(:ui_expects_tty)
     end
@@ -828,10 +844,6 @@ module Vagrant
       error_key(:vboxmanage_not_found_error)
     end
 
-    class VBoxManageNotFoundWSLError < VagrantError
-      error_key(:vboxmanage_not_found_wsl_error)
-    end
-
     class VirtualBoxBrokenVersion040214 < VagrantError
       error_key(:virtualbox_broken_version_040214)
     end

data/lib/vagrant/machine.rb

@@ -110,6 +110,7 @@ module Vagrant
       @ui              = Vagrant::UI::Prefixed.new(@env.ui, @name)
       @ui_mutex        = Mutex.new
       @state_mutex     = Mutex.new
+      @triggers        = Vagrant::Plugin::V2::Trigger.new(@env, @config.trigger, self)
 
       # Read the ID, which is usually in local storage
       @id = nil
@@ -159,6 +160,11 @@ module Vagrant
     #   as extra data set on the environment hash for the middleware
     #   runner.
     def action(name, opts=nil)
+      plugins = Vagrant::Plugin::Manager.instance.installed_plugins
+      if !plugins.keys.include?("vagrant-triggers")
+        @triggers.fire_triggers(name, :before, @name.to_s)
+      end
+
       @logger.info("Calling action: #{name} on provider #{@provider}")
 
       opts ||= {}
@@ -185,7 +191,7 @@ module Vagrant
       locker = @env.method(:lock) if lock && !name.to_s.start_with?("ssh")
 
       # Lock this machine for the duration of this action
-      locker.call("machine-action-#{id}") do
+      return_env = locker.call("machine-action-#{id}") do
         # Get the callable from the provider.
         callable = @provider.action(name)
 
@@ -203,6 +209,12 @@ module Vagrant
         ui.machine("action", name.to_s, "end")
         action_result
       end
+
+      if !plugins.keys.include?("vagrant-triggers")
+        @triggers.fire_triggers(name, :after, @name.to_s)
+      end
+      # preserve returning environment after machine action runs
+      return return_env
     rescue Errors::EnvironmentLockedError
       raise Errors::MachineActionLockedError,
         action: name,

data/lib/vagrant/plugin/v2/command.rb

@@ -45,7 +45,7 @@ module Vagrant
         def parse_options(opts=nil)
           # make sure optparse doesn't use POSIXLY_CORRECT parsing
           ENV["POSIXLY_CORRECT"] = nil
-          
+
           # Creating a shallow copy of the arguments so the OptionParser
           # doesn't destroy the originals.
           argv = @argv.dup

data/lib/vagrant/plugin/v2/trigger.rb

@@ -0,0 +1,242 @@
+require 'fileutils'
+require 'log4r'
+require 'shellwords'
+
+require Vagrant.source_root.join("plugins/provisioners/shell/provisioner")
+require "vagrant/util/subprocess"
+require "vagrant/util/platform"
+require "vagrant/util/powershell"
+
+module Vagrant
+  module Plugin
+    module V2
+      class Trigger
+        # @return [Kernel_V2::Config::Trigger]
+        attr_reader :config
+
+        # This class is responsible for setting up basic triggers that were
+        # defined inside a Vagrantfile.
+        #
+        # @param [Vagrant::Environment] env Vagrant environment
+        # @param [Kernel_V2::TriggerConfig] config Trigger configuration
+        # @param [Vagrant::Machine] machine Active Machine
+        def initialize(env, config, machine)
+          @env        = env
+          @config     = config
+          @machine    = machine
+
+          @logger = Log4r::Logger.new("vagrant::trigger::#{self.class.to_s.downcase}")
+        end
+
+        # Fires all triggers, if any are defined for the action and guest
+        #
+        # @param [Symbol] action Vagrant command to fire trigger on
+        # @param [Symbol] stage :before or :after
+        # @param [String] guest_name The guest that invoked firing the triggers
+        def fire_triggers(action, stage, guest_name)
+          # get all triggers matching action
+          triggers = []
+          if stage == :before
+            triggers = config.before_triggers.select do |t|
+              t.command == action || (t.command == :all && !t.ignore.include?(action))
+            end
+          elsif stage == :after
+            triggers = config.after_triggers.select do |t|
+              t.command == action || (t.command == :all && !t.ignore.include?(action))
+            end
+          else
+            raise Errors::TriggersNoStageGiven,
+              action: action,
+              stage: stage,
+              guest_name: guest_name
+          end
+
+          triggers = filter_triggers(triggers, guest_name)
+
+          if !triggers.empty?
+            @logger.info("Firing trigger for action #{action} on guest #{guest_name}")
+            @machine.ui.info(I18n.t("vagrant.trigger.start", stage: stage, action: action))
+            fire(triggers, guest_name)
+          end
+        end
+
+        protected
+
+        #-------------------------------------------------------------------
+        # Internal methods, don't call these.
+        #-------------------------------------------------------------------
+
+        # Filters triggers to be fired based on configured restraints
+        #
+        # @param [Array] triggers An array of triggers to be filtered
+        # @param [String] guest_name The name of the current guest
+        # @return [Array] The filtered array of triggers
+        def filter_triggers(triggers, guest_name)
+          # look for only_on trigger constraint and if it doesn't match guest
+          # name, throw it away also be sure to preserve order
+          filter = triggers.dup
+
+          filter.each do |trigger|
+            index = nil
+            match = false
+            if trigger.only_on
+              trigger.only_on.each do |o|
+                if o.match(guest_name)
+                  # trigger matches on current guest, so we're fine to use it
+                  match = true
+                  break
+                end
+              end
+              # no matches found, so don't use trigger for guest
+              index = triggers.index(trigger) unless match == true
+            end
+
+            if index
+              @logger.debug("Trigger #{trigger.id} will be ignored for #{guest_name}")
+              triggers.delete_at(index)
+            end
+          end
+
+          return triggers
+        end
+
+        # Fires off all triggers in the given array
+        #
+        # @param [Array] triggers An array of triggers to be fired
+        def fire(triggers, guest_name)
+          # ensure on_error is respected by exiting or continuing
+
+          triggers.each do |trigger|
+            @logger.debug("Running trigger #{trigger.id}...")
+
+            if trigger.name
+              @machine.ui.info(I18n.t("vagrant.trigger.fire_with_name",
+                                      name: trigger.name))
+            else
+              @machine.ui.info(I18n.t("vagrant.trigger.fire"))
+            end
+
+            if trigger.info
+              info(trigger.info)
+            end
+
+            if trigger.warn
+              warn(trigger.warn)
+            end
+
+            if trigger.run
+              run(trigger.run, trigger.on_error)
+            end
+
+            if trigger.run_remote
+              run_remote(trigger.run_remote, trigger.on_error)
+            end
+          end
+        end
+
+        # Prints the given message at info level for a trigger
+        #
+        # @param [String] message The string to be printed
+        def info(message)
+          @machine.ui.info(message)
+        end
+
+        # Prints the given message at warn level for a trigger
+        #
+        # @param [String] message The string to be printed
+        def warn(message)
+          @machine.ui.warn(message)
+        end
+
+        # Runs a script on a guest
+        #
+        # @param [Provisioners::Shell::Config] config A Shell provisioner config
+        def run(config, on_error)
+          if config.inline
+            cmd = Shellwords.split(config.inline)
+
+            @machine.ui.detail(I18n.t("vagrant.trigger.run.inline", command: config.inline))
+          else
+            cmd = File.expand_path(config.path, @env.root_path)
+            cmd << " #{config.args.join(' ' )}" if config.args
+            cmd = Shellwords.split(cmd)
+
+            @machine.ui.detail(I18n.t("vagrant.trigger.run.script", path: config.path))
+          end
+
+          # Pick an execution method to run the script or inline string with
+          # Default to Subprocess::Execute
+          exec_method = Vagrant::Util::Subprocess.method(:execute)
+
+          if Vagrant::Util::Platform.windows?
+            if config.inline
+              exec_method = Vagrant::Util::PowerShell.method(:execute_inline)
+            else
+              exec_method = Vagrant::Util::PowerShell.method(:execute)
+            end
+          end
+
+          begin
+            result = exec_method.call(*cmd, :notify => [:stdout, :stderr]) do |type,data|
+              options = {}
+              case type
+              when :stdout
+                options[:color] = :green if !config.keep_color
+              when :stderr
+                options[:color] = :red if !config.keep_color
+              end
+
+              @machine.ui.detail(data, options)
+            end
+          rescue => e
+            @machine.ui.error(I18n.t("vagrant.errors.triggers_run_fail"))
+            @machine.ui.error(e.message)
+
+            if on_error == :halt
+              @logger.debug("Trigger run encountered an error. Halting on error...")
+              raise e
+            else
+              @logger.debug("Trigger run encountered an error. Continuing on anyway...")
+              @machine.ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
+            end
+          end
+        end
+
+        # Runs a script on the guest
+        #
+        # @param [ShellProvisioner/Config] config A Shell provisioner config
+        def run_remote(config, on_error)
+          unless @machine.state.id == :running
+            if on_error == :halt
+              raise Errors::TriggersGuestNotRunning,
+                machine_name: @machine.name,
+                state: @machine.state.id
+            else
+              @machine.ui.error(I18n.t("vagrant.errors.triggers_guest_not_running",
+                                        machine_name: @machine.name,
+                                        state: @machine.state.id))
+              @machine.ui.warn(I18n.t("vagrant.trigger.on_error_continue"))
+              return
+            end
+          end
+
+          prov = VagrantPlugins::Shell::Provisioner.new(@machine, config)
+
+          begin
+            prov.provision
+          rescue => e
+            @machine.ui.error(I18n.t("vagrant.errors.triggers_run_fail"))
+
+            if on_error == :halt
+              @logger.debug("Trigger run encountered an error. Halting on error...")
+              raise e
+            else
+              @logger.debug("Trigger run encountered an error. Continuing on anyway...")
+              @machine.ui.error(e.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/plugin/v2.rb

@@ -19,6 +19,7 @@ module Vagrant
       autoload :Push, "vagrant/plugin/v2/push"
       autoload :Provisioner, "vagrant/plugin/v2/provisioner"
       autoload :SyncedFolder, "vagrant/plugin/v2/synced_folder"
+      autoload :Trigger, "vagrant/plugin/v2/trigger"
     end
   end
 end

data/lib/vagrant/util/downloader.rb

@@ -292,11 +292,21 @@ module Vagrant
         # show an error message.
         if result.exit_code != 0
           @logger.warn("Downloader exit code: #{result.exit_code}")
-          parts    = result.stderr.split(/\n*curl:\s+\(\d+\)\s*/, 2)
-          parts[1] ||= ""
-          raise Errors::DownloaderError,
-            code: result.exit_code,
-            message: parts[1].chomp
+          check = result.stderr.match(/\n*curl:\s+\((?<code>\d+)\)\s*(?<error>.*)$/)
+          if check && check[:code] == "416"
+            # All good actually. 416 means there is no more bytes to download
+            @logger.warn("Downloader got a 416, but is likely fine. Continuing on...")
+          else
+            if !check
+              err_msg = result.stderr
+            else
+              err_msg = check[:error]
+            end
+
+            raise Errors::DownloaderError,
+              code: result.exit_code,
+              message: err_msg
+          end
         end
 
         result

data/lib/vagrant/util/platform.rb

@@ -107,9 +107,12 @@ module Vagrant
           return @_windows_hyperv_enabled if defined?(@_windows_hyperv_enabled)
 
           @_windows_hyperv_enabled = -> {
-            ps_cmd = "$(Get-WindowsOptionalFeature -FeatureName Microsoft-Hyper-V-All -Online).State"
-            output = Vagrant::Util::PowerShell.execute_cmd(ps_cmd)
-            return output == 'Enabled'
+            ["Get-WindowsOptionalFeature", "Get-WindowsFeature"].each do |cmd_name|
+              ps_cmd = "$(#{cmd_name} -FeatureName Microsoft-Hyper-V-Hypervisor).State"
+              output = Vagrant::Util::PowerShell.execute_cmd(ps_cmd)
+              return true if output == "Enabled"
+            end
+            return false
           }.call
 
           return @_windows_hyperv_enabled
@@ -396,7 +399,7 @@ module Vagrant
               root_path = wsl_rootfs
               # lxrun splits home separate so we need to account
               # for it's specialness here when we build the path
-              if root_path.end_with?("lxss") && parts.first != "home"
+              if root_path.end_with?("lxss") && !(["root", "home"].include?(parts.first))
                 root_path = "#{root_path}\\rootfs"
               end
               [root_path, *parts].join("\\")

data/lib/vagrant/util/powershell.rb

@@ -87,6 +87,27 @@ module Vagrant
         return r.stdout.chomp
       end
 
+      # Execute a powershell command and return a result
+      #
+      # @param [String] command PowerShell command to execute.
+      # @param [Hash] opts A collection of options for subprocess::execute
+      # @param [Block] block Ruby block
+      def self.execute_inline(*command, **opts, &block)
+        validate_install!
+        c = [
+          executable,
+          "-NoLogo",
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy", "Bypass",
+          "-Command",
+          command
+        ].flatten.compact
+        c << opts
+
+        Subprocess.execute(*c, &block)
+      end
+
       # Returns the version of PowerShell that is installed.
       #
       # @return [String]

data/lib/vagrant/vagrantfile.rb

@@ -125,8 +125,21 @@ module Vagrant
       if provider != nil
         provider_plugin  = Vagrant.plugin("2").manager.providers[provider]
         if !provider_plugin
+          providers  = Vagrant.plugin("2").manager.providers.to_hash.keys
+          if providers
+            providers_str = providers.join(', ')
+          else
+            providers_str = "N/A"
+          end
+
+          if providers.include? provider.downcase
+            raise Errors::ProviderNotFoundSuggestion,
+              machine: name, provider: provider,
+              suggestion: provider.downcase, providers: providers_str
+          end
+
           raise Errors::ProviderNotFound,
-            machine: name, provider: provider
+            machine: name, provider: provider, providers: providers_str
         end
 
         provider_cls     = provider_plugin[0]

data/plugins/commands/login/middleware/add_authentication.rb

@@ -35,11 +35,17 @@ module VagrantPlugins
         token  = client.token
 
         env[:box_urls].map! do |url|
-          u = URI.parse(url)
-          if u.host != TARGET_HOST && REPLACEMENT_HOSTS.include?(u.host)
-            u.host = TARGET_HOST
+          begin
+            u = URI.parse(url)
+            if u.host != TARGET_HOST && REPLACEMENT_HOSTS.include?(u.host)
+              u.host = TARGET_HOST
+              u.to_s
+            else
+              url
+            end
+          rescue URI::Error
+            url
           end
-          u.to_s
         end
 
         server_uri = URI.parse(Vagrant.server_url.to_s)

data/plugins/communicators/ssh/communicator.rb

@@ -196,8 +196,13 @@ module VagrantPlugins
 
           # Adjust private key file permissions
           if Vagrant::Util::Platform.windows?
-            priv_path = @machine.data_dir.join("private_key").to_s
-            File.set_permissions(priv_path, Etc.getlogin => File::FULL)
+            begin
+              priv_path = @machine.data_dir.join("private_key").to_s
+              File.set_permissions(priv_path, Etc.getlogin => File::FULL)
+            rescue => e
+              @logger.warn("Error encountered during private key permissions set - " \
+                "#{e.class}: #{e.message}")
+            end
           else
             @machine.data_dir.join("private_key").chmod(0600)
           end

data/plugins/communicators/winrm/command_filters/rm.rb

@@ -31,9 +31,9 @@ module VagrantPlugins
 
           ret_cmd = ''
           if recurse
-            ret_cmd = "rm \"#{dir}\" -recurse -force"
+            ret_cmd = "if (Test-Path \"#{dir}\") {Remove-Item \"#{dir}\" -force -recurse}"
           else
-            ret_cmd = "rm \"#{dir}\" -force"
+            ret_cmd = "if (Test-Path \"#{dir}\") {Remove-Item \"#{dir}\" -force}"
           end
           return ret_cmd
         end

data/plugins/guests/linux/cap/mount_virtualbox_shared_folder.rb

@@ -11,6 +11,9 @@ module VagrantPlugins
 
           @@logger.debug("Mounting #{name} (#{options[:hostpath]} to #{guestpath})")
 
+          builtin_mount_type = "-cit vboxsf"
+          addon_mount_type = "-t vboxsf"
+
           mount_options = options.fetch(:mount_options, [])
           detected_ids = detect_owner_group_ids(machine, guest_path, mount_options, options)
           mount_uid = detected_ids[:uid]
@@ -19,21 +22,33 @@ module VagrantPlugins
           mount_options << "uid=#{mount_uid}"
           mount_options << "gid=#{mount_gid}"
           mount_options = mount_options.join(',')
-          mount_command = "mount -t vboxsf -o #{mount_options} #{name} #{guest_path}"
+          mount_command = "mount #{addon_mount_type} -o #{mount_options} #{name} #{guest_path}"
 
           # Create the guest path if it doesn't exist
           machine.communicate.sudo("mkdir -p #{guest_path}")
 
-          # Attempt to mount the folder. We retry here a few times because
-          # it can fail early on.
           stderr = ""
-          retryable(on: Vagrant::Errors::VirtualBoxMountFailed, tries: 3, sleep: 5) do
-            machine.communicate.sudo(mount_command,
-              error_class: Vagrant::Errors::VirtualBoxMountFailed,
-              error_key: :virtualbox_mount_failed,
-              command: mount_command,
-              output: stderr,
-            ) { |type, data| stderr = data if type == :stderr }
+          result = machine.communicate.sudo(mount_command, error_check: false) do |type, data|
+            stderr << data if type == :stderr
+          end
+
+          if result != 0
+            if stderr.include?("-cit")
+              @@logger.info("Detected builtin vboxsf module, modifying mount command")
+              mount_command.sub!(addon_mount_type, builtin_mount_type)
+            end
+
+            # Attempt to mount the folder. We retry here a few times because
+            # it can fail early on.
+            stderr = ""
+            retryable(on: Vagrant::Errors::VirtualBoxMountFailed, tries: 3, sleep: 5) do
+              machine.communicate.sudo(mount_command,
+                error_class: Vagrant::Errors::VirtualBoxMountFailed,
+                error_key: :virtualbox_mount_failed,
+                command: mount_command,
+                output: stderr,
+              ) { |type, data| stderr = data if type == :stderr }
+            end
           end
 
           # Chown the directory to the proper user. We skip this if the