chef 18.4.2 → 18.5.0

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

@@ -21,7 +21,7 @@ class Chef
   class Provider
     class Mount
       class Aix < Chef::Provider::Mount::Mount
-        provides :mount, platform: "aix"
+        provides :mount, platform: "aix", target_mode: true
 
         # Override for aix specific handling
         def initialize(new_resource, run_context)
@@ -163,7 +163,7 @@ class Chef
             # disable, then enable.
             disable_fs
           end
-          ::File.open("/etc/filesystems", "a") do |fstab|
+          ::TargetIO::File.open("/etc/filesystems", "a") do |fstab|
             fstab.puts("\n\n#{@new_resource.mount_point}:")
             if network_device?
               device_details = device_fstab.split(":")
@@ -194,7 +194,7 @@ class Chef
           contents = []
           if @current_resource.enabled
             found_device = false
-            ::File.open("/etc/filesystems", "r").each_line do |line|
+            ::TargetIO::File.open("/etc/filesystems", "r").each_line do |line|
               case line
               when %r{^/.+:\s*$}
                 if /#{Regexp.escape(@new_resource.mount_point)}+:/.match?(line)
@@ -207,7 +207,7 @@ class Chef
                 contents << line
               end
             end
-            ::File.open("/etc/filesystems", "w") do |fstab|
+            ::TargetIO::File.open("/etc/filesystems", "w") do |fstab|
               contents.each { |line| fstab.puts line }
             end
           else

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

@@ -23,7 +23,7 @@ class Chef
     class Mount
       class Linux < Chef::Provider::Mount::Mount
 
-        provides :mount, os: "linux"
+        provides :mount, os: "linux", target_mode: true
 
         # Check to see if the volume is mounted.
         # "findmnt" outputs the mount points with volume.
@@ -39,8 +39,8 @@ class Chef
 
         def mounted?
           mounted = false
-          real_mount_point = if ::File.exist? @new_resource.mount_point
-                               ::File.realpath(@new_resource.mount_point)
+          real_mount_point = if ::TargetIO::File.exist? @new_resource.mount_point
+                               ::TargetIO::File.realpath(@new_resource.mount_point)
                              else
                                @new_resource.mount_point
                              end
@@ -83,4 +83,4 @@ class Chef
       end
     end
   end
-end
+end

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

@@ -42,9 +42,9 @@ class Chef
 
         def mountable?
           # only check for existence of non-remote devices
-          if device_should_exist? && !::File.exist?(device_real)
+          if device_should_exist? && !::TargetIO::File.exist?(device_real)
             raise Chef::Exceptions::Mount, "Device #{@new_resource.device} does not exist"
-          elsif @new_resource.mount_point != "none" && !::File.exist?(@new_resource.mount_point)
+          elsif @new_resource.mount_point != "none" && !::TargetIO::File.exist?(@new_resource.mount_point)
             raise Chef::Exceptions::Mount, "Mount point #{@new_resource.mount_point} does not exist"
           end
 
@@ -54,11 +54,11 @@ class Chef
         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")
+          unless ::TargetIO::File.exist?("/etc/fstab")
             logger.debug "/etc/fstab not found, treating mount as not-enabled"
             return
           end
-          ::File.foreach("/etc/fstab") do |line|
+          ::TargetIO::File.foreach("/etc/fstab") do |line|
             case line
             when /^[#\s]/
               next
@@ -81,8 +81,8 @@ class Chef
           # "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.exist? @new_resource.mount_point
-                               ::File.realpath(@new_resource.mount_point)
+          real_mount_point = if ::TargetIO::File.exist? @new_resource.mount_point
+                               ::TargetIO::File.realpath(@new_resource.mount_point)
                              else
                                @new_resource.mount_point
                              end
@@ -168,7 +168,7 @@ class Chef
             # and order will remain the same.
             edit_fstab
           else
-            ::File.open("/etc/fstab", "a") do |fstab|
+            ::TargetIO::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
@@ -229,12 +229,12 @@ class Chef
           if network_device?
             # ignore trailing slash
             Regexp.escape(device_real) + "/?"
-          elsif ::File.symlink?(device_real)
+          elsif ::TargetIO::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)))})"
+            "(?:#{Regexp.escape(device_real)}|#{Regexp.escape(::File.expand_path(::TargetIO::File.readlink(device_real), ::File.dirname(device_real)))})"
           else
             Regexp.escape(device_real)
           end
