train 0.12.1

data/lib/train/extras/command_wrapper.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'base64'
+require 'winrm'
+require 'train/errors'
+
+module Train::Extras
+  # Define the interface of all command wrappers.
+  class CommandWrapperBase
+    # Verify that the command wrapper is initialized properly and working.
+    #
+    # @return [Any] verification result, nil if all went well, otherwise a message
+    def verify
+      fail Train::ClientError, "#{self.class} does not implement #verify()"
+    end
+
+    # Wrap a command and return the augmented command which can be executed.
+    #
+    # @param [Strin] command that will be wrapper
+    # @return [String] result of wrapping the command
+    def run(_command)
+      fail Train::ClientError, "#{self.class} does not implement #run(command)"
+    end
+  end
+
+  # Wrap linux commands and add functionality like sudo.
+  class LinuxCommand < CommandWrapperBase
+    Train::Options.attach(self)
+
+    option :sudo, default: false
+    option :sudo_options, default: nil
+    option :sudo_password, default: nil
+    option :sudo_command, default: nil
+    option :user
+
+    def initialize(backend, options)
+      @backend = backend
+      validate_options(options)
+
+      @sudo = options[:sudo]
+      @sudo_options = options[:sudo_options]
+      @sudo_password = options[:sudo_password]
+      @sudo_command = options[:sudo_command]
+      @user = options[:user]
+      @prefix = build_prefix
+    end
+
+    # (see CommandWrapperBase::verify)
+    def verify
+      res = @backend.run_command(run('echo'))
+      return nil if res.exit_status == 0
+      rawerr = res.stdout + ' ' + res.stderr
+
+      {
+        'Sorry, try again' => 'Wrong sudo password.',
+        'sudo: no tty present and no askpass program specified' =>
+          'Sudo requires a password, please configure it.',
+        'sudo: command not found' =>
+          "Can't find sudo command. Please either install and "\
+            'configure it on the target or deactivate sudo.',
+        'sudo: sorry, you must have a tty to run sudo' =>
+          'Sudo requires a TTY. Please see the README on how to configure '\
+            'sudo to allow for non-interactive usage.',
+      }.each do |sudo, human|
+        rawerr = human if rawerr.include? sudo
+      end
+
+      rawerr
+    end
+
+    # (see CommandWrapperBase::run)
+    def run(command)
+      @prefix + command
+    end
+
+    def self.active?(options)
+      options.is_a?(Hash) && options[:sudo]
+    end
+
+    private
+
+    def build_prefix
+      return '' unless @sudo
+      return '' if @user == 'root'
+
+      res = (@sudo_command || 'sudo') + ' '
+
+      unless @sudo_password.nil?
+        b64pw = Base64.strict_encode64(@sudo_password + "\n")
+        res = "echo #{b64pw} | base64 -d | #{res}-S "
+      end
+
+      res << @sudo_options.to_s + ' ' unless @sudo_options.nil?
+
+      res
+    end
+  end
+
+  # this is required if you run locally on windows,
+  # winrm connections provide a PowerShell shell automatically
+  # TODO: only activate in local mode
+  class PowerShellCommand < CommandWrapperBase
+    Train::Options.attach(self)
+
+    def initialize(backend, options)
+      @backend = backend
+      validate_options(options)
+    end
+
+    def run(script)
+      # wrap the script to ensure we always run it via powershell
+      # especially in local mode, we cannot be sure that we get a Powershell
+      # we may just get a `cmd`.
+      # TODO: we may want to opt for powershell.exe -command instead of `encodeCommand`
+      "powershell -encodedCommand #{WinRM::PowershellScript.new(safe_script(script)).encoded}"
+    end
+
+    # reused from https://github.com/WinRb/WinRM/blob/master/lib/winrm/command_executor.rb
+    # suppress the progress stream from leaking to stderr
+    def safe_script(script)
+      "$ProgressPreference='SilentlyContinue';" + script
+    end
+
+    def to_s
+      'PowerShell CommandWrapper'
+    end
+  end
+
+  class CommandWrapper
+    include_options LinuxCommand
+
+    def self.load(transport, options)
+      if transport.os.unix?
+        return nil unless LinuxCommand.active?(options)
+        res = LinuxCommand.new(transport, options)
+        msg = res.verify
+        fail Train::UserError, "Sudo failed: #{msg}" unless msg.nil?
+        res
+      # only use powershell command for local transport. winrm transport
+      # uses powershell as default
+      elsif transport.os.windows? && transport.class == Train::Transports::Local::Connection
+        PowerShellCommand.new(transport, options)
+      end
+    end
+  end
+end

