chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

data/lib/chef/provider/package/yum/yum_helper.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
+
+#
+# NOTE: this actually needs to run under python2.4 and centos 5.x through python3 and centos 7.x
+# please manually test changes on centos5 boxes or you will almost certainly break things.
+#
+
+import sys
+import yum
+import signal
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'simplejson'))
+try: import json
+except ImportError: import simplejson as json
+import re
+from rpmUtils.miscutils import stringToVersion,compareEVR
+from rpmUtils.arch import getBaseArch, getArchList
+
+
+try: from yum.misc import string_to_prco_tuple
+except ImportError:
+    # RHEL5 compat
+    def string_to_prco_tuple(prcoString):
+        prco_split = prcoString.split()
+        n, f, v = prco_split
+        (prco_e, prco_v, prco_r) = stringToVersion(v)
+        return (n, f, (prco_e, prco_v, prco_r))
+
+base = None
+
+def get_base():
+    global base
+    if base is None:
+        base = yum.YumBase()
+    setup_exit_handler()
+    return base
+
+def versioncompare(versions):
+    arch_list = getArchList()
+    candidate_arch1 = versions[0].split(".")[-1]
+    candidate_arch2 = versions[1].split(".")[-1]
+
+    # The first version number passed to this method is always a valid nevra (the current version)
+    # If the second version number looks like it does not contain a valid arch
+    # then we'll chop the arch component (assuming it *is* a valid one) from the first version string
+    # so we're only comparing the evr portions.
+    if (candidate_arch2 not in arch_list) and (candidate_arch1 in arch_list):
+       final_version1 = versions[0].replace("." + candidate_arch1,"")
+    else:
+       final_version1 = versions[0]
+
+    final_version2 = versions[1]
+
+    (e1, v1, r1) = stringToVersion(final_version1)
+    (e2, v2, r2) = stringToVersion(final_version2)
+
+    evr_comparison = compareEVR((e1, v1, r1), (e2, v2, r2))
+    outpipe.write("%(e)s\n" % { 'e': evr_comparison })
+    outpipe.flush()
+
+def install_only_packages(name):
+    base = get_base()
+    if name in base.conf.installonlypkgs:
+      outpipe.write('True')
+    else:
+      outpipe.write('False')
+    outpipe.flush()
+
+# python2.4 / centos5 compat
+try:
+    any
+except NameError:
+    def any(s):
+        for v in s:
+            if v:
+                return True
+        return False
+
+def query(command):
+    base = get_base()
+
+    enabled_repos = base.repos.listEnabled()
+
+    # Handle any repocontrols passed in with our options
+    if 'enablerepos' in command:
+      base.repos.enableRepo(*command['enablerepos'])
+
+    if 'disablerepos' in command:
+      base.repos.disableRepo(*command['disablerepos'])
+
+    args = { 'name': command['provides'] }
+    do_nevra = False
+    if 'epoch' in command:
+        args['epoch'] = command['epoch']
+        do_nevra = True
+    if 'version' in command:
+        args['ver'] = command['version']
+        do_nevra = True
+    if 'release' in command:
+        args['rel'] = command['release']
+        do_nevra = True
+    if 'arch' in command:
+        desired_arch = command['arch']
+        args['arch'] = command['arch']
+        do_nevra = True
+    else:
+        desired_arch = getBaseArch()
+
+    obj = None
+    if command['action'] == "whatinstalled":
+        obj = base.rpmdb
+    else:
+        obj = base.pkgSack
+
+    # if we are given "name == 1.2.3" then we must use the getProvides() API.
+    #   - this means that we ignore arch and version properties when given prco tuples as a package_name
+    #   - in order to fix this, something would have to happen where getProvides was called first and
+    #     then the result was searchNevra'd.  please be extremely careful if attempting to fix that
+    #     since searchNevra does not support prco tuples.
+    if any(elem in command['provides'] for elem in r"<=>"):
+        # handles flags (<, >, =, etc) and versions, but no wildcareds 
+        pkgs = obj.getProvides(*string_to_prco_tuple(command['provides']))
+    elif do_nevra:
+        # now if we're given version or arch properties explicitly, then we do a SearchNevra.
+        #  - this means that wildcard version in the package_name with an arch property will not work correctly
+        #  - again don't try to fix this just by pushing bugs around in the code, you would need to call
+        #    returnPackages and searchProvides and then apply the Nevra filters to those results.
+        pkgs = obj.searchNevra(**args)
+        if (command['action'] == "whatinstalled") and (not pkgs):
+          pkgs = obj.searchNevra(name=args['name'], arch=desired_arch)
+    else:
+        pats = [command['provides']]
+        pkgs = obj.returnPackages(patterns=pats)
+
+        if not pkgs:
+            # handles wildcards
+            pkgs = obj.searchProvides(command['provides'])
+
+    if not pkgs:
+        outpipe.write(command['provides'].split().pop(0)+' nil nil\n')
+        outpipe.flush()
+    else:
+        # make sure we picked the package with the highest version
+        pkgs = base.bestPackagesFromList(pkgs,single_name=True)
+        pkg = pkgs.pop(0)
+        outpipe.write("%(n)s %(e)s:%(v)s-%(r)s %(a)s\n" % { 'n': pkg.name, 'e': pkg.epoch, 'v': pkg.version, 'r': pkg.release, 'a': pkg.arch })
+        outpipe.flush()
+
+    # Reset any repos we were passed in enablerepo/disablerepo to the original state in enabled_repos
+    if 'enablerepos' in command:
+        for repo in command['enablerepos']:
+            if base.repos.getRepo(repo) not in enabled_repos:
+                base.repos.disableRepo(repo)
+
+    if 'disablerepos' in command:
+        for repo in command['disablerepos']:
+            if base.repos.getRepo(repo) in enabled_repos:
+                base.repos.enableRepo(repo)
+
+# the design of this helper is that it should try to be 'brittle' and fail hard and exit in order
+# to keep process tables clean.  additional error handling should probably be added to the retry loop
+# on the ruby side.
+def exit_handler(signal, frame):
+    base.closeRpmDB()
+    sys.exit(0)
+
+def setup_exit_handler():
+    signal.signal(signal.SIGINT, exit_handler)
+    signal.signal(signal.SIGHUP, exit_handler)
+    signal.signal(signal.SIGPIPE, exit_handler)
+    signal.signal(signal.SIGQUIT, exit_handler)
+
+if len(sys.argv) < 3:
+  inpipe = sys.stdin
+  outpipe = sys.stdout
+else:
+  inpipe = os.fdopen(int(sys.argv[1]), "r")
+  outpipe = os.fdopen(int(sys.argv[2]), "w")
+
+while 1:
+    # kill self if we get orphaned (tragic)
+    ppid = os.getppid()
+    if ppid == 1:
+        sys.exit(0)
+    setup_exit_handler()
+    line = inpipe.readline()
+    command = json.loads(line)
+    if command['action'] == "whatinstalled":
+        query(command)
+    elif command['action'] == "whatavailable":
+        query(command)
+    elif command['action'] == "versioncompare":
+        versioncompare(command['versions'])
+    elif command['action'] == "installonlypkgs":
+         install_only_packages(command['package'])
+    else:
+        raise RuntimeError("bad command")

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

