train 0.12.1

data/lib/train/transports/docker.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter
+# Author:: Christoph Hartmann
+
+require 'docker'
+
+module Train::Transports
+  class Docker < Train.plugin(1)
+    name 'docker'
+
+    include_options Train::Extras::CommandWrapper
+    option :host, required: true
+
+    def connection(state = {}, &block)
+      opts = merge_options(options, state || {})
+      validate_options(opts)
+
+      if @connection && @connection_options == opts
+        reuse_connection(&block)
+      else
+        create_new_connection(opts, &block)
+      end
+    end
+
+    private
+
+    # Creates a new Docker connection instance and save it for potential future
+    # reuse.
+    #
+    # @param options [Hash] connection options
+    # @return [Docker::Connection] a Docker connection instance
+    # @api private
+    def create_new_connection(options, &block)
+      if @connection
+        logger.debug("[Docker] shutting previous connection #{@connection}")
+        @connection.close
+      end
+
+      @connection_options = options
+      @connection = Connection.new(options, &block)
+    end
+
+    # Return the last saved Docker connection instance.
+    #
+    # @return [Docker::Connection] a Docker connection instance
+    # @api private
+    def reuse_connection
+      logger.debug("[Docker] reusing existing connection #{@connection}")
+      yield @connection if block_given?
+      @connection
+    end
+  end
+end
+
+class Train::Transports::Docker
+  class Connection < BaseConnection
+    def initialize(conf)
+      super(conf)
+      @id = options[:host]
+      @container = ::Docker::Container.get(@id) ||
+                   fail("Can't find Docker container #{@id}")
+      @files = {}
+      @cmd_wrapper = nil
+      @cmd_wrapper = CommandWrapper.load(self, @options)
+      self
+    end
+
+    def close
+      # nothing to do at the moment
+    end
+
+    def os
+      @os ||= OS.new(self)
+    end
+
+    def file(path)
+      @files[path] ||= LinuxFile.new(self, path)
+    end
+
+    def run_command(cmd)
+      cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
+      stdout, stderr, exit_status = @container.exec(
+        [
+          '/bin/sh', '-c', cmd
+        ])
+      CommandResult.new(stdout.join, stderr.join, exit_status)
+    rescue ::Docker::Error::DockerError => _
+      raise
+    rescue => _
+      # @TODO: differentiate any other error
+      raise
+    end
+
+    class OS < OSCommon
+      def initialize(backend)
+        # hardcoded to unix/linux for now, until other operating systems
+        # are supported
+        super(backend, { family: 'unix' })
+      end
+    end
+  end
+end

data/lib/train/transports/local.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+#
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'train/plugins'
+require 'mixlib/shellout'
+
+module Train::Transports
+  class Local < Train.plugin(1)
+    name 'local'
+
+    include_options Train::Extras::CommandWrapper
+
+    autoload :File, 'train/transports/local_file'
+    autoload :OS,   'train/transports/local_os'
+
+    def connection(_ = nil)
+      @connection ||= Connection.new(@options)
+    end
+
+    class Connection < BaseConnection
+      def initialize(options)
+        super(options)
+        @files = {}
+        @cmd_wrapper = nil
+        @cmd_wrapper = CommandWrapper.load(self, options)
+      end
+
+      def run_command(cmd)
+        cmd = @cmd_wrapper.run(cmd) unless @cmd_wrapper.nil?
+        res = Mixlib::ShellOut.new(cmd)
+        res.run_command
+        CommandResult.new(res.stdout, res.stderr, res.exitstatus)
+      rescue Errno::ENOENT => _
+        CommandResult.new('', '', 1)
+      end
+
+      def os
+        @os ||= OS.new(self)
+      end
+
+      def file(path)
+        @files[path] ||= File.new(self, path)
+      end
+
+      def login_command
+        nil # none, open your shell
+      end
+    end
+  end
+end

data/lib/train/transports/local_file.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+#
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'train/extras'
+
+class Train::Transports::Local::Connection
+  class File < LinuxFile
+    def content
+      @content ||= ::File.read(@path, encoding: 'UTF-8')
+    rescue StandardError => _
+      nil
+    end
+
+    %w{
+      exist? file? socket? directory? symlink? pipe?
+    }.each do |m|
+      define_method m.to_sym do
+        ::File.method(m.to_sym).call(@path)
+      end
+    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 block_device?
+      ::File.blockdev?(@path)
+    end
+
+    def character_device?
+      ::File.chardev?(@path)
+    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
+
+    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 & 00777,
+        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
+  end
+end