@@ -261,7 +261,7 @@ class Chef
             contents = []
 
             found = false
-            ::File.readlines("/etc/fstab").reverse_each do |line|
+            ::TargetIO::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
@@ -276,7 +276,7 @@ class Chef
               end
             end
 
-            ::File.open("/etc/fstab", "w") do |fstab|
+            ::TargetIO::File.open("/etc/fstab", "w") do |fstab|
               contents.reverse_each { |line| fstab.puts line }
             end
           else

data/lib/chef/provider/package/apt.rb

@@ -124,11 +124,6 @@ class Chef
 
         private
 
-        # @return [String] package name with or without anchors attached to it.
-        def resolve_package(pkg)
-          new_resource.anchor_package_regex ? "^#{pkg}$" : pkg
-        end
-
         # @return [String] version of apt-get which is installed
         def apt_version
           @apt_version ||= shell_out("apt-get --version").stdout.match(/^apt (\S+)/)[1]
@@ -179,12 +174,10 @@ class Chef
         end
 
         def resolve_package_versions(pkg)
-          # apt-cache considers package names as regex by default. The anchor_package_regex flag will decide whether to match name exact string or not
-          pkg_name = resolve_package(pkg)
           current_version = nil
           candidate_version = nil
           all_versions = []
-          run_noninteractive("apt-cache", default_release_options, "policy", pkg_name).stdout.each_line do |line|
+          run_noninteractive("apt-cache", default_release_options, "policy", pkg).stdout.each_line do |line|
             case line
             when /^\s{2}Installed: (.+)$/
               current_version = ( $1 != "(none)" ) ? $1 : nil
@@ -223,9 +216,7 @@ class Chef
         end
 
         def resolve_virtual_package_name(pkg)
