train 3.2.14 → 3.2.20

data/lib/train/extras/stat.rb

@@ -1,136 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-module Train::Extras
-  class Stat
-    TYPES = {
-      socket: 00140000,
-      symlink: 00120000,
-      file: 00100000,
-      block_device: 00060000,
-      directory: 00040000,
-      character_device: 00020000,
-      pipe: 00010000,
-    }.freeze
-
-    def self.find_type(mode)
-      res = TYPES.find { |_, mask| mask & mode == mask }
-      res.nil? ? :unknown : res[0]
-    end
-
-    def self.stat(shell_escaped_path, backend, follow_symlink)
-      # use perl scripts for aix, solaris 10 and hpux
-      if backend.os.aix? || (backend.os.solaris? && backend.os[:release].to_i < 11) || backend.os.hpux?
-        return aix_stat(shell_escaped_path, backend, follow_symlink)
-      end
-      return bsd_stat(shell_escaped_path, backend, follow_symlink) if backend.os.bsd?
-      # linux,solaris 11 and esx will use standard linux stats
-      return linux_stat(shell_escaped_path, backend, follow_symlink) if backend.os.unix? || backend.os.esx?
-
-      # all other cases we don't handle
-      # TODO: print an error if we get here, as it shouldn't be invoked
-      # on non-unix
-      {}
-    end
-
-    def self.linux_stat(shell_escaped_path, backend, follow_symlink)
-      lstat = follow_symlink ? " -L" : ""
-      format = (backend.os.esx? || backend.os[:name] == "alpine" || backend.os[:name] == "yocto") ? "-c" : "--printf"
-      res = backend.run_command("stat#{lstat} #{shell_escaped_path} 2>/dev/null #{format} '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'")
-      # ignore the exit_code: it is != 0 if selinux labels are not supported
-      # on the system.
-
-      fields = res.stdout.split("\n")
-      return {} if fields.length != 9
-
-      tmask = fields[1].to_i(16)
-      selinux = fields[8]
-      ## selinux security context string not available on esxi
-      selinux = nil if (selinux == "?") || (selinux == "(null)") || (selinux == "C")
-      {
-        type: find_type(tmask),
-        mode: tmask & 07777,
-        owner: fields[2],
-        uid: fields[3].to_i,
-        group: fields[4],
-        gid: fields[5].to_i,
-        mtime: fields[7].to_i,
-        size: fields[0].to_i,
-        selinux_label: selinux,
-      }
-    end
-
-    def self.bsd_stat(shell_escaped_path, backend, follow_symlink)
-      # From stat man page on FreeBSD:
-      # z       The size of file in bytes (st_size).
-      # p       File type and permissions (st_mode).
-      # u, g    User ID and group ID of file's owner (st_uid, st_gid).
-      # a, m, c, B
-      #         The time file was last accessed or modified, or when the
-      #         inode was last changed, or the birth time of the inode
-      #         (st_atime, st_mtime, st_ctime, st_birthtime).
-      #
-      # The special output specifier S may be used to indicate that the
-      # output, if applicable, should be in string format.  May be used
-      # in combination with:
-      #      ...
-      #      gu      Display group or user name.
-      lstat = follow_symlink ? " -L" : ""
-      res = backend.run_command(
-        "stat#{lstat} -f '%z\n%p\n%Su\n%u\n%Sg\n%g\n%a\n%m' "\
-        "#{shell_escaped_path}"
-      )
-
-      return {} if res.exit_status != 0
-
-      fields = res.stdout.split("\n")
-      return {} if fields.length != 8
-
-      tmask = fields[1].to_i(8)
-
-      {
-        type: find_type(tmask),
-        mode: tmask & 07777,
-        owner: fields[2],
-        uid: fields[3].to_i,
-        group: fields[4],
-        gid: fields[5].to_i,
-        mtime: fields[7].to_i,
-        size: fields[0].to_i,
-        selinux_label: fields[8],
-      }
-    end
-
-    def self.aix_stat(shell_escaped_path, backend, follow_symlink)
-      # Perl here b/c it is default on AIX
-      lstat = follow_symlink ? "lstat" : "stat"
-      stat_cmd = <<-EOP
-      perl -e '
-      @a = #{lstat}(shift) or exit 2;
-      $u = getpwuid($a[4]);
-      $g = getgrgid($a[5]);
-      printf("0%o\\n%s\\n%d\\n%s\\n%d\\n%d\\n%d\\n", $a[2], $u, $a[4], $g, $a[5], $a[9], $a[7])
-      ' #{shell_escaped_path}
-      EOP
-
-      res = backend.run_command(stat_cmd)
-      return {} if res.exit_status != 0
-
-      fields = res.stdout.split("\n")
-      return {} if fields.length != 7
-
-      tmask = fields[0].to_i(8)
-      {
-        type: find_type(tmask),
-        mode: tmask & 07777,
-        owner: fields[1],
-        uid: fields[2].to_i,
-        group: fields[3],
-        gid: fields[4].to_i,
-        mtime: fields[5].to_i,
-        size: fields[6].to_i,
-        selinux_label: nil,
-      }
-    end
-  end
-end

