chef 18.5.0 → 18.7.3

data/lib/chef/target_io/train/file.rb

@@ -1,219 +0,0 @@
-module TargetIO
-  module TrainCompat
-    class File
-      class << self
-        def foreach(name)
-          raise "TargetIO does not implement block-less File.foreach yet" unless block_given?
-
-          contents = readlines(name)
-          contents.each { |line| yield(line) }
-        end
-
-        def binread(name, length = nil, offset = 0)
-          content = read(file_name)
-          length = content.size - offset if length.nil?
-
-          content[offset, length]
-        end
-
-        def expand_path(file_name, dir_string = "")
-          require "pathname" unless defined?(Pathname)
-
-          # Will just collapse relative paths inside
-          pn = Pathname.new File.join(dir_string, file_name)
-          pn.cleanpath
-        end
-
-        def new(filename, mode = "r")
-          # Would need to hook into io.close (Closure?)
-          raise NotImplementedError, "TargetIO does not implement File.new yet"
-        end
-
-        def read(file_name)
-          readlines(file_name)&.join("\n") || ""
-        end
-
-        def open(file_name, mode = "r")
-          # Would need to hook into io.close (Closure?)
-          raise "TargetIO does not implement block-less File.open with modes other than read yet" if mode != "r" && !block_given?
-
-          content = read(file_name)
-          new_content = content.dup
-
-          io = StringIO.new(new_content)
-
-          if mode.start_with? "w"
-            io.truncate(0)
-          elsif mode.start_with? "a"
-            io.seek(0, IO::SEEK_END)
-          end
-
-          if block_given?
-            yield(io)
-
-            if (content != new_content) && !mode.start_with?("r")
-              __transport_connection.file(file_name).content = new_content # Need Train 2.5+
-            end
-          end
-
-          io
-        end
-
-        def readlines(file_name)
-          content = __transport_connection.file(file_name).content
-          raise Errno::ENOENT if content.nil? # Not found
-
-          content.split("\n")
-        end
-
-        ### START Could be in Train::File::...
-
-        def executable?(file_name)
-          mode(file_name) & 0111 != 0
-        end
-
-        def readable?(file_name)
-          cmd = format("test -r %s", file_name)
-          __transport_connection.run_command(cmd).exit_status == 0
-        end
-
-        def writable?(file_name)
-          cmd = format("test -w %s", file_name)
-          __transport_connection.run_command(cmd).exit_status == 0
-        end
-
-        # def ftype(file_name)
-        #   case type(file_name)
-        #   when :block_device
-        #     "blockSpecial"
-        #   when :character_device
-        #     "characterSpecial"
-        #   when :symlink
-        #     "link"
-        #   else
-        #     type(file_name).to_s
-        #   end
-        # end
-
-        def realpath(file_name)
-          cmd = "realpath #{file_name}" # coreutils, not MacOSX
-          Chef::Log.debug cmd
-
-          __transport_connection.run_command(cmd).stdout.chop
-        end
-
-        def readlink(file_name)
-          raise Errno::EINVAL unless symlink?(file_name)
-
-          cmd = "readlink #{file_name}"
-          Chef::Log.debug cmd
-
-          __transport_connection.run_command(cmd).stdout.chop
-        end
-
-        # def setgid?(file_name)
-        #   mode(file_name) & 04000 != 0
-        # end
-
-        # def setuid?(file_name)
-        #   mode(file_name) & 02000 != 0
-        # end
-
-        # def sticky?(file_name)
-        #   mode(file_name) & 01000 != 0
-        # end
-
-        # def size?(file_name)
-        #   exist?(file_name) && size(file_name) > 0
-        # end
-
-        # def world_readable?(file_name)
-        #   mode(file_name) & 0001 != 0
-        # end
-
-        # def world_writable?(file_name)
-        #   mode(file_name) & 0002 != 0
-        # end
-
-        # def zero?(file_name)
-        #   exists?(file_name) && size(file_name) == 0
-        # end
-
-        ### END: Could be in Train
-
-        # passthrough or map calls to third parties
-        def method_missing(m, *args, **kwargs, &block)
-          nonio    = %i{extname join dirname path split}
-
-          # TODO: writable?
-          passthru = %i{basename directory? exist? exists? file? path pipe? socket? symlink?}
-          redirect_train = {
-            blockdev?: :block_device?,
-            chardev?: :character_device?,
-          }
-          redirect_utils = {
-            chown: :chown,
-            chmod: :chmod,
-            symlink: :ln_s,
-            delete: :rm,
-          }
-          filestat = %i{gid group mode owner selinux_label size uid}
-
-          if %i{stat lstat}.include? m
-            Chef::Log.debug "File::#{m} passed to Train.file.stat"
-
-            follow_symlink = m == :stat
-            tfile = __transport_connection.file(args[0], follow_symlink).stat
-
-            require "ostruct" unless defined?(OpenStruct)
-            OpenStruct.new(tfile)
-
-          # Non-IO methods can be issued locally
-          elsif nonio.include? m
-            ::File.send(m, *args, **kwargs) # TODO: pass block
-
-          elsif passthru.include? m
-            Chef::Log.debug "File::#{m} passed to Train.file.#{m}"
-
-            file_name, other_args = args[0], args[1..]
-
-            file = __transport_connection.file(file_name)
-            file.send(m, *other_args, **kwargs) # block?
-
-          elsif m == :mtime
-            # Solve a data type disparity between Train.file and File
-            timestamp = __transport_connection.file(args[0]).mtime
-            Time.at(timestamp)
-
-          elsif filestat.include? m
-            Chef::Log.debug "File::#{m} passed to Train.file.stat.#{m}"
-
-            __transport_connection.file(args[0]).stat[m]
-
-          elsif redirect_utils.key?(m)
-            new_method = redirect_utils[m]
-            Chef::Log.debug "File::#{m} redirected to TargetIO::FileUtils.#{new_method}"
-
-            ::TargetIO::FileUtils.send(new_method, *args, **kwargs) # TODO: pass block
-
-          elsif redirect_train.key?(m)
-            new_method = redirect_train[m]
-            Chef::Log.debug "File::#{m} redirected to Train.file.#{new_method}"
-
-            file_name, other_args = args[0], args[1..]
-
-            file = __transport_connection.file(file_name)
-            file.send(redirect[m], *other_args, **kwargs) # TODO: pass block
-
-          else
-            raise "Unsupported File method #{m}"
-          end
-        end
-
-        def __transport_connection
-          Chef.run_context&.transport_connection
-        end
-      end
-    end
-  end
-end