-          # apt-cache considers package names as regex by default. The anchor_package_regex flag will decide whether to match name exact string or not
-          pkg_name = resolve_package(pkg)
-          showpkg = run_noninteractive("apt-cache", "showpkg", pkg_name).stdout
+          showpkg = run_noninteractive("apt-cache", "showpkg", pkg).stdout
           partitions = showpkg.rpartition(/Reverse Provides: ?#{$/}/)
           return nil if partitions[0] == "" && partitions[1] == "" # not found in output
 

data/lib/chef/provider/package/bff.rb

@@ -25,8 +25,8 @@ class Chef
     class Package
       class Bff < Chef::Provider::Package
 
-        provides :package, os: "aix"
-        provides :bff_package
+        provides :package, os: "aix", target_mode: true
+        provides :bff_package, target_mode: true
 
         include Chef::Mixin::GetSourceFromPackage
 
@@ -134,7 +134,7 @@ class Chef
         end
 
         def package_source_found?
-          @package_source_found ||= new_resource.source && ::File.exist?(new_resource.source)
+          @package_source_found ||= new_resource.source && ::TargetIO::File.exist?(new_resource.source)
         end
 
       end

data/lib/chef/provider/package/chocolatey.rb

@@ -144,7 +144,11 @@ class Chef
         def check_resource_semantics!; end
 
         def get_choco_version
-          @get_choco_version ||= powershell_exec!("#{choco_exe} --version").result
+          # We need a different way to get the version than by simply calling "choco --version".
+          # If the license file is installed (for business customers) but not the Chocolatey.Extension (because you're using the choco resource to install it)
+          # then you get a license error. This method bypasses that by getting the version from the exe directly instead of invoking it.
+          # deprecated: @get_choco_version ||= powershell_exec!("#{choco_exe} --version").result
+          @get_choco_version ||= powershell_exec!("Get-ItemProperty #{choco_exe} | select-object -expandproperty versioninfo | select-object -expandproperty productversion").result
         end
 
         # Choco V2 uses 'Search' for remote repositories and 'List' for local packages
@@ -167,22 +171,34 @@ class Chef
           true
         end
 
-        # walk the collection to find peer resources to ensure that
-        # we get as much of the cache this run as possible.  Unified mode
-        # sub-resources will, of course, be incremental with this, since we can't
-        # grab them in advance, but even in that case we're still way, way
-        # more efficient with our queries...
+        # Find the set of packages to ask the chocolatey server about
+        #
+        # if walk_resource_tree is true, this finds _all_ of the packages that
+        # we have referenced anywhere in our recipes - this is so we can
+        # attempt to query them all in a single transaction.  However,
+        # currently we don't do that - see the comment on available_packages
+        # for details of the why, but the TL;DR is that the public chocolatey
+        # servers do not support `or` type queries properly.
+        #
+        # If walk_resource_tree is false, we don't do any of that - we just filter
+        # the package list based on cache data.  This is the default due to reasons
+        # explained in the comment on available_packages - the goal is to eventually
+        # turn this back on, hence the default false parameter here.
         #
         # @return [Array] List of chocolatey packages referenced in the run list
-        def collect_package_requests(ignore_list: [])
+        def collect_package_requests(ignore_list: [], walk_resource_tree: false)
           return ["*"] if new_resource.bulk_query || Chef::Config[:always_use_bulk_chocolatey_package_list]
 
-          # Get to the root of the resource collection
-          rc = run_context.parent_run_context || run_context
-          rc = rc.parent_run_context while rc.parent_run_context
+          if walk_resource_tree
+            # Get to the root of the resource collection
+            rc = run_context.parent_run_context || run_context
+            rc = rc.parent_run_context while rc.parent_run_context
 
-          package_collection = package_name_array
-          package_collection += nested_package_resources(rc.resource_collection)
+            package_collection = package_name_array
+            package_collection += nested_package_resources(rc.resource_collection)
+          else
+            package_collection = package_name_array
+          end
           # downcase the array and uniq.  sorted for easier testing...
           package_collection.uniq.sort.filter { |pkg| !ignore_list.include?(pkg) }
         end
@@ -339,22 +355,33 @@ class Chef
             @@choco_available_packages[new_resource.list_options] = {}
           end
 
-          # Attempt to get everything we need in a single query.
-          # Grab 25 packages at a time at most, to avoid hurting servers too badly
+          # This would previously grab 25 packages at a time, which previously worked - however,
+          # upstream changed and it turns out this was only working by accident - see
+          # https://github.com/chocolatey/choco/issues/2116 for this.  So the TL;DR ends up
+          # being that this can be re-enabled when the chocolatey server actually supports an
+          # or operator.  So it makes sense to leave the logic here for this split, while we
+          # work with upstream to get this to be a working feature there
+          #
+          # Foot guns: there is a --id-starts-with for chocolatey, which you'd think would work,
+          # but that actually fails on public chocolatey as well, because it seems to do the filtering
+          # locally. Which means it too will omit a lot of results (this is also corroborated by
+          # the 2116 issue above).
           #
-          # For v1 we actually used to grab the entire list of packages, but we found
-          # that it could cause undue load on really large package lists
+          # collect_package_requests, however, continues to be useful here because it filters
+          # the already cached things from the list.  However, for now it will no longer walk the
+          # resource tree until 2116 can be sorted out.  When we regain that ability, we should
+          # re-evaluate this, since it does save a LOT of API requests!
           collect_package_requests(
             ignore_list: @@choco_available_packages[new_resource.list_options].keys
-          ).each_slice(25) do |pkg_set|
+          ).each do |pkg_set|
             available_versions =
               begin
               cmd = [ query_command, "-r" ]
 
               # Chocolatey doesn't actually take a wildcard for this query, however
               # it will return all packages when using '*' as a query
-              unless pkg_set == ["*"]
-                cmd += pkg_set
+              unless pkg_set == "*"
+                cmd << pkg_set
               end
               cmd += common_options
               cmd.push( new_resource.list_options ) if new_resource.list_options
@@ -383,10 +410,12 @@ class Chef
         #
         # @return [Hash] name-to-version mapping of installed packages
         def installed_packages
-          if new_resource.use_choco_list == false || !Chef::Config[:always_use_choco_list]
-            installed_packages_via_choco
-          else
+          # Logic here must be either use_choco_list is false _and_ always_use_choco_list is
+          # falsy, since the global overrides the local
+          if new_resource.use_choco_list == false && !Chef::Config[:always_use_choco_list]
             installed_packages_via_disk
+          else
+            installed_packages_via_choco
           end
         end
 