data/lib/train/file.rb

@@ -1,212 +0,0 @@
-# encoding: utf-8
-#
-# author: Christoph Hartmann
-# author: Dominik Richter
-
-require_relative "file/local"
-require_relative "file/remote"
-require_relative "extras/stat"
-
-module Train
-  class File # rubocop:disable Metrics/ClassLength
-    def initialize(backend, path, follow_symlink = true)
-      @backend = backend
-      @path = path || ""
-      @follow_symlink = follow_symlink
-
-      sanitize_filename(path)
-    end
-
-    # This method gets override by particular os class.
-    def sanitize_filename(_path)
-      nil
-    end
-
-    # interface methods: these fields should be implemented by every
-    # backend File
-    DATA_FIELDS = %w{
-      exist? mode owner group uid gid content mtime size selinux_label path
-    }.freeze
-
-    DATA_FIELDS.each do |m|
-      next if m == "path"
-
-      define_method m do
-        raise NotImplementedError, "File must implement the #{m}() method."
-      end
-    end
-
-    def to_json
-      res = Hash[DATA_FIELDS.map { |x| [x, method(x).call] }]
-      # additional fields provided as input
-      res["type"] = type
-      res["follow_symlink"] = @follow_symlink
-      res
-    end
-
-    def type
-      :unknown
-    end
-
-    def source
-      if @follow_symlink
-        self.class.new(@backend, @path, false)
-      else
-        self
-      end
-    end
-
-    def source_path
-      @path
-    end
-
-    # product_version is primarily used by Windows operating systems only and will be overwritten
-    # in Windows-related classes. Since this field is returned for all file objects, the acceptable
-    # default value is nil
-    def product_version
-      nil
-    end
-
-    # file_version is primarily used by Windows operating systems only and will be overwritten
-    # in Windows-related classes. Since this field is returned for all file objects, the acceptable
-    # default value is nil
-    def file_version
-      nil
-    end
-
-    def version?(version)
-      (product_version == version) ||
-        (file_version == version)
-    end
-
-    def block_device?
-      type.to_s == "block_device"
-    end
-
-    def character_device?
-      type.to_s == "character_device"
-    end
-
-    def pipe?
-      type.to_s == "pipe"
-    end
-
-    def file?
-      type.to_s == "file"
-    end
-
-    def socket?
-      type.to_s == "socket"
-    end
-
-    def directory?
-      type.to_s == "directory"
-    end
-
-    def symlink?
-      source.type.to_s == "symlink"
-    end
-
-    def owned_by?(sth)
-      owner == sth
-    end
-
-    def path
-      if symlink? && @follow_symlink
-        link_path
-      else
-        @path
-      end
-    end
-
-    # if the OS-specific file class supports inquirying as to whether the
-    # file/device is mounted, the #mounted method should return a command
-    # object whose stdout will not be nil if indeed the device is mounted.
-    #
-    # if the OS-specific file class does not support checking for mount
-    # status, the method should not be implemented and this method will
-    # return false.
-    def mounted?
-      return false unless respond_to?(:mounted)
-
-      !mounted.nil? && !mounted.stdout.nil? && !mounted.stdout.empty?
-    end
-
-    def md5sum
-      # Skip processing rest of method if fallback method is selected
-      return perform_checksum_ruby(:md5) if defined?(@ruby_checksum_fallback)
-
-      checksum = if @backend.os.family == "windows"
-                   perform_checksum_windows(:md5)
-                 else
-                   @md5_command ||= case @backend.os.family
-                                    when "darwin"
-                                      "md5 -r"
-                                    when "solaris"
-                                      "digest -a md5"
-                                    else
-                                      "md5sum"
-                                    end
-
-                   perform_checksum_unix(@md5_command)
-                 end
-
-      checksum || perform_checksum_ruby(:md5)
-    end
-
-    def sha256sum
-      # Skip processing rest of method if fallback method is selected
-      return perform_checksum_ruby(:sha256) if defined?(@ruby_checksum_fallback)
-
-      checksum = if @backend.os.family == "windows"
-                   perform_checksum_windows(:sha256)
-                 else
-                   @sha256_command ||= case @backend.os.family
-                                       when "darwin", "hpux", "qnx"
-                                         "shasum -a 256"
-                                       when "solaris"
-                                         "digest -a sha256"
-                                       else
-                                         "sha256sum"
-                                       end
-
-                   perform_checksum_unix(@sha256_command)
-                 end
-
-      checksum || perform_checksum_ruby(:sha256)
-    end
-
-    private
-
-    def perform_checksum_unix(cmd)
-      res = @backend.run_command("#{cmd} #{@path}")
-      res.stdout.split(" ").first if res.exit_status == 0
-    end
-
-    def perform_checksum_windows(method)
-      cmd = "CertUtil -hashfile #{@path} #{method.to_s.upcase}"
-      res = @backend.run_command(cmd)
-      res.stdout.split("\r\n")[1].tr(" ", "") if res.exit_status == 0
-    end
-
-    # This pulls the content of the file to the machine running Train and uses
-    # Digest to perform the checksum. This is less efficient than using remote
-    # system binaries and can lead to incorrect results due to encoding.
-    def perform_checksum_ruby(method)
-      # This is used to skip attempting other checksum methods. If this is set
-      # then we know all other methods have failed.
-      @ruby_checksum_fallback = true
-      case method
-      when :md5
-        res = Digest::MD5.new
-      when :sha256
-        res = Digest::SHA256.new
-      end
-
-      res.update(content)
-      res.hexdigest
-    rescue TypeError => _
-      nil
-    end
-  end
-end