data/lib/train/transports/local_os.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+#
+# This is heavily based on:
+#
+#   OHAI https://github.com/chef/ohai
+#   by Adam Jacob, Chef Software Inc
+#
+
+require 'rbconfig'
+
+class Train::Transports::Local
+  class OS < OSCommon
+    def initialize(backend)
+      super(backend, { family: detect_local_os })
+    end
+
+    private
+
+    def detect_local_os
+      case ::RbConfig::CONFIG['host_os']
+      when /aix(.+)$/
+        return 'aix'
+      when /darwin(.+)$/
+        return 'darwin'
+      when /hpux(.+)$/
+        return 'hpux'
+      when /linux/
+        return 'linux'
+      when /freebsd(.+)$/
+        return 'freebsd'
+      when /openbsd(.+)$/
+        return 'openbsd'
+      when /netbsd(.*)$/
+        return 'netbsd'
+      when /solaris2/
+        return 'solaris2'
+      when /mswin|mingw32|windows/
+        # After long discussion in IRC the "powers that be" have come to a consensus
+        # that no Windows platform exists that was not based on the
+        # Windows_NT kernel, so we herby decree that "windows" will refer to all
+        # platforms built upon the Windows_NT kernel and have access to win32 or win64
+        # subsystems.
+        return 'windows'
+      else
+        return ::RbConfig::CONFIG['host_os']
+      end
+    end
+  end
+end

data/lib/train/transports/mock.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+#
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'train/plugins'
+require 'digest'
+
+module Train::Transports
+  class Mock < Train.plugin(1)
+    name 'mock'
+
+    def initialize(conf = nil)
+      @conf = conf || {}
+      trace_calls if @conf[:trace]
+    end
+
+    def connection
+      @connection ||= Connection.new(@conf)
+    end
+
+    def to_s
+      'Mock Transport'
+    end
+
+    private
+
+    def trace_calls
+      interface_methods = {
+        'Train::Transports::Mock' =>
+          Train::Transports::Mock.instance_methods(false),
+        'Train::Transports::Mock::Connection' =>
+          Connection.instance_methods(false),
+        'Train::Transports::Mock::Connection::File' =>
+          Connection::FileCommon.instance_methods(false),
+        'Train::Transports::Mock::Connection::OS' =>
+          Connection::OSCommon.instance_methods(false),
+      }
+
+      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Lint/Eval
+      set_trace_func proc { |event, _file, _line, id, binding, classname|
+        unless classname.to_s.start_with?('Train::Transports::Mock') and
+               event == 'call' and
+               interface_methods[classname.to_s].include?(id)
+          next
+        end
+        # kindly borrowed from the wonderful simple-tracer by matugm
+        arg_names = eval(
+          'method(__method__).parameters.map { |arg| arg[1].to_s }',
+          binding)
+        args = eval("#{arg_names}.map { |arg| eval(arg) }", binding).join(', ')
+        prefix = '-' * (classname.to_s.count(':') - 2) + '> '
+        puts("#{prefix}#{id} #{args}")
+      }
+      # rubocop:enable all
+    end
+  end
+end
+
+class Train::Transports::Mock
+  class Connection < BaseConnection
+    attr_accessor :files, :commands
+    attr_reader :os
+
+    def initialize(conf = nil)
+      @conf = conf || {}
+      @files = {}
+      @os = OS.new(self, family: 'unknown')
+      @commands = {}
+    end
+
+    def mock_os(value)
+      @os = OS.new(self, value)
+    end
+
+    def mock_command(cmd, stdout = nil, stderr = nil, exit_status = 0)
+      @commands[cmd] = Command.new(stdout || '', stderr || '', exit_status)
+    end
+
+    def command_not_found(cmd)
+      if @conf[:verbose]
+        STDERR.puts('Command not mocked:')
+        STDERR.puts('    '+cmd.to_s.split("\n").join("\n    "))
+        STDERR.puts('    SHA: ' + Digest::SHA256.hexdigest(cmd.to_s))
+      end
+      mock_command(cmd)
+    end
+
+    def run_command(cmd)
+      @commands[cmd] ||
+        @commands[Digest::SHA256.hexdigest cmd.to_s] ||
+        command_not_found(cmd)
+    end
+
+    def file_not_found(path)
+      STDERR.puts('File not mocked: '+path.to_s) if @conf[:verbose]
+      File.new(self, path)
+    end
+
+    def file(path)
+      @files[path] ||= file_not_found(path)
+    end
+
+    def to_s
+      'Mock Connection'
+    end
+  end
+end
+
+class Train::Transports::Mock::Connection
+  Command = Struct.new(:stdout, :stderr, :exit_status)
+end
+
+class Train::Transports::Mock::Connection
+  class OS < OSCommon
+    def initialize(backend, desc)
+      super(backend, desc)
+    end
+
+    def detect_family
+      # no op, we do not need to detect the os
+    end
+  end
+end
+
+class Train::Transports::Mock::Connection
+  class File < FileCommon
+    %w{
+      exist? mode owner group link_path content mtime size
+      selinux_label product_version file_version path type
+    }.each do |m|
+      attr_accessor m.tr('?', '').to_sym
+    end
+
+    def initialize(backend, path, follow_symlink = true)
+      super(backend, path, follow_symlink)
+      @type = :unknown
+      @exist = false
+    end
+
+    def mounted
+      @mounted ||=
+        @backend.run_command("mount | grep -- ' on #{@path}'")
+    end
+  end
+end