data/lib/train/extras/file_aix.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'shellwords'
+require 'train/extras/stat'
+
+module Train::Extras
+  class AixFile < UnixFile
+    def link_path
+      return nil unless symlink?
+      @link_path ||=
+        @backend.run_command("perl -e 'print readlink shift' #{@spath}")
+                .stdout.chomp
+    end
+
+    def mounted
+      @mounted ||=
+        @backend.run_command("lsfs -c #{@spath}")
+    end
+  end
+end

data/lib/train/extras/file_common.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'digest/sha2'
+require 'digest/md5'
+
+module Train::Extras
+  class FileCommon # rubocop:disable Metrics/ClassLength
+    # interface methods: these fields should be implemented by every
+    # backend File
+    %w{
+      exist? mode owner group uid gid content mtime size selinux_label path
+      product_version file_version
+    }.each do |m|
+      define_method m.to_sym do
+        fail NotImplementedError, "File must implement the #{m}() method."
+      end
+    end
+
+    def initialize(backend, path, follow_symlink = true)
+      @backend = backend
+      @path = path || ''
+      @follow_symlink = follow_symlink
+    end
+
+    def type
+      :unknown
+    end
+
+    # The following methods can be overwritten by a derived class
+    # if desired, to e.g. achieve optimizations.
+
+    def md5sum
+      res = Digest::MD5.new
+      res.update(content)
+      res.hexdigest
+    rescue TypeError => _
+      nil
+    end
+
+    def sha256sum
+      res = Digest::SHA256.new
+      res.update(content)
+      res.hexdigest
+    rescue TypeError => _
+      nil
+    end
+
+    # Additional methods for convenience
+
+    def file?
+      type == :file
+    end
+
+    def block_device?
+      type == :block_device
+    end
+
+    def character_device?
+      type == :character_device
+    end
+
+    def socket?
+      type == :socket
+    end
+
+    def directory?
+      type == :directory
+    end
+
+    def symlink?
+      source.type == :symlink
+    end
+
+    def source_path
+      @path
+    end
+
+    def source
+      if @follow_symlink
+        self.class.new(@backend, @path, false)
+      else
+        self
+      end
+    end
+
+    def pipe?
+      type == :pipe
+    end
+
+    def mode?(sth)
+      mode == sth
+    end
+
+    def owned_by?(sth)
+      owner == sth
+    end
+
+    def grouped_into?(sth)
+      group == sth
+    end
+
+    def linked_to?(dst)
+      link_path == dst
+    end
+
+    def link_path
+      symlink? ? path : nil
+    end
+
+    def version?(version)
+      product_version == version or
+        file_version == version
+    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
+
+    def mounted?
+      !mounted.nil? && !mounted.stdout.nil? && !mounted.stdout.empty?
+    end
+
+    def basename(suffix = nil, sep = '/')
+      fail 'Not yet supported: Suffix in file.basename' unless suffix.nil?
+      @basename ||= detect_filename(path, sep || '/')
+    end
+
+    # helper methods provided to any implementing class
+
+    private
+
+    def detect_filename(path, sep)
+      idx = path.rindex(sep)
+      return path if idx.nil?
+      idx += 1
+      return detect_filename(path[0..-2], sep) if idx == path.length
+      path[idx..-1]
+    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

data/lib/train/extras/file_linux.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+module Train::Extras
+  class LinuxFile < UnixFile
+    def content
+      return @content if defined?(@content)
+      @content = @backend.run_command(
+        "cat #{@spath} || echo -n").stdout
+      return @content unless @content.empty?
+      @content = nil if directory? or size.nil? or size > 0
+      @content
+    end
+  end
+end