data/lib/chef/target_io/train/fileutils.rb

@@ -1,220 +0,0 @@
-module TargetIO
-  module TrainCompat
-    class FileUtils
-      class << self
-        def chmod(mode, list, noop: nil, verbose: nil)
-          cmd = sprintf("chmod %s %s", __mode_to_s(mode), Array(list).join(" "))
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def chmod_R(mode, list, noop: nil, verbose: nil, force: nil)
-          cmd = sprintf("chmod -R%s %s %s", (force ? "f" : ""), mode_to_s(mode), Array(list).join(" "))
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def chown(user, group, list, noop: nil, verbose: nil)
-          cmd = sprintf("chown %s %s", (group ? "#{user}:#{group}" : user || ":"), Array(list).join(" "))
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def chown_R(user, group, list, noop: nil, verbose: nil, force: nil)
-          cmd = sprintf("chown -R%s %s %s", (force ? "f" : ""), (group ? "#{user}:#{group}" : user || ":"), Array(list).join(" "))
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        # cmp
-        # collect_method
-        # commands
-        # compare_file
-        # compare_stream
-
-        def cp(src, dest, preserve: nil, noop: nil, verbose: nil)
-          cmd = "cp#{preserve ? " -p" : ""} #{[src, dest].flatten.join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-        alias_method :copy, :cp
-
-        def cp_lr(src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)
-          cmd = "cp -lr#{remove_destination ? " --remove-destination" : ""} #{[src, dest].flatten.join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def cp_r(src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)
-          cmd = "cp -r#{preserve ? "p" : ""}#{remove_destination ? " --remove-destination" : ""} #{[src, dest].flatten.join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        # getwd (alias pwd)
-        # have_option?
-        # identical? (alias compare_file)
-
-        def install(src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)
-          cmd = "install -c"
-          cmd << " -p" if preserve
-          cmd << " -m " << mode_to_s(mode) if mode
-          cmd << " -o #{owner}" if owner
-          cmd << " -g #{group}" if group
-          cmd << " " << [src, dest].flatten.join(" ")
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def ln(src, dest, force: nil, noop: nil, verbose: nil)
-          cmd = "ln#{force ? " -f" : ""} #{[src, dest].flatten.join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-        alias_method :link, :ln
-
-        def ln_s(src, dest, force: nil, noop: nil, verbose: nil)
-          cmd = "ln -s#{force ? "f" : ""} #{[src, dest].flatten.join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-        alias_method :symlink, :ln_s
-
-        def ln_sf(src, dest, noop: nil, verbose: nil)
-          ln_s(src, dest, force: true, noop: noop, verbose: verbose)
-        end
-
-        def mkdir(list, mode: nil, noop: nil, verbose: nil)
-          cmd = "mkdir #{mode ? ("-m %03o " % mode) : ""}#{Array(list).join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def mkdir_p(list, mode: nil, noop: nil, verbose: nil)
-          cmd = "mkdir -p #{mode ? ("-m %03o " % mode) : ""}#{Array(list).join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-        alias_method :makedirs, :mkdir_p
-        alias_method :mkpath, :mkdir_p
-
-        def mv(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)
-          cmd = "mv#{force ? " -f" : ""} #{[src, dest].flatten.join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        # options
-        # options_of
-        # pwd
-        # remove
-        # remove_entry_secure
-        # remove_file
-
-        def rm(list, force: nil, noop: nil, verbose: nil)
-          cmd = "rm#{force ? " -f" : ""} #{Array(list).join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def rm_f(list, force: nil, noop: nil, verbose: nil, secure: nil)
-          rm(list, force: true, noop: noop, verbose: verbose)
-        end
-
-        def rm_r(list, force: nil, noop: nil, verbose: nil, secure: nil)
-          cmd = "rm -r#{force ? "f" : ""} #{Array(list).join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def rm_rf(list, noop: nil, verbose: nil, secure: nil)
-          rm_r(list, force: true, noop: noop, verbose: verbose, secure: secure)
-        end
-        alias_method :remove_entry, :rm_rf
-        alias_method :rmtree, :rm_rf
-        alias_method :safe_unlink, :rm_rf
-
-        def rmdir(list, parents: nil, noop: nil, verbose: nil)
-          cmd = "rmdir #{parents ? "-p " : ""}#{Array(list).join(" ")}"
-
-          Chef::Log.debug cmd if verbose
-          return if noop
-
-          __run_command(cmd)
-        end
-
-        def touch(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)
-          return if noop
-
-          __run_command "touch #{nocreate ? "-c " : ""}#{mtime ? mtime.strftime("-t %Y%m%d%H%M.%S ") : ""}#{Array(list).join(" ")}"
-        end
-
-        # uptodate?
-
-        def method_missing(m, *_args, **_kwargs, &_block)
-          raise "Unsupported #{self.class} method #{m}"
-        end
-
-        private
-
-        # TODO: Symbolic modes
-        def __mode_to_s(mode)
-          mode.to_s(8)
-        end
-
-        def __run_command(cmd)
-          __transport_connection.run_command(cmd)
-        end
-
-        def __transport_connection
-          Chef.run_context&.transport_connection
-        end
-      end
-    end
-  end
-end