@@ -29,24 +29,24 @@ class Chef
         use_multipackage_api
 
         provides :package, platform_family: "suse"
-        provides :zypper_package, os: "linux"
+        provides :zypper_package
 
         def get_versions(package_name)
           candidate_version = current_version = nil
           is_installed = false
-          Chef::Log.debug("#{new_resource} checking zypper")
+          logger.trace("#{new_resource} checking zypper")
           status = shell_out_compact_timeout!("zypper", "--non-interactive", "info", package_name)
           status.stdout.each_line do |line|
             case line
             when /^Version *: (.+) *$/
               candidate_version = $1.strip
-              Chef::Log.debug("#{new_resource} version #{candidate_version}")
-            when /^Installed *: Yes *$/
+              logger.trace("#{new_resource} version #{candidate_version}")
+            when /^Installed *: Yes.*$/ # http://rubular.com/r/9StcAMjOn6
               is_installed = true
-              Chef::Log.debug("#{new_resource} is installed")
+              logger.trace("#{new_resource} is installed")
             when /^Status *: out-of-date \(version (.+) installed\) *$/
               current_version = $1.strip
-              Chef::Log.debug("#{new_resource} out of date version #{current_version}")
+              logger.trace("#{new_resource} out of date version #{current_version}")
             end
           end
           current_version = candidate_version if is_installed
@@ -76,15 +76,11 @@ class Chef
         end
 
         def package_locked(name, version)
-          islocked = false
           locked = shell_out_compact_timeout!("zypper", "locks")