@@ -413,8 +442,8 @@ class Chef
             # that contains all possible package folders, and so we push our
             # guess to the front as an optimization.
             target_dirs << targets.first.downcase if targets.length == 1
-            if targets.downcase is_a?(String)
-              target_dirs << targets
+            if targets.is_a?(String)
+              target_dirs << targets.downcase
             end
             target_dirs += get_local_pkg_dirs(choco_lib_path)
             fetch_package_versions(choco_lib_path, target_dirs, targets)
@@ -465,6 +494,7 @@ class Chef
         # Fetch the local package versions from chocolatey
         def fetch_package_versions(base_dir, target_dirs, targets)
           pkg_versions = {}
+          targets = [targets] if targets.is_a?(String)
           target_dirs.each do |dir|
             pkg_versions.merge!(get_pkg_data(::File.join(base_dir, dir)))
             # return early if we found the single package version we were looking for

data/lib/chef/provider/package/dpkg.rb

@@ -29,7 +29,7 @@ class Chef
         DPKG_INSTALLED = /^Status: install ok installed/.freeze
         DPKG_VERSION   = /^Version: (.+)$/.freeze
 
-        provides :dpkg_package
+        provides :dpkg_package, target_mode: true
 
         use_multipackage_api
         use_package_name_for_source
@@ -146,14 +146,14 @@ class Chef
         #
         # @return [Boolean] True if all sources exist
         def source_files_exist?
-          resolved_source_array.all? { |s| s && ::File.exist?(s) }
+          resolved_source_array.all? { |s| s && ::TargetIO::File.exist?(s) }
         end
 
         # Helper to return all the names of the missing sources for error messages.
         #
         # @return [Array<String>] Array of missing sources
         def missing_sources
-          resolved_source_array.select { |s| s.nil? || !::File.exist?(s) }
+          resolved_source_array.select { |s| s.nil? || !::TargetIO::File.exist?(s) }
         end
 
         def current_package_name_array

data/lib/chef/provider/package/freebsd/base.rb

@@ -30,7 +30,7 @@ class Chef
 
         module PortsHelper
           def supports_ports?
-            ::File.exist?("/usr/ports/Makefile")
+            ::TargetIO::File.exist?("/usr/ports/Makefile")
           end
 
           def port_dir(port)

data/lib/chef/provider/package/habitat.rb

@@ -15,7 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require_relative "../../http/simple"
 require_relative "../../json_compat"
 require_relative "../../exceptions"
 require_relative "../package"
@@ -27,7 +26,7 @@ class Chef
       class Habitat < Chef::Provider::Package
         use_multipackage_api
         use "../../resource/habitat/habitat_shared"
-        provides :habitat_package
+        provides :habitat_package, target_mode: true
 
         def load_current_resource
           @current_resource = Chef::Resource::HabitatPackage.new(new_resource.name)
@@ -40,6 +39,9 @@ class Chef
         end
 
         def install_package(names, versions)
+          # License acceptance needed outside of local Chef Client
+          shell_out!("hab license accept") if Chef::Config.target_mode?
+
           names.zip(versions).map do |n, v|
             opts = ["pkg", "install", "--channel", new_resource.channel, "--url", new_resource.bldr_url]
             opts += ["--auth", new_resource.auth_token] if new_resource.auth_token
@@ -120,7 +122,7 @@ class Chef
 
         def http
           # FIXME: use SimpleJSON when the depot mime-type is fixed
-          @http ||= Chef::HTTP::Simple.new(new_resource.bldr_url.to_s)
+          @http ||= TargetIO::HTTP.new(new_resource.bldr_url.to_s)
         end
 
         def candidate_versions

data/lib/chef/provider/package/ips.rb

@@ -26,8 +26,8 @@ class Chef
     class Package
       class Ips < Chef::Provider::Package
 
-        provides :package, platform: %w{openindiana omnios solaris2}
-        provides :ips_package
+        provides :package, platform: %w{openindiana omnios solaris2}, target_mode: true
+        provides :ips_package, target_mode: true
 
         attr_accessor :virtual
 

data/lib/chef/provider/package/openbsd.rb

@@ -30,8 +30,8 @@ class Chef
     class Package
       class Openbsd < Chef::Provider::Package
 