data/lib/chef/target_io/train/http.rb

@@ -1,117 +0,0 @@
-# require_relative "../mixin/which"
-
-module TargetIO
-  module TrainCompat
-    class HTTP
-      attr_reader :last_response
-
-      def initialize(url, options = {})
-        @url = url.is_a?(URI) ? url.to_s : url
-        @options = options
-        @last_response = ""
-      end
-
-      # Send an HTTP HEAD request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def head(path, headers = {})
-        request(:HEAD, path, headers)
-      end
-
-      # Send an HTTP GET request to the path
-      #
-      # === Parameters
-      # path:: The path to GET
-      def get(path, headers = {})
-        request(:GET, path, headers)
-      end
-
-      # Send an HTTP PUT request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def put(path, json, headers = {})
-        request(:PUT, path, headers, json)
-      end
-
-      # Send an HTTP POST request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def post(path, json, headers = {})
-        request(:POST, path, headers, json)
-      end
-
-      # Send an HTTP DELETE request to the path
-      #
-      # === Parameters
-      # path:: path part of the request URL
-      def delete(path, headers = {})
-        request(:DELETE, path, headers)
-      end
-
-      # Used inside Chef::Provider::RemoteFile::HTTPS
-      def streaming_request(path, headers = {}, tempfile = nil)
-        content = get(path, headers)
-        @last_response = content
-
-        tempfile.write(content)
-        tempfile.close
-
-        tempfile
-      end
-
-      def request(method, path, headers = {}, data = false)
-        cmd = nil
-        path = path.is_a?(URI) ? path.to_s : path
-        headers.merge!(@options[:headers] || {})
-
-        SUPPORTED_COMMANDS.each do |command_name|
-          executable = which(command_name).chop
-          next if !executable || executable.empty?
-
-          # There are different ways to call (constructor, argument, combination of both)
-          full_url = if path.start_with?("http")
-                       path
-                     elsif path.empty? || @url.end_with?(path)
-                       @url
-                     else
-                       File.join(@url, path)
-                     end
-
-          cmd = send(command_name.to_sym, executable, method.to_s.upcase, full_url, headers, data)
-          break
-        end
-
-        raise "Target needs one of #{SUPPORTED_COMMANDS.join("/")} for HTTP requests to work" unless cmd
-
-        connection = Chef.run_context&.transport_connection
-        connection.run_command(cmd).stdout
-      end
-
-      SUPPORTED_COMMANDS = %w{curl wget}.freeze
-
-      # Sending data is not yet supported
-      def curl(cmd, method, url, headers, _data)
-        cmd += headers.map { |name, value| " --header '#{name}: #{value}'" }.join
-        cmd += " --request #{method} "
-        cmd += url
-      end
-
-      # Sending data is not yet supported
-      def wget(cmd, method, url, headers, _data)
-        cmd += headers.map { |name, value| " --header '#{name}: #{value}'" }.join
-        cmd += " --method #{method}"
-        cmd += " --output-document=- "
-        cmd += url
-      end
-
-      # extend Chef::Mixin::Which
-      def which(cmd)
-        connection = Chef.run_context&.transport_connection
-        connection.run_command("which #{cmd}").stdout
-      end
-    end
-  end
-end

