chef 18.0.169-x64-mingw-ucrt

data/lib/chef/provider/mount/mount.rb

@@ -0,0 +1,290 @@
+#
+# Author:: Joshua Timberman (<joshua@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../mount"
+require_relative "../../log"
+
+class Chef
+  class Provider
+    class Mount
+      class Mount < Chef::Provider::Mount
+
+        provides :mount
+
+        def initialize(new_resource, run_context)
+          super
+          @real_device = nil
+        end
+        attr_accessor :real_device
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Mount.new(@new_resource.name)
+          @current_resource.mount_point(@new_resource.mount_point)
+          @current_resource.device(@new_resource.device)
+          mounted?
+          enabled?
+        end
+
+        def mountable?
+          # only check for existence of non-remote devices
+          if device_should_exist? && !::File.exists?(device_real)
+            raise Chef::Exceptions::Mount, "Device #{@new_resource.device} does not exist"
+          elsif @new_resource.mount_point != "none" && !::File.exists?(@new_resource.mount_point)
+            raise Chef::Exceptions::Mount, "Mount point #{@new_resource.mount_point} does not exist"
+          end
+
+          true
+        end
+
+        def enabled?
+          # Check to see if there is a entry in /etc/fstab. Last entry for a volume wins.
+          enabled = false
+          unless ::File.exist?("/etc/fstab")
+            logger.debug "/etc/fstab not found, treating mount as not-enabled"
+            return
+          end
+          ::File.foreach("/etc/fstab") do |line|
+            case line
+            when /^[#\s]/
+              next
+            when /^(#{device_fstab_regex})\s+#{Regexp.escape(@new_resource.mount_point)}\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/
+              enabled = true
+              @current_resource.device($1)
+              @current_resource.fstype($2)
+              @current_resource.options($3)
+              @current_resource.dump($4.to_i)
+              @current_resource.pass($5.to_i)
+              logger.trace("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/fstab")
+            end
+          end
+          @current_resource.enabled(enabled)
+        end
+
+        def mounted?
+          mounted = false
+
+          # "mount" outputs the mount points as real paths. Convert
+          # the mount_point of the resource to a real path in case it
+          # contains symlinks in its parents dirs.
+          real_mount_point = if ::File.exists? @new_resource.mount_point
+                               ::File.realpath(@new_resource.mount_point)
+                             else
+                               @new_resource.mount_point
+                             end
+
+          shell_out!("mount").stdout.each_line do |line|
+            case line
+            when /^#{device_mount_regex}\s+on\s+#{Regexp.escape(real_mount_point)}\s/
+              mounted = true
+              logger.trace("Special device #{device_logstring} mounted as #{real_mount_point}")
+            when %r{^([/\w])+\son\s#{Regexp.escape(real_mount_point)}\s+}
+              mounted = false
+              logger.trace("Special device #{$~[1]} mounted as #{real_mount_point}")
+            end
+          end
+          @current_resource.mounted(mounted)
+        end
+
+        def mount_fs
+          unless @current_resource.mounted
+            mountable?
+            command = [ "mount", "-t", @new_resource.fstype ]
+            unless @new_resource.options.nil? || @new_resource.options.empty?
+              command << "-o"
+              command << @new_resource.options.join(",")
+            end
+            command << case @new_resource.device_type
+                       when :device
+                         device_real
+                       when :label
+                         [ "-L", @new_resource.device ]
+                       when :uuid
+                         [ "-U", @new_resource.device ]
+                       end
+            command << @new_resource.mount_point
+            shell_out!(*command)
+            logger.trace("#{@new_resource} is mounted at #{@new_resource.mount_point}")
+          else
+            logger.debug("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
+          end
+        end
+
+        def umount_fs
+          if @current_resource.mounted
+            shell_out!("umount", @new_resource.mount_point)
+            logger.trace("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
+          else
+            logger.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
+          end
+        end
+
+        def remount_command
+          [ "mount", "-o", "remount,#{@new_resource.options.join(",")}", @new_resource.mount_point ]
+        end
+
+        def remount_fs
+          if @current_resource.mounted && @new_resource.supports[:remount]
+            shell_out!(*remount_command)
+            @new_resource.updated_by_last_action(true)
+            logger.trace("#{@new_resource} is remounted at #{@new_resource.mount_point}")
+          elsif @current_resource.mounted
+            umount_fs
+            sleep 1
+            mount_fs
+          else
+            logger.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point} - nothing to do")
+          end
+        end
+
+        # Return appropriate default mount options according to the given os.
+        def default_mount_options
+          linux? ? "defaults" : "rw"
+        end
+
+        def enable_fs
+          if @current_resource.enabled && mount_options_unchanged? && device_unchanged?
+            logger.debug("#{@new_resource} is already enabled - nothing to do")
+            return nil
+          end
+
+          if @current_resource.enabled
+            # The current options don't match what we have, so
+            # update the last matching entry with current option
+            # and order will remain the same.
+            edit_fstab
+          else
+            ::File.open("/etc/fstab", "a") do |fstab|
+              fstab.puts("#{device_fstab} #{@new_resource.mount_point} #{@new_resource.fstype} #{@new_resource.options.nil? ? default_mount_options : @new_resource.options.join(",")} #{@new_resource.dump} #{@new_resource.pass}")
+              logger.trace("#{@new_resource} is enabled at #{@new_resource.mount_point}")
+            end
+          end
+        end
+
+        def disable_fs
+          edit_fstab(remove: true)
+        end
+
+        def network_device?
+          @new_resource.device.include?(":") || @new_resource.device.include?("//")
+        end
+
+        def device_should_exist?
+          ( @new_resource.device != "none" ) &&
+            ( not network_device? ) &&
+            ( not %w{ cgroup tmpfs fuse vboxsf zfs }.include? @new_resource.fstype )
+        end
+
+        private
+
+        def device_real
+          if @real_device.nil?
+            if @new_resource.device_type == :device
+              @real_device = @new_resource.device
+            else
+              @real_device = ""
+              ret = shell_out("/sbin/findfs", device_fstab)
+              device_line = ret.stdout.lines.first # stdout.first consumes
+              @real_device = device_line.chomp unless device_line.nil?
+            end
+          end
+          # Removed "/" from the end of str, because it was causing idempotency issue.
+          (@real_device == "/" || @real_device.match?(":/$")) ? @real_device : @real_device.chomp("/")
+        end
+
+        def device_logstring
+          case @new_resource.device_type
+          when :device
+            (device_real).to_s
+          when :label
+            "#{device_real} with label #{@new_resource.device}"
+          when :uuid
+            "#{device_real} with uuid #{@new_resource.device}"
+          end
+        end
+
+        def device_with_space_escape
+          # For CIFS (and perhaps other remote network mounts) when a space is in the "device name"
+          # It will appear with the space substituted with a special character. However, when mounting,
+          # The mount needs to be done with an actual space. This function provides the device name with
+          # The special character to determine if the device is mounted.
+          device_mount_regex.gsub(" ", "\\x20")
+        end
+
+        def device_mount_regex
+          if network_device?
+            # ignore trailing slash
+            Regexp.escape(device_real) + "/?"
+          elsif ::File.symlink?(device_real)
+            # This regular expression tries to match device_real. If that does not match it will try to match the target of device_real.
+            # So given a symlink like this:
+            # /dev/mapper/vgroot-tmp.vol -> /dev/dm-9
+            # First it will try to match "/dev/mapper/vgroot-tmp.vol". If there is no match it will try matching for "/dev/dm-9".
+            "(?:#{Regexp.escape(device_real)}|#{Regexp.escape(::File.expand_path(::File.readlink(device_real), ::File.dirname(device_real)))})"
+          else
+            Regexp.escape(device_real)
+          end
+        end
+
+        def device_fstab_regex
+          if @new_resource.device_type == :device
+            device_mount_regex
+          else
+            Regexp.union(device_fstab, device_mount_regex)
+          end
+        end
+
+        def mount_options_unchanged?
+          @current_resource.fstype == @new_resource.fstype &&
+            @current_resource.options == @new_resource.options &&
+            @current_resource.dump == @new_resource.dump &&
+            @current_resource.pass == @new_resource.pass
+        end
+
+        # It will update or delete the entry from fstab.
+        def edit_fstab(remove: false)
+          if @current_resource.enabled
+            contents = []
+
+            found = false
+            ::File.readlines("/etc/fstab").reverse_each do |line|
+              if !found && line =~ /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}\s/
+                found = true
+                if remove
+                  logger.trace("#{@new_resource} is removed from fstab")
+                else
+                  contents << ("#{device_fstab} #{@new_resource.mount_point} #{@new_resource.fstype} #{@new_resource.options.nil? ? default_mount_options : @new_resource.options.join(",")} #{@new_resource.dump} #{@new_resource.pass}")
+                  logger.trace("#{@new_resource} is updated with new content in fstab")
+                end
+                next
+              else
+                contents << line
+              end
+            end
+
+            ::File.open("/etc/fstab", "w") do |fstab|
+              contents.reverse_each { |line| fstab.puts line }
+            end
+          else
+            logger.debug("#{@new_resource} is not enabled - nothing to do")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/mount/solaris.rb

@@ -0,0 +1,274 @@
+# Author:: Hugo Fichter
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Author:: Joshua Timberman (<joshua@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../mount"
+require_relative "../../log"
+require "forwardable" unless defined?(Forwardable)
+
+class Chef
+  class Provider
+    class Mount
+      # Mount Solaris File systems
+      class Solaris < Chef::Provider::Mount
+        provides :mount, platform_family: "solaris_based"
+
+        extend Forwardable
+
+        VFSTAB = "/etc/vfstab".freeze
+
+        def_delegator :@new_resource, :device, :device
+        def_delegator :@new_resource, :device_type, :device_type
+        def_delegator :@new_resource, :dump, :dump
+        def_delegator :@new_resource, :fsck_device, :fsck_device
+        def_delegator :@new_resource, :fstype, :fstype
+        def_delegator :@new_resource, :mount_point, :mount_point
+        def_delegator :@new_resource, :options, :options
+        def_delegator :@new_resource, :pass, :pass
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Mount.new(new_resource.name)
+          current_resource.mount_point(mount_point)
+          current_resource.device(device)
+          current_resource.fsck_device(fsck_device)
+          current_resource.device_type(device_type)
+          update_current_resource_state
+        end
+
+        def define_resource_requirements
+          requirements.assert(:mount, :remount) do |a|
+            a.assertion { !device_should_exist? || ::File.exist?(device) }
+            a.failure_message(Chef::Exceptions::Mount, "Device #{device} does not exist")
+            a.whyrun("Assuming device #{device} would have been created")
+          end
+
+          unless fsck_device == "-"
+            requirements.assert(:mount, :remount) do |a|
+              a.assertion { ::File.exist?(fsck_device) }
+              a.failure_message(Chef::Exceptions::Mount, "Device #{fsck_device} does not exist")
+              a.whyrun("Assuming device #{fsck_device} would have been created")
+            end
+          end
+
+          requirements.assert(:mount, :remount) do |a|
+            a.assertion { ::File.exist?(mount_point) }
+            a.failure_message(Chef::Exceptions::Mount, "Mount point #{mount_point} does not exist")
+            a.whyrun("Assuming mount point #{mount_point} would have been created")
+          end
+        end
+
+        def mount_fs
+          actual_options = native_options(options)
+          actual_options.delete("-")
+          command = [ "mount", "-F", fstype ]
+          unless actual_options.empty?
+            command << "-o"
+            command << actual_options.join(",")
+          end
+          command << [ device, mount_point ]
+          shell_out!(command)
+        end
+
+        def umount_fs
+          shell_out!("umount", mount_point)
+        end
+
+        def remount_fs
+          # FIXME: Should remount always do the remount or only if the options change?
+          actual_options = native_options(options)
+          actual_options.delete("-")
+          mount_options = actual_options.empty? ? "" : ",#{actual_options.join(",")}"
+          shell_out!("mount", "-o", "remount#{mount_options}", mount_point)
+        end
+
+        def enable_fs
+          unless mount_options_unchanged?
+            # we are enabling because our options have changed, so disable first then re-enable.
+            # XXX: this should be refactored to be the responsibility of the caller
+            disable_fs if current_resource.enabled
+          end
+
+          vfstab_write(merge_vfstab_entry)
+        end
+
+        def disable_fs
+          contents, found = delete_vfstab_entry
+
+          if found
+            vfstab_write(contents.reverse)
+          else
+            # this is likely some kind of internal error, since we should only call disable_fs when there
+            # the filesystem we want to disable is enabled.
+            logger.warn("#{new_resource} did not find the mountpoint to disable in the vfstab")
+          end
+        end
+
+        def etc_tempfile
+          yield Tempfile.open("vfstab", "/etc")
+        end
+
+        def mount_options_unchanged?
+          new_options = native_options(options)
+          current_options = native_options(current_resource.nil? ? nil : current_resource.options)
+
+          current_resource.fsck_device == fsck_device &&
+            current_resource.fstype == fstype &&
+            current_options == new_options &&
+            current_resource.dump == dump &&
+            current_resource.pass == pass &&
+            current_resource.options.include?("noauto") == !mount_at_boot?
+        end
+
+        def update_current_resource_state
+          current_resource.mounted(mounted?)
+          (enabled, fstype, options, pass) = read_vfstab_status
+          current_resource.enabled(enabled)
+          current_resource.fstype(fstype)
+          current_resource.options(options)
+          current_resource.pass(pass)
+        end
+
+        def enabled?
+          read_vfstab_status[0]
+        end
+
+        # Check for the device in mounttab.
+        # <device> on <mountpoint> type <fstype> <options> on <date>
+        # /dev/dsk/c1t0d0s0 on / type ufs read/write/setuid/devices/intr/largefiles/logging/xattr/onerror=panic/dev=700040 on Tue May  1 11:33:55 2012
+        def mounted?
+          mounted = false
+          shell_out!("mount", "-v").stdout.each_line do |line|
+            case line
+            when /^#{device_regex}\s+on\s+#{Regexp.escape(mount_point)}\s+/
+              logger.trace("Special device #{device} is mounted as #{mount_point}")
+              mounted = true
+            when %r{^([/\w]+)\son\s#{Regexp.escape(mount_point)}\s+}
+              logger.trace("Special device #{Regexp.last_match[1]} is mounted as #{mount_point}")
+              mounted = false
+            end
+          end
+          mounted
+        end
+
+        private
+
+        def read_vfstab_status
+          # Check to see if there is an entry in /etc/vfstab. Last entry for a volume wins.
+          enabled = false
+          pass = false
+          fstype = options = nil
+          ::File.foreach(VFSTAB) do |line|
+            case line
+            when /^[#\s]/
+              next
+              # solaris /etc/vfstab format:
+              # device         device          mount           FS      fsck    mount   mount
+              # to mount       to fsck         point           type    pass    at boot options
+            when %r{^#{device_regex}\s+[-/\w]+\s+#{Regexp.escape(mount_point)}\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)}
+              enabled = true
+              fstype = Regexp.last_match[1]
+              options = Regexp.last_match[4]
+              # Store the 'mount at boot' column from vfstab as the 'noauto' option
+              # in current_resource.options (linux style)
+              if Regexp.last_match[3] == "no"
+                if options.nil? || options.empty?
+                  options = "noauto"
+                else
+                  options += ",noauto"
+                end
+              end
+              pass = (Regexp.last_match[2] == "-") ? 0 : Regexp.last_match[2].to_i
+              logger.trace("Found mount #{device} to #{mount_point} in #{VFSTAB}")
+              next
+            when %r{^[-/\w]+\s+[-/\w]+\s+#{Regexp.escape(mount_point)}\s+}
+              # if we find a mountpoint on top of our mountpoint, then we are not enabled
+              enabled = false
+              logger.trace("Found conflicting mount point #{mount_point} in #{VFSTAB}")
+            end
+          end
+          [enabled, fstype, options, pass]
+        end
+
+        def device_should_exist?
+          !%w{tmpfs nfs ctfs proc mntfs objfs sharefs fd smbfs vxfs}.include?(fstype)
+        end
+
+        def mount_at_boot?
+          options.nil? || !options.include?("noauto")
+        end
+
+        def vfstab_write(contents)
+          etc_tempfile do |f|
+            f.write(contents.join(""))
+            f.close
+            # move, preserving modes of destination file
+            mover = Chef::FileContentManagement::Deploy.strategy(true)
+            mover.deploy(f.path, VFSTAB)
+          end
+        end
+
+        def vfstab_entry
+          actual_options = native_options(options)
+          autostr = mount_at_boot? ? "yes" : "no"
+          passstr = pass == 0 ? "-" : pass
+          optstr = (actual_options.nil? || actual_options.empty?) ? "-" : actual_options.join(",")
+          "\n#{device}\t#{fsck_device}\t#{mount_point}\t#{fstype}\t#{passstr}\t#{autostr}\t#{optstr}\n"
+        end
+
+        def delete_vfstab_entry
+          contents = []
+          found = false
+          ::File.readlines(VFSTAB).reverse_each do |line|
+            if !found && line =~ /^#{device_regex}\s+\S+\s+#{Regexp.escape(mount_point)}/
+              found = true
+              logger.trace("#{new_resource} is removed from vfstab")
+              next
+            end
+            contents << line
+          end
+          [contents, found]
+        end
+
+        def merge_vfstab_entry
+          contents = ::File.readlines(VFSTAB)
+          contents[-1].chomp!
+          contents << vfstab_entry
+        end
+
+        def native_options(temp_options)
+          if temp_options == %w{defaults}
+            ["-"]
+          else
+            new_options = []
+            new_options += temp_options.nil? ? [] : temp_options.dup
+            new_options.delete("noauto")
+            new_options
+          end
+        end
+
+        def device_regex
+          if ::File.symlink?(device)
+            "(?:#{Regexp.escape(device)}|#{Regexp.escape(::File.expand_path(::File.readlink(device), ::File.dirname(device)))})"
+          else
+            Regexp.escape(device)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/mount/windows.rb

@@ -0,0 +1,92 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright 2010-2016, VMware, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../mount"
+if RUBY_PLATFORM.match?(/mswin|mingw|windows/)
+  require_relative "../../util/windows/net_use"
+  require_relative "../../util/windows/volume"
+end
+
+class Chef
+  class Provider
+    class Mount
+      class Windows < Chef::Provider::Mount
+
+        provides :mount, os: "windows"
+
+        def is_volume(name)
+          /^\\\\\?\\Volume\{[\w-]+\}\\$/.match?(name) ? true : false
+        end
+
+        def initialize(new_resource, run_context)
+          super
+          @mount = nil
+        end
+
+        def load_current_resource
+          if is_volume(@new_resource.device)
+            @mount = Chef::Util::Windows::Volume.new(@new_resource.mount_point)
+          else # assume network drive
+            @mount = Chef::Util::Windows::NetUse.new(@new_resource.mount_point)
+          end
+
+          @current_resource = Chef::Resource::Mount.new(@new_resource.name)
+          @current_resource.mount_point(@new_resource.mount_point)
+          logger.trace("Checking for mount point #{@current_resource.mount_point}")
+
+          begin
+            @current_resource.device(@mount.device)
+            logger.trace("#{@current_resource.device} mounted on #{@new_resource.mount_point}")
+            @current_resource.mounted(true)
+          rescue ArgumentError => e
+            @current_resource.mounted(false)
+            logger.trace("#{@new_resource.mount_point} is not mounted: #{e.message}")
+          end
+        end
+
+        def mount_fs
+          unless @current_resource.mounted
+            @mount.add(remote: @new_resource.device,
+                       username: @new_resource.username,
+                       domainname: @new_resource.domain,
+                       password: @new_resource.password)
+            logger.trace("#{@new_resource} is mounted at #{@new_resource.mount_point}")
+          else
+            logger.debug("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
+          end
+        end
+
+        def umount_fs
+          if @current_resource.mounted
+            @mount.delete
+            logger.trace("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
+          else
+            logger.trace("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
+          end
+        end
+
+        private
+
+        def mount_options_unchanged?
+          @current_resource.device == @new_resource.device
+        end
+
+      end
+    end
+  end
+end