-          locked.stdout.each_line do |line|
-            line_package = line.split("|").shift(2).last.strip
-            if line_package == name
-              islocked = true
-            end
+          locked_packages = locked.stdout.each_line.map do |line|
+            line.split("|").shift(2).last.strip
           end
-          islocked
+          name.all? { |n| locked_packages.include? n }
         end
 
         def load_current_resource

data/lib/chef/provider/powershell_script.rb

@@ -23,7 +23,7 @@ class Chef
   class Provider
     class PowershellScript < Chef::Provider::WindowsScript
 
-      provides :powershell_script, os: "windows"
+      provides :powershell_script
 
       def initialize(new_resource, run_context)
         super(new_resource, run_context, ".ps1")
@@ -73,8 +73,8 @@ class Chef
       # special handling to cover common use cases.
       def add_exit_status_wrapper
         self.code = wrapper_script
-        Chef::Log.debug("powershell_script provider called with script code:\n\n#{new_resource.code}\n")
-        Chef::Log.debug("powershell_script provider will execute transformed code:\n\n#{code}\n")
+        logger.trace("powershell_script provider called with script code:\n\n#{new_resource.code}\n")
+        logger.trace("powershell_script provider will execute transformed code:\n\n#{code}\n")
       end
 
       def validate_script_syntax!

data/lib/chef/provider/reboot.rb

@@ -54,14 +54,14 @@ class Chef
 
       def action_request_reboot
         converge_by("request a system reboot to occur if the run succeeds") do
-          Chef::Log.warn "Reboot requested:'#{new_resource.name}'"
+          logger.warn "Reboot requested:'#{new_resource.name}'"
           request_reboot
         end
       end
 
       def action_reboot_now
         converge_by("rebooting the system immediately") do
-          Chef::Log.warn "Rebooting system immediately, requested by '#{new_resource.name}'"
+          logger.warn "Rebooting system immediately, requested by '#{new_resource.name}'"
           request_reboot
           throw :end_client_run_early
         end
@@ -69,7 +69,7 @@ class Chef
 
       def action_cancel
         converge_by("cancel any existing end-of-run reboot request") do
-          Chef::Log.warn "Reboot canceled: '#{new_resource.name}'"
+          logger.warn "Reboot canceled: '#{new_resource.name}'"
           node.run_context.cancel_reboot
         end
       end

data/lib/chef/provider/registry_key.rb

@@ -126,12 +126,18 @@ class Chef
               value[:data] = value[:data].to_i
             end
             unless current_value[:type] == value[:type] && current_value[:data] == value[:data]
-              converge_by("set value #{value}") do
+              converge_by_value = value
+              converge_by_value[:data] = "*sensitive value suppressed*" if new_resource.sensitive
+
+              converge_by("set value #{converge_by_value}") do
                 registry.set_value(new_resource.key, value)
               end
             end
           else
-            converge_by("set value #{value}") do
+            converge_by_value = value
+            converge_by_value[:data] = "*sensitive value suppressed*" if new_resource.sensitive
+
+            converge_by("set value #{converge_by_value}") do
               registry.set_value(new_resource.key, value)
             end
           end
@@ -146,7 +152,10 @@ class Chef
         end
         new_resource.unscrubbed_values.each do |value|
           unless @name_hash.has_key?(value[:name].downcase)
-            converge_by("create value #{value}") do
+            converge_by_value = value
+            converge_by_value[:data] = "*sensitive value suppressed*" if new_resource.sensitive
+
+            converge_by("create value #{converge_by_value}") do
               registry.set_value(new_resource.key, value)
             end
           end
@@ -157,7 +166,10 @@ class Chef
         if registry.key_exists?(new_resource.key)
           new_resource.unscrubbed_values.each do |value|
             if @name_hash.has_key?(value[:name].downcase)
-              converge_by("delete value #{value}") do
+              converge_by_value = value
+              converge_by_value[:data] = "*sensitive value suppressed*" if new_resource.sensitive
+
+              converge_by("delete value #{converge_by_value}") do
                 registry.delete_value(new_resource.key, value)
               end
             end

data/lib/chef/provider/remote_directory.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -47,8 +47,6 @@ class Chef
         !!@overwrite
       end
 
-      attr_accessor :managed_files
-
       # Hash containing keys of the paths for all the files that we sync, plus all their
       # parent directories.
       #

data/lib/chef/provider/remote_file/cache_control_data.rb