data/lib/chef/target_io/train/io.rb

@@ -1,13 +0,0 @@
-require_relative "file"
-
-module TargetIO
-  module TrainCompat
-    class IO
-      class << self
-        def read(path)
-          TargetIO::File.read(path)
-        end
-      end
-    end
-  end
-end

data/lib/chef/target_io/train/shadow.rb

@@ -1,52 +0,0 @@
-module TargetIO
-  module TrainCompat
-    module Shadow
-      # @see https://www.rubydoc.info/gems/ruby-shadow/2.5.0
-      class Passwd
-        class << self
-          def getspnam(name)
-            content = ::TargetIO::File.read("/etc/shadow")
-            entries = __parse_shadow(content)
-            data    = entries.detect { |entry| entry["name"] == name }
-            return ::TargetIO::Shadow::Entry.new unless data
-
-            ::TargetIO::Shadow::Entry.new(
-              data["sp_namp"],
-              data["sp_pwdp"],
-              data["sp_lstchg"],
-              data["sp_min"],
-              data["sp_max"],
-              data["sp_warn"],
-              data["sp_inact"],
-              data["sp_expire"],
-              data["sp_loginclass"]
-            )
-          end
-
-          def __parse_shadow(content)
-            content.to_s.split("\n").map do |line|
-              next if line[0] == "#"
-
-              __parse_shadow_line(line)
-            end.compact
-          end
-
-          def __parse_shadow_line(line)
-            x = line.split(":")
-            {
-              # rubocop:disable Layout/AlignHash
-              "sp_namp"   => x.at(0),
-              "sp_pwdp"   => x.at(1),
-              "sp_lstchg" => x.at(2),
-              "sp_min"    => x.at(3),
-              "sp_max"    => x.at(4),
-              "sp_warn"   => x.at(5),
-              "sp_inact"  => x.at(6),
-              "sp_expire" => x.at(7),
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chef/target_io/train_compat.rb

@@ -1,7 +0,0 @@
-require_relative "train/dir"
-require_relative "train/etc"
-require_relative "train/file"
-require_relative "train/fileutils"
-require_relative "train/http"
-require_relative "train/io"
-require_relative "train/shadow"

data/lib/chef/target_io.rb

@@ -1,9 +0,0 @@
-require_relative "target_io/dir"
-require_relative "target_io/etc"
-require_relative "target_io/file"
-require_relative "target_io/fileutils"
-require_relative "target_io/http"
-require_relative "target_io/io"
-require_relative "target_io/shadow"
-
-require_relative "target_io/train_compat"