data/lib/train/file/local.rb

@@ -1,82 +0,0 @@
-# encoding: utf-8
-
-module Train
-  class File
-    class Local < Train::File
-      %w{
-        exist? file? socket? directory? symlink? pipe? size basename
-      }.each do |m|
-        define_method m.to_sym do
-          ::File.method(m.to_sym).call(@path)
-        end
-      end
-
-      def content
-        @content ||= ::File.read(@path, encoding: "UTF-8")
-      rescue StandardError => _
-        nil
-      end
-
-      def link_path
-        return nil unless symlink?
-
-        begin
-          @link_path ||= ::File.realpath(@path)
-        rescue Errno::ELOOP => _
-          # Leave it blank on symbolic loop, same as readlink
-          @link_path = ""
-        end
-      end
-
-      def shallow_link_path
-        return nil unless symlink?
-
-        @link_path ||= ::File.readlink(@path)
-      end
-
-      def block_device?
-        ::File.blockdev?(@path)
-      end
-
-      def character_device?
-        ::File.chardev?(@path)
-      end
-
-      def type
-        case ::File.ftype(@path)
-        when "blockSpecial"
-          :block_device
-        when "characterSpecial"
-          :character_device
-        when "link"
-          :symlink
-        when "fifo"
-          :pipe
-        else
-          ::File.ftype(@path).to_sym
-        end
-      end
-
-      %w{
-        mode owner group uid gid mtime selinux_label
-      }.each do |field|
-        define_method field.to_sym do
-          stat[field.to_sym]
-        end
-      end
-
-      def mode?(sth)
-        mode == sth
-      end
-
-      def linked_to?(dst)
-        link_path == dst
-      end
-    end
-  end
-end
-
-# subclass requires are loaded after Train::File::Local is defined
-# to avoid superclass mismatch errors
-require_relative "local/unix"
-require_relative "local/windows"

data/lib/train/file/local/unix.rb

@@ -1,96 +0,0 @@
-# encoding: utf-8
-
-require "shellwords"
-require_relative "../../extras/stat"
-
-module Train
-  class File
-    class Local
-      class Unix < Train::File::Local
-        def sanitize_filename(path)
-          @spath = Shellwords.escape(path) || @path
-        end
-
-        def stat
-          return @stat if defined?(@stat)
-
-          begin
-            file_stat =
-              if @follow_symlink
-                ::File.stat(@path)
-              else
-                ::File.lstat(@path)
-              end
-          rescue StandardError => _err
-            return @stat = {}
-          end
-
-          @stat = {
-            type: Train::Extras::Stat.find_type(file_stat.mode),
-            mode: file_stat.mode & 07777,
-            mtime: file_stat.mtime.to_i,
-            size: file_stat.size,
-            owner: pw_username(file_stat.uid),
-            uid: file_stat.uid,
-            group: pw_groupname(file_stat.gid),
-            gid: file_stat.gid,
-          }
-
-          lstat = @follow_symlink ? " -L" : ""
-          res = @backend.run_command("stat#{lstat} #{@spath} 2>/dev/null --printf '%C'")
-          if res.exit_status == 0 && !res.stdout.empty? && res.stdout != "?"
-            @stat[:selinux_label] = res.stdout.strip
-          end
-
-          @stat
-        end
-
-        def mounted
-          @mounted ||=
-            @backend.run_command("mount | grep -- ' on #{@path} '")
-        end
-
-        def grouped_into?(sth)
-          group == sth
-        end
-
-        def unix_mode_mask(owner, type)
-          o = UNIX_MODE_OWNERS[owner.to_sym]
-          return nil if o.nil?
-
-          t = UNIX_MODE_TYPES[type.to_sym]
-          return nil if t.nil?
-
-          t & o
-        end
-
-        private
-
-        def pw_username(uid)
-          Etc.getpwuid(uid).name
-        rescue ArgumentError => _
-          nil
-        end
-
-        def pw_groupname(gid)
-          Etc.getgrgid(gid).name
-        rescue ArgumentError => _
-          nil
-        end
-
-        UNIX_MODE_OWNERS = {
-          all: 00777,
-          owner: 00700,
-          group: 00070,
-          other: 00007,
-        }.freeze
-
-        UNIX_MODE_TYPES = {
-          r: 00444,
-          w: 00222,
-          x: 00111,
-        }.freeze
-      end
-    end
-  end
-end