chef 18.10.17 → 19.2.12

data/lib/chef/target_io/etc.rb

@@ -0,0 +1,16 @@
+module TargetIO
+  class Etc
+    class << self
+      def method_missing(m, *args, **kwargs, &block)
+        Chef::Log.debug format("Etc::%s(%s)", m.to_s, args.join(", "))
+
+        if ChefConfig::Config.target_mode? && !Chef.run_context.transport_connection.os.unix?
+          raise "Etc support only on Unix, this is " + Chef.run_context.transport_connection.platform.title
+        end
+
+        backend = ChefConfig::Config.target_mode? ? TrainCompat::Etc : ::Etc
+        backend.send(m, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/chef/target_io/file.rb

@@ -0,0 +1,12 @@
+module TargetIO
+  class File
+    class << self
+      def method_missing(m, *args, **kwargs, &block)
+        Chef::Log.debug format("File::%s(%s)", m.to_s, args.join(", "))
+
+        backend = ChefConfig::Config.target_mode? ? TrainCompat::File : ::File
+        backend.send(m, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/chef/target_io/fileutils.rb

@@ -0,0 +1,12 @@
+module TargetIO
+  class FileUtils
+    class << self
+      def method_missing(m, *args, **kwargs, &block)
+        Chef::Log.debug format("FileUtils::%s(%s)", m.to_s, args.join(", "))
+
+        backend = ChefConfig::Config.target_mode? ? TrainCompat::FileUtils : ::FileUtils
+        backend.send(m, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/chef/target_io/http.rb

@@ -0,0 +1,35 @@
+require "forwardable" unless defined?(Forwardable)
+
+require_relative "../http/simple"
+require_relative "../json_compat"
+require_relative "train/http"
+
+module TargetIO
+  class HTTP
+    extend Forwardable
+    def_delegators :@http_class, :get, :head, :patch, :post, :put, :delete
+
+    # Only for Chef::Provider::RemoteFile::HTTP
+    def_delegators :@http_class, :streaming_request, :streaming_request_with_progress, :last_response
+
+    def initialize(url, http_client_opts = {})
+      if ::ChefConfig::Config.target_mode?
+        @http_class = TargetIO::TrainCompat::HTTP.new(url, http_client_opts)
+      else
+        @http_class = Chef::HTTP::Simple.new(url, http_client_opts)
+      end
+    end
+
+    class SimpleJSON
+      def initialize(url, http_client_opts = {})
+        @http_class = TargetIO::HTTP.new(url, http_client_opts)
+      end
+
+      def get(path, headers = {})
+        response = @http_class.get(path, headers)
+
+        Chef::JSONCompat.from_json(response)
+      end
+    end
+  end
+end

data/lib/chef/target_io/io.rb

@@ -0,0 +1,12 @@
+module TargetIO
+  class IO
+    class << self
+      def method_missing(m, *args, **kwargs, &block)
+        Chef::Log.debug format("IO::%s(%s)", m.to_s, args.join(", "))
+
+        backend = ChefConfig::Config.target_mode? ? TrainCompat::IO : ::IO
+        backend.send(m, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/chef/target_io/shadow.rb

@@ -0,0 +1,44 @@
+module TargetIO
+  module Shadow
+    # sp_namp - pointer to null-terminated user name.
+    # sp_pwdp - pointer to null-terminated password.
+    # sp_lstchg - days  since  Jan  1,  1970 password was last
+    #             changed.
+    # sp_min - days before which password may not be changed.
+    # sp_max - days after which password must be changed.
+    # sp_warn - days before password is to expire that  user  is
+    #           warned of pending password expiration.
+    # sp_inact  -  days  after  password expires that account is
+    #              considered inactive and disabled.
+    # sp_expire - days since Jan 1, 1970 when  account  will  be
+    #             disabled
+    # sp_loginclass - pointer to null-terminated user login class.
+    Entry = Struct.new(
+      :sp_namp,
+      :sp_pwdp,
+      :sp_lstchg,
+      :sp_min,
+      :sp_max,
+      :sp_warn,
+      :sp_inact,
+      :sp_expire,
+      :sp_loginclass
+    )
+
+    class Passwd
+      class << self
+
+        def method_missing(m, *args, **kwargs, &block)
+          Chef::Log.debug format("Shadow::Passwd::%s(%s)", m.to_s, args.join(", "))
+
+          if ChefConfig::Config.target_mode? && !Chef.run_context.transport_connection.os.unix?
+            raise "Shadow support only on Unix, this is " + Chef.run_context.transport_connection.platform.title
+          end
+
+          backend = ChefConfig::Config.target_mode? ? TrainCompat::Shadow::Passwd : ::Shadow::Passwd
+          backend.send(m, *args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/chef/target_io/support.rb

@@ -0,0 +1,73 @@
+require "tempfile" unless defined?(::Tempfile)
+
+module TargetIO
+  module Support
+    # "sudo" based connections need a staging area for file reading/writing
+    def read_file(filename)
+      accessible_file = filename
+
+      if sudo?
+        accessible_file = staging_file(filename)
+        ::TargetIO::FileUtils.cp(filename, accessible_file)
+      end
+
+      content = transport_connection.file(accessible_file).content
+
+      clean_staging(accessible_file) if sudo?
+
+      content
+    end
+
+    def write_file(remote_file, content)
+      tempfile = ::Tempfile.new
+      tempfile.write(tempfile, content)
+      tempfile.close
+
+      upload(tempfile.path, remote_file)
+      tempfile.unlink
+
+      remote_file
+    end
+
+    def upload(local_file, remote_file)
+      accessible_file = remote_file
+      accessible_file = staging_file(remote_file) if sudo?
+
+      transport_connection.upload(local_file, accessible_file)
+
+      if sudo?
+        ::TargetIO::FileUtils.mv(accessible_file, remote_file)
+        clean_staging(accessible_file)
+      end
+    end
+
+    def staging_file(filename)
+      staging_dir = ::TargetIO::Dir.mktmpdir(filename)
+      ::File.join(staging_dir, ::File.basename(filename))
+    end
+
+    def clean_staging(filename)
+      ::TargetIO::FileUtils.rm(filename)
+
+      staging_dir = ::File.dirname(filename)
+      ::TargetIO::FileUtils.rmdir(staging_dir)
+    rescue Errno::ENOENT
+    end
+
+    def run_command(cmd)
+      transport_connection.run_command(cmd)
+    end
+
+    def sudo?
+      transport_connection.transport_options[:sudo]
+    end
+
+    def remote_user
+      transport_connection.transport_options[:user]
+    end
+
+    def transport_connection
+      Chef.run_context&.transport_connection
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require_relative "file"
+require_relative "fileutils"
+
+require_relative "../support"
+
+module TargetIO
+  module TrainCompat
+    class Dir
+      class << self
+        include TargetIO::Support
+
+        def [](*patterns, base: ".", sort: true)
+          Dir.glob(patterns, 0, base, sort)
+        end
+
+        def delete(dir_name)
+          ::TargetIO::FileUtils.rm_rf(dir_name)
+        end
+
+        def directory?(dir_name)
+          ::TargetIO::File.directory? dir_name
+        end
+
+        def entries(dirname)
+          cmd = "ls -1a #{dirname}"
+          output = run_command(cmd).stdout
+          output.split("\n")
+        end
+
+        def glob(pattern, flags = 0, base: ".", sort: true)
+          raise "Dir.glob flags not supported except FNM_DOTMATCH" unless [0, ::File::FNM_DOTMATCH].include? flags
+
+          pattern  = Array(pattern)
+          matchdot = flags || ::File::FNM_DOTMATCH ? "dotglob" : ""
+
+          cmd += <<-BASH4
+            shopt -s globstar #{matchdot}
+            cd #{base}
+            for f in #{pattern.join(" ")}; do
+              printf '%s\n' "$f";
+            done
+          BASH4
+
+          output = run_command(cmd).stdout
+          files  = output.split("\n")
+          files.sort! if sort
+
+          files
+        end
+
+        def mkdir(dir_name, mode = nil)
+          ::TargetIO::FileUtils.mkdir(dir_name)
+          ::TargetIO::FileUtils.chmod(dir_name, mode) if mode
+        end
+
+        # Borrowed and adapted from Ruby's Dir::tmpdir and Dir::mktmpdir
+        def mktmpdir(prefix_suffix = nil, *rest, **options)
+          prefix, suffix = ::File.basename(prefix_suffix || "d")
+          random = (::Random.urandom(4).unpack1("L") % 36**6).to_s(36)
+
+          t = Time.now.strftime("%Y%m%d%s")
+          path = "#{prefix}#{t}-#{$$}-#{random}" + "#{suffix || ""}"
+          path = ::File.join(tmpdir, path)
+
+          ::TargetIO::FileUtils.mkdir(path)
+          ::TargetIO::FileUtils.chmod(0700, path)
+          ::TargetIO::FileUtils.chown(remote_user, nil, path) if sudo?
+
+          at_exit do
+            ::TargetIO::FileUtils.rm_rf(path)
+          end
+
+          path
+        end
+
+        def tmpdir
+          ::Dir.tmpdir
+        end
+
+        def unlink(dir_name)
+          ::TargetIO::FileUtils.rmdir(dir_name)
+        end
+      end
+    end
+  end
+end

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