-        provides :package, os: "openbsd"
-        provides :openbsd_package
+        provides :package, os: "openbsd", target_mode: true
+        provides :openbsd_package, target_mode: true
 
         include Chef::Mixin::ShellOut
         include Chef::Mixin::GetSourceFromPackage
@@ -129,6 +129,7 @@ class Chef
           end
         end
 
+        # Target Mode limitation: ENV["PKG_PATH"] cannot be evaluated, as remote commands are not run in a standard shell
         def pkg_path
           ENV["PKG_PATH"] || "http://ftp.OpenBSD.org/pub/#{node["kernel"]["name"]}/#{node["kernel"]["release"]}/packages/#{node["kernel"]["machine"]}/"
         end

data/lib/chef/provider/package/pacman.rb

@@ -24,8 +24,8 @@ class Chef
     class Package
       class Pacman < Chef::Provider::Package
 
-        provides :package, platform: "arch"
-        provides :pacman_package
+        provides :package, platform: "arch", target_mode: true
+        provides :pacman_package, target_mode: true
 
         use_multipackage_api
         allow_nils
@@ -37,8 +37,8 @@ class Chef
 
           repos = %w{extra core community}
 
-          if ::File.exist?("/etc/pacman.conf")
-            pacman = ::File.read("/etc/pacman.conf")
+          if ::TargetIO::File.exist?("/etc/pacman.conf")
+            pacman = ::TargetIO::File.read("/etc/pacman.conf")
             repos = pacman.scan(/\[(.+)\]/).flatten
           end
 

data/lib/chef/provider/package/paludis.rb

@@ -24,8 +24,8 @@ class Chef
     class Package
       class Paludis < Chef::Provider::Package
 
-        provides :package, platform: "exherbo"
-        provides :paludis_package
+        provides :package, platform: "exherbo", target_mode: true
+        provides :paludis_package, target_mode: true
 
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(new_resource.package_name)

data/lib/chef/provider/package/portage.rb

@@ -38,7 +38,7 @@ class Chef
 
           globsafe_category = category ? Chef::Util::PathHelper.escape_glob_dir(category) : nil
           globsafe_pkg = Chef::Util::PathHelper.escape_glob_dir(pkg)
