train-core 1.4.4

data/lib/train/errors.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+# Author:: Christoph Hartmann (<chris@lollyrock.com>)
+#
+# Copyright (C) 2013, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+
+module Train
+  # Base exception for any exception explicitly raised by the Train library.
+  class Error < ::StandardError; end
+
+  # Base exception class for all exceptions that are caused by user input
+  # errors.
+  class UserError < Error; end
+
+  # Base exception class for all exceptions that are caused by incorrect use
+  # of an API.
+  class ClientError < Error; end
+
+  # Base exception class for all exceptions that are caused by other failures
+  # in the transport layer.
+  class TransportError < Error; end
+
+  # Exception for when no platform can be detected.
+  class PlatformDetectionFailed < Error; end
+
+  # Exception for when a invalid cache type is passed.
+  class UnknownCacheType < Error; end
+end

data/lib/train/extras.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+
+module Train::Extras
+  require 'train/extras/command_wrapper'
+  require 'train/extras/stat'
+
+  CommandResult = Struct.new(:stdout, :stderr, :exit_status)
+  LoginCommand = Struct.new(:command, :arguments)
+end

data/lib/train/extras/command_wrapper.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'base64'
+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 :shell, default: false
+    option :shell_options, default: nil
+    option :shell_command, default: nil
+    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)
+
+      @shell = options[:shell]
+      @shell_options = options[:shell_options] # e.g. '--login'
+      @shell_command = options[:shell_command] # e.g. '/bin/sh'
+      @sudo = options[:sudo]
+      @sudo_options = options[:sudo_options]
+      @sudo_password = options[:sudo_password]
+      @sudo_command = options[:sudo_command]
+      @user = options[:user]
+    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)
+      shell_wrap(sudo_wrap(command))
+    end
+
+    def self.active?(options)
+      options.is_a?(Hash) && (
+        options[:sudo] ||
+        options[:shell]
+      )
+    end
+
+    private
+
+    # wrap the cmd in a sudo command
+    def sudo_wrap(cmd)
+      return cmd unless @sudo
+      return cmd if @user == 'root'
+
+      res = (@sudo_command || 'sudo') + ' '
+
+      res = "#{safe_string(@sudo_password + "\n")} | #{res}-S " unless @sudo_password.nil?
+
+      res << @sudo_options.to_s + ' ' unless @sudo_options.nil?
+
+      res + cmd
+    end
+
+    # wrap the cmd in a subshell allowing for options to
+    # passed to the subshell
+    def shell_wrap(cmd)
+      return cmd unless @shell
+
+      shell = @shell_command || '$SHELL'
+      options = ' ' + @shell_options.to_s unless @shell_options.nil?
+
+      "#{safe_string(cmd)} | #{shell}#{options}"
+    end
+
+    # encapsulates encoding the string into a safe form, and decoding for use.
+    # @return [String] A command line snippet that can be used as part of a pipeline.
+    def safe_string(str)
+      b64str = Base64.strict_encode64(str)
+      "echo #{b64str} | base64 --decode"
+    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
+      end
+    end
+  end
+end

data/lib/train/extras/stat.rb

@@ -0,0 +1,132 @@
+# 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') ? '-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 == '?' or selinux == '(null)' or 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

@@ -0,0 +1,151 @@
+# encoding: utf-8
+#
+# author: Christoph Hartmann
+# author: Dominik Richter
+
+require 'train/file/local'
+require 'train/file/remote'
+require 'digest/sha2'
+require 'digest/md5'
+require 'train/extras/stat'
+
+module Train
+  class File
+    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|
+      define_method m.to_sym do
+        fail 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 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
+
+    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 or
+        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
+  end
+end