r-train 0.9.1

data/lib/train.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+
+require 'train/version'
+require 'train/plugins'
+require 'train/errors'
+require 'uri'
+
+module Train
+  # Create a new transport instance, with the plugin indicated by the
+  # given name.
+  #
+  # @param [String] name of the plugin
+  # @param [Array] *args list of arguments for the plugin
+  # @return [Transport] instance of the new transport or nil
+  def self.create(name, *args)
+    cls = load_transport(name)
+    cls.new(*args) unless cls.nil?
+  end
+
+  # Retrieve the configuration options of a transport plugin.
+  #
+  # @param [String] name of the plugin
+  # @return [Hash] map of default options
+  def self.options(name)
+    cls = load_transport(name)
+    cls.default_options unless cls.nil?
+  end
+
+  # Load the transport plugin indicated by name. If the plugin is not
+  # yet found in the plugin registry, it will be attempted to load from
+  # `train/transports/plugin_name`.
+  #
+  # @param [String] name of the plugin
+  # @return [Train::Transport] the transport plugin
+  def self.load_transport(name)
+    res = Train::Plugins.registry[name.to_s]
+    return res unless res.nil?
+
+    # if the plugin wasnt loaded yet:
+    require 'train/transports/' + name.to_s
+    Train::Plugins.registry[name.to_s]
+  rescue LoadError => _
+    raise Train::UserError,
+          "Can't find train plugin #{name.inspect}. Please install it first."
+  end
+
+  # Resolve target configuration in URI-scheme into
+  # all respective fields and merge with existing configuration.
+  # e.g. ssh://bob@remote  =>  backend: ssh, user: bob, host: remote
+  def self.target_config(config = nil) # rubocop:disable Metrics/AbcSize
+    conf = config.nil? ? {} : config.dup
+
+    # symbolize keys
+    conf = conf.each_with_object({}) do |(k, v), acc|
+      acc[k.to_sym] = v
+      acc
+    end
+
+    group_keys_and_keyfiles(conf)
+
+    return conf if conf[:target].to_s.empty?
+
+    uri = URI.parse(conf[:target].to_s)
+    unless uri.host.nil? and uri.scheme.nil?
+      conf[:backend]  ||= uri.scheme
+      conf[:host]     ||= uri.host
+      conf[:port]     ||= uri.port
+      conf[:user]     ||= uri.user
+      conf[:password] ||= uri.password
+      conf[:path]     ||= uri.path
+    end
+
+    # ensure path is nil, if its empty; e.g. required to reset defaults for winrm
+    conf[:path] = nil if !conf[:path].nil? && conf[:path].to_s.empty?
+
+    # return the updated config
+    conf
+  end
+
+  private
+
+  def self.group_keys_and_keyfiles(conf)
+    # in case the user specified a key-file, register it that way
+    # we will clear the list of keys and put keys and key_files separately
+    keys_mixed = conf[:keys]
+    return if keys_mixed.nil?
+
+    conf[:key_files] = []
+    conf[:keys] = []
+    keys_mixed.each do |key|
+      if !key.nil? and File.file?(key)
+        conf[:key_files].push(key)
+      else
+        conf[:keys].push(key)
+      end
+    end
+  end
+end

data/lib/train/errors.rb

@@ -0,0 +1,23 @@
+# 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 class for all exceptions that are caused by user input
+  # errors.
+  class UserError < ::StandardError; end
+
+  # Base exception class for all exceptions that are caused by incorrect use
+  # of an API.
+  class ClientError < ::StandardError; end
+
+  # Base exception class for all exceptions that are caused by other failures
+  # in the transport layer.
+  class TransportError < ::StandardError; end
+end