-          possibilities = Dir["/var/db/pkg/#{globsafe_category || "*"}/#{globsafe_pkg}-*"].map { |d| d.sub(%r{/var/db/pkg/}, "") }
+          possibilities = TargetIO::Dir["/var/db/pkg/#{globsafe_category || "*"}/#{globsafe_pkg}-*"].map { |d| d.sub(%r{/var/db/pkg/}, "") }
           versions = possibilities.map do |entry|
             if entry =~ %r{[^/]+/#{Regexp.escape(pkg)}\-(\d[\.\d]*[a-z]?((_(alpha|beta|pre|rc|p)\d*)*)?(-r\d+)?)}
               [$&, $1]

data/lib/chef/provider/package/powershell.rb

@@ -127,6 +127,7 @@ class Chef
           command.push("-RequiredVersion #{version}") if version
           command.push("-Source #{new_resource.source}") if new_resource.source && cmdlet_name =~ Regexp.union(/Install-Package/, /Find-Package/)
           command.push("-SkipPublisherCheck") if new_resource.skip_publisher_check && cmdlet_name !~ /Find-Package/
+          command.push("-AllowClobber") if new_resource.allow_clobber
           if new_resource.options && cmdlet_name !~ Regexp.union(/Get-Package/, /Find-Package/)
             new_resource.options.each do |arg|
               command.push(arg) unless command.include?(arg)

data/lib/chef/provider/package/rpm.rb

@@ -24,7 +24,7 @@ class Chef
   class Provider
     class Package
       class Rpm < Chef::Provider::Package
-        provides :rpm_package
+        provides :rpm_package, target_mode: true
 
         include Chef::Mixin::GetSourceFromPackage
 
@@ -51,7 +51,7 @@ class Chef
           current_resource.package_name(new_resource.package_name)
 
           if new_resource.source
-            unless uri_scheme?(new_resource.source) || ::File.exist?(new_resource.source)
+            unless uri_scheme?(new_resource.source) || ::TargetIO::File.exist?(new_resource.source)
               @package_source_exists = false
               return
             end

data/lib/chef/provider/package/smartos.rb

@@ -29,8 +29,8 @@ class Chef
       class SmartOS < Chef::Provider::Package
         attr_accessor :is_virtual_package
 
-        provides :package, platform: "smartos"
-        provides :smartos_package
+        provides :package, platform: "smartos", target_mode: true
+        provides :smartos_package, target_mode: true
 
         def load_current_resource
           logger.trace("#{new_resource} loading current resource")

data/lib/chef/provider/package/snap.rb

@@ -218,6 +218,7 @@ class Chef
           waiting = true
           while waiting
             result = get_change_id(id)
+
             case result["result"]["status"]
             when "Do", "Doing", "Undoing", "Undo"
               # Continue
@@ -329,7 +330,7 @@ class Chef
         def generate_snap_json(snap_names, action, channel, options, revision = nil)
           request = {
               "action" => action,
-              "snaps" => snap_names,
+              "snaps" => Array(snap_names),
           }
           if %w{install refresh switch}.include?(action) && channel
             request["channel"] = channel

data/lib/chef/provider/package/snap_tm.rb

@@ -0,0 +1,79 @@
+#
+# Author:: T.Heinen (<thomas.heinen@gmail.com>)
+# 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 "snap"
+
+class Chef
+  class Provider
+    class Package
+      class SnapTM < Chef::Provider::Package::Snap
+        provides :snap_package, target_mode: true
+
+        def install_package(names, versions)
+          if new_resource.source
+            install_snap_from_source(names, new_resource.source)
+          else
+            Array(names).each do |snap|
+              snap_options = new_resource.options
+
+              snapctl([
+                "install",
+                "--channel=#{new_resource.channel}",
+                snap_options&.map { |opt| "--#{opt}" },
+                snap,
+              ].flatten.compact)
+            end
+          end
+        end
+
+        def remove_package(names, versions)
+          Array(names).each do |snap|
+            snapctl([
+              "remove",
+              snap,
+            ])
+          end
+        end
+
+        def snapctl(*args)
+          # Deferred execution can result in exit code 10
+          shell_out!("snap", *args, returns: [0, 10])
+        end
+
+        def get_latest_package_version(name, channel)
+          cmd = shell_out("snap info #{name}")
+          latest = cmd.stdout.lines.detect { |l| l.start_with? "  latest/#{new_resource.channel}:" }
+          return unless latest
+
+          latest.split.at(1)
+        end
+
+        def get_installed_package_by_name(name)
+          cmd = shell_out("snap info #{name}")
+          installed = cmd.stdout.lines.detect { |l| l.start_with? "installed:" }
+          return {} unless installed
+
+          {
+            "name" => name,
+            "version" => installed.split.at(1),
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ class Chef
 
         include Chef::Mixin::GetSourceFromPackage
 
-        provides :solaris_package
+        provides :solaris_package, target_mode: true
 
         # def initialize(*args)
         #   super
@@ -50,7 +50,7 @@ class Chef
           current_resource.package_name(new_resource.package_name)
 
           if new_resource.source
-            @package_source_found = ::File.exist?(new_resource.source)
+            @package_source_found = ::TargetIO::File.exist?(new_resource.source)
             if @package_source_found
               logger.trace("#{new_resource} checking pkg status")
               shell_out("pkginfo", "-l", "-d", new_resource.source, new_resource.package_name).stdout.each_line do |line|
@@ -101,7 +101,7 @@ class Chef
         def install_package(name, version)
           logger.trace("#{new_resource} package install options: #{options}")
           if options.nil?
-            command = if ::File.directory?(new_resource.source) # CHEF-4469
+            command = if ::TargetIO::File.directory?(new_resource.source) # CHEF-4469
                         [ "pkgadd", "-n", "-d", new_resource.source, new_resource.package_name ]
                       else
                         [ "pkgadd", "-n", "-d", new_resource.source, "all" ]
@@ -109,7 +109,7 @@ class Chef
             shell_out!(command)
             logger.trace("#{new_resource} installed version #{new_resource.version} from: #{new_resource.source}")
           else
-            command = if ::File.directory?(new_resource.source) # CHEF-4469
+            command = if ::TargetIO::File.directory?(new_resource.source) # CHEF-4469
                         [ "pkgadd", "-n", options, "-d", new_resource.source, new_resource.package_name ]
                       else
                         [ "pkgadd", "-n", options, "-d", new_resource.source, "all" ]