data/lib/train/extras/file_unix.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'shellwords'
+require 'train/extras/stat'
+
+module Train::Extras
+  class UnixFile < FileCommon
+    attr_reader :path
+    def initialize(backend, path, follow_symlink = true)
+      super(backend, path, follow_symlink)
+      @spath = Shellwords.escape(@path)
+    end
+
+    def content
+      @content ||= case
+                   when !exist?, directory?
+                     nil
+                   when size.nil?, size == 0
+                     ''
+                   else
+                     @backend.run_command("cat #{@spath}").stdout || ''
+                   end
+    end
+
+    def exist?
+      @exist ||= (
+        f = @follow_symlink ? '' : " || test -L #{@spath}"
+        @backend.run_command("test -e #{@spath}"+f)
+                .exit_status == 0
+      )
+    end
+
+    def path
+      return @path unless @follow_symlink && symlink?
+      @link_path ||= read_target_path
+    end
+
+    def mounted
+      @mounted ||=
+        @backend.run_command("mount | grep -- ' on #{@spath} '")
+    end
+
+    %w{
+      type mode owner group uid gid mtime size selinux_label
+    }.each do |field|
+      define_method field.to_sym do
+        stat[field.to_sym]
+      end
+    end
+
+    def product_version
+      nil
+    end
+
+    def file_version
+      nil
+    end
+
+    def stat
+      return @stat if defined?(@stat)
+      @stat = Train::Extras::Stat.stat(@spath, @backend, @follow_symlink)
+    end
+
+    private
+
+    # Returns full path of a symlink target(real dest) or '' on symlink loop
+    def read_target_path
+      full_path = @backend.run_command("readlink -n #{@spath} -f").stdout
+      # Needed for some OSes like OSX that returns relative path
+      # when the link and target are in the same directory
+      if !full_path.start_with?('/') && full_path != ''
+        full_path = File.expand_path("../#{full_path}", @spath)
+      end
+      full_path
+    end
+  end
+end

data/lib/train/extras/file_windows.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'shellwords'
+require 'train/extras/stat'
+
+# PS C:\Users\Administrator> Get-Item -Path C:\test.txt | Select-Object -Property BaseName, FullName, IsReadOnly, Exists,
+# LinkType, Mode, VersionInfo, Owner, Archive, Hidden, ReadOnly, System |  ConvertTo-Json
+
+module Train::Extras
+  class WindowsFile < FileCommon
+    attr_reader :path
+    def initialize(backend, path, follow_symlink = false)
+      super(backend, path, follow_symlink)
+      @spath = sanitize_filename(@path)
+    end
+
+    def basename(suffix = nil, sep = '\\')
+      super(suffix, sep)
+    end
+
+    # Ensures we do not use invalid characters for file names
+    # @see https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx#naming_conventions
+    def sanitize_filename(filename)
+      return if filename.nil?
+      # we do not filter :, backslash and forward slash, since they are part of the path
+      filename.gsub(/[<>"|?*]/, '')
+    end
+
+    def content
+      return @content if defined?(@content)
+      @content = @backend.run_command(
+        "Get-Content(\"#{@spath}\") | Out-String").stdout
+      return @content unless @content.empty?
+      @content = nil if directory? # or size.nil? or size > 0
+      @content
+    end
+
+    def exist?
+      return @exist if defined?(@exist)
+      @exist = @backend.run_command(
+        "(Test-Path -Path \"#{@spath}\").ToString()").stdout.chomp == 'True'
+    end
+
+    def link_path
+      nil
+    end
+
+    def mounted
+      nil
+    end
+
+    def type
+      if attributes.include?('Archive')
+        return :file
+      elsif attributes.include?('Directory')
+        return :directory
+      end
+      :unknown
+    end
+
+    %w{
+      mode owner group uid gid mtime size selinux_label
+    }.each do |field|
+      define_method field.to_sym do
+        nil
+      end
+    end
+
+    def product_version
+      nil
+    end
+
+    def file_version
+      nil
+    end
+
+    def stat
+      nil
+    end
+
+    private
+
+    def attributes
+      return @attributes if defined?(@attributes)
+      @attributes = @backend.run_command(
+        "(Get-ItemProperty -Path \"#{@spath}\").attributes.ToString()").stdout.chomp.split(/\s*,\s*/)
+    end
+  end
+end