data/lib/train/extras.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+
+module Train::Extras
+  autoload :CommandWrapper, 'train/extras/command_wrapper'
+  autoload :FileCommon,     'train/extras/file_common'
+  autoload :LinuxFile,      'train/extras/linux_file'
+  autoload :WindowsFile,    'train/extras/windows_file'
+  autoload :OSCommon,       'train/extras/os_common'
+  autoload :Stat,           '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,105 @@
+# 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 :sudo, default: false
+    option :sudo_options, default: nil
+    option :sudo_password, 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]
+      @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
+
+      rawerr = 'Wrong sudo password.' if rawerr.include? 'Sorry, try again'
+      if rawerr.include? 'sudo: no tty present and no askpass program specified'
+        rawerr = 'Sudo requires a password, please configure it.'
+      end
+      if rawerr.include? 'sudo: command not found'
+        rawerr = "Can't find sudo command. Please either install and "\
+                 'configure it on the target or deactivate 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 '
+
+      unless @sudo_password.nil?
+        b64pw = Base64.strict_encode64(@sudo_password + "\n")
+        res = "echo #{b64pw} | base64 -d | sudo -S "
+      end
+
+      res << @sudo_options.to_s + ' ' unless @sudo_options.nil?
+
+      res
+    end
+  end
+
+  class CommandWrapper
+    include_options LinuxCommand
+
+    def self.load(transport, options)
+      return nil unless LinuxCommand.active?(options)
+      return nil unless transport.os.unix?
+      res = LinuxCommand.new(transport, options)
+      msg = res.verify
+      fail Train::UserError, "Sudo failed: #{msg}" unless msg.nil?
+      res
+    end
+  end
+end

data/lib/train/extras/file_common.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'digest/sha2'
+require 'digest/md5'
+
+module Train::Extras
+  class FileCommon
+    # interface methods: these fields should be implemented by every
+    # backend File
+    %w{
+      exist? mode owner group link_target link_path content mtime size
+      selinux_label product_version file_version path
+    }.each do |m|
+      define_method m.to_sym do
+        fail NotImplementedError, "File must implement the #{m}() method."
+      end
+    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?
+      target_type == :file
+    end
+
+    def block_device?
+      target_type == :block_device
+    end
+
+    def character_device?
+      target_type == :character_device
+    end
+
+    def socket?
+      target_type == :socket
+    end
+
+    def directory?
+      target_type == :directory
+    end
+
+    def symlink?
+      type == :symlink
+    end
+
+    def pipe?
+      target_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 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
+
+    # helper methods provided to any implementing class
+
+    private
+
+    def target_type
+      # Just return the type unless this is a symlink
+      return type unless type == :symlink
+      # Get the link's target type, i.e. the real destination's type
+      return link_target.type unless link_target.nil?
+      # Return unknown if we don't know where this is pointing to
+      :unknown
+    end
+
+    UNIX_MODE_OWNERS = {
+      all:   00777,
+      owner: 00700,
+      group: 00070,
+      other: 00007,
+    }
+
+    UNIX_MODE_TYPES = {
+      r: 00444,
+      w: 00222,
+      x: 00111,
+    }
+  end
+end

data/lib/train/extras/linux_file.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'shellwords'
+require 'train/extras/stat'
+
+module Train::Extras
+  class LinuxFile < FileCommon
+    attr_reader :path
+    def initialize(backend, path)
+      @backend = backend
+      @path = path
+      @spath = Shellwords.escape(@path)
+    end
+
+    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
+
+    def exist?
+      @exist ||= (
+        @backend.run_command("test -e #{@spath}")
+                .exit_status == 0
+      )
+    end
+
+    def link_target
+      return @link_target if defined? @link_target
+      return @link_target = nil if link_path.nil?
+      @link_target = @backend.file(link_path)
+    end
+
+    def link_path
+      return nil unless symlink?
+      @link_path ||= (
+        @backend.run_command("readlink #{@spath}").stdout.chomp
+      )
+    end
+
+    def mounted?
+      @mounted ||= (
+        !@backend.run_command("mount | grep -- ' on #{@spath}'")
+                 .stdout.empty?
+      )
+    end
+
+    %w{
+      type mode owner group 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)
+    end
+  end
+end