@@ -153,7 +153,7 @@ class Chef
             if Chef::FileCache.has_key?(old_path)
               # We found an old cache control data file. We started using sha256 instead of md5
               # to name these. Upgrade the file to the new name.
-              Chef::Log.debug("Found old cache control data file at #{old_path}. Moving to #{path}.")
+              Chef::Log.trace("Found old cache control data file at #{old_path}. Moving to #{path}.")
               Chef::FileCache.load(old_path).tap do |data|
                 Chef::FileCache.store(path, data)
                 Chef::FileCache.delete(old_path)

data/lib/chef/provider/remote_file/content.rb

@@ -32,10 +32,10 @@ class Chef
         include Chef::Mixin::Uris
 
         def file_for_provider
-          Chef::Log.debug("#{@new_resource} checking for changes")
+          logger.trace("#{@new_resource} checking for changes")
 
           if current_resource_matches_target_checksum?
-            Chef::Log.debug("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
+            logger.trace("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
           else
             sources = @new_resource.source
             raw_file = try_multiple_sources(sources)
@@ -55,9 +55,9 @@ class Chef
                   end
             raw_file = grab_file_from_uri(uri)
           rescue SocketError, Errno::ECONNREFUSED, Errno::ENOENT, Errno::EACCES, Timeout::Error, Net::HTTPServerException, Net::HTTPFatalError, Net::FTPError, Errno::ETIMEDOUT => e
-            Chef::Log.warn("#{@new_resource} cannot be downloaded from #{source}: #{e}")
+            logger.warn("#{@new_resource} cannot be downloaded from #{source}: #{e}")
             if source = sources.shift
-              Chef::Log.info("#{@new_resource} trying to download from another mirror")
+              logger.info("#{@new_resource} trying to download from another mirror")
               retry
             else
               raise e

data/lib/chef/provider/remote_file/http.rb

@@ -31,12 +31,14 @@ class Chef
         attr_reader :uri
         attr_reader :new_resource
         attr_reader :current_resource
+        attr_reader :logger
 
         # Parse the uri into instance variables
-        def initialize(uri, new_resource, current_resource)
+        def initialize(uri, new_resource, current_resource, logger = Chef::Log.with_child)
           @uri = uri
           @new_resource = new_resource
           @current_resource = current_resource
+          @logger = logger
         end
 
         def events
@@ -55,7 +57,7 @@ class Chef
           if (etag = cache_control_data.etag) && want_etag_cache_control?
             cache_control_headers["if-none-match"] = etag
           end
-          Chef::Log.debug("Cache control headers: #{cache_control_headers.inspect}")
+          logger.trace("Cache control headers: #{cache_control_headers.inspect}")
           cache_control_headers
         end
 
@@ -129,7 +131,7 @@ class Chef
           # case you'd end up with a tar archive (no gzip) named, e.g., foo.tgz,
           # which is not what you wanted.
           if uri.to_s =~ /gz$/
-            Chef::Log.debug("Turning gzip compression off due to filename ending in gz")
+            logger.trace("Turning gzip compression off due to filename ending in gz")
             opts[:disable_gzip] = true
           end
           opts

data/lib/chef/provider/remote_file/local_file.rb

@@ -48,7 +48,7 @@ class Chef
         # Fetches the file at uri, returning a Tempfile-like File handle
         def fetch
           tempfile = Chef::FileContentManagement::Tempfile.new(new_resource).tempfile
-          Chef::Log.debug("#{new_resource} staging #{source_path} to #{tempfile.path}")
+          Chef::Log.trace("#{new_resource} staging #{source_path} to #{tempfile.path}")
           FileUtils.cp(source_path, tempfile.path)
           tempfile.close if tempfile
           tempfile

data/lib/chef/provider/remote_file/network_file.rb

@@ -41,9 +41,9 @@ class Chef
         def fetch
           begin
             tempfile = Chef::FileContentManagement::Tempfile.new(new_resource).tempfile
-            Chef::Log.debug("#{new_resource} staging #{@source} to #{tempfile.path}")
+            Chef::Log.trace("#{new_resource} staging #{@source} to #{tempfile.path}")
 
-            with_user_context(new_resource.remote_user, new_resource.remote_password, new_resource.remote_domain) do
+            with_user_context(new_resource.remote_user, new_resource.remote_password, new_resource.remote_domain, new_resource.authentication) do
               ::File.open(@source, "rb") do |remote_file|
                 while data = remote_file.read(TRANSFER_CHUNK_SIZE)
                   tempfile.write(data)

data/lib/chef/provider/route.rb

@@ -77,7 +77,7 @@ class Chef
         begin
           IPAddr.new(ip, Socket::AF_INET).to_s
         rescue ArgumentError
-          Chef::Log.debug("Invalid IP address data: hex=#{hex_ip}, ip=#{ip}")
+          logger.trace("Invalid IP address data: hex=#{hex_ip}, ip=#{ip}")
           return nil
         end
       end
@@ -111,7 +111,7 @@ class Chef
 
           # Skip formatting lines (header, etc)
           next unless destination && gateway && mask
-          Chef::Log.debug("#{new_resource} system has route: dest=#{destination} mask=#{mask} gw=#{gateway}")
+          logger.trace("#{new_resource} system has route: dest=#{destination} mask=#{mask} gw=#{gateway}")
 
           # check if what were trying to configure is already there
           # use an ipaddr object with ip/mask this way we can have
@@ -119,7 +119,7 @@ class Chef
           # expanding bitmask by hand.
           #
           running_ip = IPAddr.new("#{destination}/#{mask}")
-          Chef::Log.debug("#{new_resource} new ip: #{new_ip.inspect} running ip: #{running_ip.inspect}")
+          logger.trace("#{new_resource} new ip: #{new_ip.inspect} running ip: #{running_ip.inspect}")
           self.is_running = true if running_ip == new_ip && gateway == new_resource.gateway
         end
 
@@ -129,12 +129,12 @@ class Chef
       def action_add
         # check to see if load_current_resource found the route
         if is_running
-          Chef::Log.debug("#{new_resource} route already active - nothing to do")
+          logger.trace("#{new_resource} route already active - nothing to do")
         else
           command = generate_command(:add)
           converge_by("run #{command.join(' ')} to add route") do
             shell_out_compact!(command)
-            Chef::Log.info("#{new_resource} added")
+            logger.info("#{new_resource} added")
           end
         end
 
@@ -147,10 +147,10 @@ class Chef
           command = generate_command(:delete)
           converge_by("run #{command.join(' ')} to delete route ") do
             shell_out_compact!(command)
-            Chef::Log.info("#{new_resource} removed")
+            logger.info("#{new_resource} removed")
           end
         else
-          Chef::Log.debug("#{new_resource} route does not exist - nothing to do")
+          logger.trace("#{new_resource} route does not exist - nothing to do")
         end
 
         # for now we always write the file (ugly but its what it is)
@@ -174,18 +174,18 @@ class Chef
             conf[dev] = "" if conf[dev].nil?
             case @action
             when :add
-              conf[dev] << config_file_contents(:add, target: resource.target, netmask: resource.netmask, gateway: resource.gateway) if resource.action == [:add]
+              conf[dev] << config_file_contents(:add, comment: resource.comment, target: resource.target, netmask: resource.netmask, gateway: resource.gateway) if resource.action == [:add]
             when :delete
               # need to do this for the case when the last route on an int
               # is removed
               conf[dev] << config_file_contents(:delete)
             end
           end
-          conf.each do |k, v|
+          conf.each_key do |k|
             if new_resource.target == "default"
               network_file_name = "/etc/sysconfig/network"
               converge_by("write route default route to #{network_file_name}") do
-                Chef::Log.debug("#{new_resource} writing default route #{new_resource.gateway} to #{network_file_name}")
+                logger.trace("#{new_resource} writing default route #{new_resource.gateway} to #{network_file_name}")
                 if ::File.exist?(network_file_name)
                   network_file = ::Chef::Util::FileEdit.new(network_file_name)
                   network_file.search_file_replace_line /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"
@@ -202,7 +202,7 @@ class Chef
               converge_by("write route route.#{k}\n#{conf[k]} to #{network_file_name}") do
                 network_file = ::File.new(network_file_name, "w")
                 network_file.puts(conf[k])
-                Chef::Log.debug("#{new_resource} writing route.#{k}\n#{conf[k]}")
+                logger.trace("#{new_resource} writing route.#{k}\n#{conf[k]}")
                 network_file.close
               end
             end
@@ -231,6 +231,7 @@ class Chef
         content = ""
         case action
         when :add
+          content << "# #{options[:comment]}\n" if options[:comment]
           content << (options[:target]).to_s
           content << "/#{MASK[options[:netmask].to_s]}" if options[:netmask]
           content << " via #{options[:gateway]}" if options[:gateway]