chef 18.9.4 → 19.1.164

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

@@ -0,0 +1,108 @@
+require_relative "file"
+
+module TargetIO
+  module TrainCompat
+    class Etc
+      @@cache = {}
+
+      class << self
+        def getpwnam(name)
+          __getpw { |entry| entry["user"] == name }
+        end
+
+        def getpwuid(uid)
+          __getpw { |entry| entry["uid"] == uid.to_i }
+        end
+
+        def getgrnam(name)
+          __getgr { |entry| entry["name"] == name }
+        end
+
+        def getgrgid(gid)
+          __getgr { |entry| entry["gid"] == gid.to_i }
+        end
+
+        def __getpw(&block)
+          content = ::TargetIO::File.read("/etc/passwd")
+          entries = __parse_passwd(content)
+          data    = entries.detect(&block)
+          raise ArgumentError unless data
+
+          ::Etc::Passwd.new(
+            data["user"],
+            data["password"],
+            data["uid"].to_i,
+            data["gid"].to_i,
+            data["desc"],
+            data["home"],
+            data["shell"]
+          )
+        end
+
+        # Parse /etc/passwd files.
+        # Courtesy of InSpec
+        #
+        # @param [String] content the raw content of /etc/passwd
+        # @return [Array] Collection of passwd entries
+        def __parse_passwd(content)
+          content.to_s.split("\n").map do |line|
+            next if line[0] == "#"
+
+            __parse_passwd_line(line)
+          end.compact
+        end
+
+        # Parse a line of /etc/passwd
+        #
+        # @param [String] line a line of /etc/passwd
+        # @return [Hash] Map of entries in this line
+        def __parse_passwd_line(line)
+          x = line.split(":")
+          {
+            # rubocop:disable Layout/AlignHash
+            "user"     => x.at(0),
+            "password" => x.at(1),
+            "uid"      => x.at(2),
+            "gid"      => x.at(3),
+            "desc"     => x.at(4),
+            "home"     => x.at(5),
+            "shell"    => x.at(6),
+          }
+        end
+
+        def __getgr(&block)
+          content = ::TargetIO::File.read("/etc/group")
+          entries = __parse_group(content)
+          data    = entries.detect(&block)
+          raise ArgumentError unless data
+
+          ::Etc::Group.new(
+            data["name"],
+            data["password"],
+            data["gid"].to_i,
+            String(data["mem"]).split(",")
+          )
+        end
+
+        def __parse_group(content)
+          content.to_s.split("\n").map do |line|
+            next if line[0] == "#"
+
+            __parse_group_line(line)
+          end.compact
+        end
+
+        def __parse_group_line(line)
+          x = line.split(":")
+          {
+            # rubocop:disable Layout/AlignHash
+            "name"     => x.at(0),
+            "password" => x.at(1),
+            "gid"      => x.at(2),
+            "mem"      => x.at(3),
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+require_relative "../support"
+
+module TargetIO
+  module TrainCompat
+    class File
+      class << self
+        include TargetIO::Support
+
+        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")
+          raise "TargetIO does not implement block-less File.open with modes other than read yet" if mode != "r" && !block_given?
+
+          content = exist?(file_name) ? 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)
+
+            # Return name of new remote file to be used in later operations
+            file_name = write_file(file_name, new_content) if (content != new_content) && !mode.start_with?("r")
+
+            return file_name
+          end
+
+          io
+        end
+
+        def readlines(file_name)
+          content = read_file(file_name)
+          raise Errno::ENOENT if content.nil? # Not found
+
+          content.split("\n")
+        end
+
+        def executable?(file_name)
+          mode(file_name) & 0111 != 0
+        end
+
+        def readable?(file_name)
+          cmd = format("test -r %s", file_name)
+          run_command(cmd).exit_status == 0
+        end
+
+        def writable?(file_name)
+          cmd = format("test -w %s", file_name)
+          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
+
+          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
+
+          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
+
+        def tempfile(filename)
+          tempdir = ::TargetIO::Dir.mktmpdir(path)
+          ::File.join(tempdir, filename)
+        end
+
+        # passthrough or map calls to third parties
+        def method_missing(m, *args, **kwargs, &block)
+          nonio    = %i{extname join dirname path split}
+          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,
+            unlink: :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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+require_relative "../support"
+
+module TargetIO
+  module TrainCompat
+    class FileUtils
+      class << self
+        include TargetIO::Support
+
+        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
+
+        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
+
+        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
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+require_relative "../support"
+
+module TargetIO
+  module TrainCompat
+    class HTTP
+      include TargetIO::Support
+
+      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
+
+        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)
+        run_command("which #{cmd}").stdout
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,54 @@
+require_relative "../support"
+
+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