data/lib/train/transports/ssh.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+# Author:: Christoph Hartmann (<chris@lollyrock.com>)
+#
+# Copyright (C) 2014, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'net/ssh'
+require 'net/scp'
+require 'train/errors'
+
+module Train::Transports
+  # Wrapped exception for any internally raised SSH-related errors.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class SSHFailed < Train::TransportError; end
+
+  # A Transport which uses the SSH protocol to execute commands and transfer
+  # files.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class SSH < Train.plugin(1)
+    name 'ssh'
+
+    autoload :Connection, 'train/transports/ssh_connection'
+
+    # add options for submodules
+    include_options Train::Extras::CommandWrapper
+
+    # common target configuration
+    option :host,      required: true
+    option :port,      default: 22, required: true
+    option :user,      default: 'root', required: true
+    option :key_files, default: nil
+    option :password,  default: nil
+
+    # additional ssh options
+    option :keepalive, default: true
+    option :keepalive_interval, default: 60
+    option :connection_timeout, default: 15
+    option :connection_retries, default: 5
+    option :connection_retry_sleep, default: 1
+    option :max_wait_until_ready, default: 600
+    option :compression, default: false
+
+    option :compression_level do |opts|
+      # on nil or false: set compression level to 0
+      opts[:compression] ? 6 : 0
+    end
+
+    # (see Base#connection)
+    def connection(state = {}, &block)
+      opts = merge_options(options, state || {})
+      validate_options(opts)
+      conn_opts = connection_options(opts)
+
+      if defined?(@connection) && @connection_options == conn_opts
+        reuse_connection(&block)
+      else
+        create_new_connection(conn_opts, &block)
+      end
+    end
+
+    private
+
+    def validate_options(options)
+      super(options)
+
+      key_files = Array(options[:key_files])
+      if key_files.empty? and options[:password].nil?
+        fail Train::ClientError,
+             'You must configure at least one authentication method for SSH:'\
+             ' Password or key.'
+      end
+
+      options[:auth_methods] ||= ['none']
+
+      unless key_files.empty?
+        options[:auth_methods].push('publickey')
+        options[:keys_only] = true if options[:password].nil?
+        options[:key_files] = key_files
+      end
+
+      unless options[:password].nil?
+        options[:auth_methods].push('password')
+      end
+
+      super
+      self
+    end
+
+    # Builds the hash of options needed by the Connection object on
+    # construction.
+    #
+    # @param opts [Hash] merged configuration and mutable state data
+    # @return [Hash] hash of connection options
+    # @api private
+    def connection_options(opts)
+      {
+        logger:                 logger,
+        user_known_hosts_file:  '/dev/null',
+        paranoid:               false,
+        hostname:               opts[:host],
+        port:                   opts[:port],
+        username:               opts[:user],
+        compression:            opts[:compression],
+        compression_level:      opts[:compression_level],
+        keepalive:              opts[:keepalive],
+        keepalive_interval:     opts[:keepalive_interval],
+        timeout:                opts[:connection_timeout],
+        connection_retries:     opts[:connection_retries],
+        connection_retry_sleep: opts[:connection_retry_sleep],
+        max_wait_until_ready:   opts[:max_wait_until_ready],
+        auth_methods:           opts[:auth_methods],
+        keys_only:              opts[:keys_only],
+        keys:                   opts[:key_files],
+        password:               opts[:password],
+        forward_agent:          opts[:forward_agent],
+        transport_options:      opts,
+      }
+    end
+
+    # Creates a new SSH Connection instance and save it for potential future
+    # reuse.
+    #
+    # @param options [Hash] conneciton options
+    # @return [Ssh::Connection] an SSH Connection instance
+    # @api private
+    def create_new_connection(options, &block)
+      if defined?(@connection)
+        logger.debug("[SSH] shutting previous connection #{@connection}")
+        @connection.close
+      end
+
+      @connection_options = options
+      conn = Connection.new(options, &block)
+      @connection = conn unless conn.nil?
+    end
+
+    # Return the last saved SSH connection instance.
+    #
+    # @return [Ssh::Connection] an SSH Connection instance
+    # @api private
+    def reuse_connection
+      logger.debug("[SSH] reusing existing connection #{@connection}")
+      yield @connection if block_given?
+      @connection
+    end
+  end
+end