train-core 1.4.4

data/lib/train/file/remote/windows.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module Train
+  class File
+    class Remote
+      class Windows < Train::File::Remote
+        attr_reader :path
+        # 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(path)
+          return if path.nil?
+          # we do not filter :, backslash and forward slash, since they are part of the path
+          @spath = path.gsub(/[<>"|?*]/, '')
+        end
+
+        def basename(suffix = nil, sep = '\\')
+          super(suffix, sep)
+        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 owner
+          owner = @backend.run_command(
+            "Get-Acl \"#{@spath}\" | select -expand Owner").stdout.strip
+          return if owner.empty?
+          owner
+        end
+
+        def type
+          if attributes.include?('Archive') && !attributes.include?('Directory')
+            return :file
+          elsif attributes.include?('ReparsePoint')
+            return :symlink
+          elsif attributes.include?('Directory')
+            return :directory
+          end
+          :unknown
+        end
+
+        def size
+          if file?
+            @backend.run_command("((Get-Item '#{@spath}').Length)").stdout.strip.to_i
+          end
+        end
+
+        def product_version
+          @product_version ||= @backend.run_command(
+            "[System.Diagnostics.FileVersionInfo]::GetVersionInfo(\"#{@spath}\").ProductVersion").stdout.chomp
+        end
+
+        def file_version
+          @file_version ||= @backend.run_command(
+            "[System.Diagnostics.FileVersionInfo]::GetVersionInfo(\"#{@spath}\").FileVersion").stdout.chomp
+        end
+
+        %w{
+          mode group uid gid mtime selinux_label
+        }.each do |field|
+          define_method field.to_sym do
+            nil
+          end
+        end
+
+        def link_path
+          nil
+        end
+
+        def mounted
+          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
+  end
+end

data/lib/train/options.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+# Author:: Christoph Hartmann (<chris@lollyrock.com>)
+
+module Train
+  module Options
+    def self.attach(target)
+      target.class.method(:include).call(ClassOptions)
+      target.method(:include).call(InstanceOptions)
+    end
+
+    module ClassOptions
+      def option(name, conf = nil, &block)
+        d = conf || {}
+        unless d.is_a? Hash
+          fail Train::ClientError,
+               "The transport plugin #{self} declared an option #{name} "\
+               "and didn't provide a valid configuration hash."
+        end
+
+        if !conf.nil? and !conf[:default].nil? and block_given?
+          fail Train::ClientError,
+               "The transport plugin #{self} declared an option #{name} "\
+               'with both a default value and block. Only use one of these.'
+        end
+
+        d[:default] = block if block_given?
+
+        default_options[name] = d
+      end
+
+      def default_options
+        @default_options = {} unless defined? @default_options
+        @default_options
+      end
+
+      def include_options(other)
+        unless other.respond_to?(:default_options)
+          fail "Trying to include options from module #{other.inspect}, "\
+               "which doesn't seem to support options."
+        end
+        default_options.merge!(other.default_options)
+      end
+    end
+
+    module InstanceOptions
+      # @return [Hash] options, which created this Transport
+      attr_reader :options
+
+      def default_options
+        self.class.default_options
+      end
+
+      def merge_options(base, opts)
+        res = base.merge(opts || {})
+        default_options.each do |field, hm|
+          next unless res[field].nil? and hm.key?(:default)
+          default = hm[:default]
+          if default.is_a? Proc
+            res[field] = default.call(res)
+          else
+            res[field] = default
+          end
+        end
+        res
+      end
+
+      def validate_options(opts)
+        default_options.each do |field, hm|
+          if opts[field].nil? and hm[:required]
+            fail Train::ClientError,
+                 "You must provide a value for #{field.to_s.inspect}."
+          end
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/train/platforms.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require 'train/platforms/common'
+require 'train/platforms/detect'
+require 'train/platforms/detect/scanner'
+require 'train/platforms/detect/specifications/os'
+require 'train/platforms/detect/specifications/api'
+require 'train/platforms/detect/uuid'
+require 'train/platforms/family'
+require 'train/platforms/platform'
+
+module Train::Platforms
+  class << self
+    # Retrieve the current platform list
+    #
+    # @return [Hash] map with platform names and their objects
+    def list
+      @list ||= {}
+    end
+
+    # Retrieve the current family list
+    #
+    # @return [Hash] map with family names and their objects
+    def families
+      @families ||= {}
+    end
+  end
+
+  # Create or update a platform
+  #
+  # @return Train::Platform
+  def self.name(name, condition = {})
+    # Check the list to see if one is already created
+    plat = list[name]
+    unless plat.nil?
+      # Pass the condition incase we are adding a family relationship
+      plat.condition = condition unless condition.nil?
+      return plat
+    end
+
+    Train::Platforms::Platform.new(name, condition)
+  end
+
+  # Create or update a family
+  #
+  # @return Train::Platforms::Family
+  def self.family(name, condition = {})
+    # Check the families to see if one is already created
+    family = families[name]
+    unless family.nil?
+      # Pass the condition incase we are adding a family relationship
+      family.condition = condition unless condition.nil?
+      return family
+    end
+
+    Train::Platforms::Family.new(name, condition)
+  end
+
+  # Find the families or top level platforms
+  #
+  # @return [Hash] with top level family and platforms
+  def self.top_platforms
+    top_platforms = list.select { |_key, value| value.families.empty? }
+    top_platforms.merge!(families.select { |_key, value| value.families.empty? })
+    top_platforms
+  end
+
+  # List all platforms and families in a readable output
+  def self.list_all
+    top_platforms = self.top_platforms
+    top_platforms.each_value do |platform|
+      puts platform.title
+      print_children(platform) if defined?(platform.children)
+    end
+  end
+
+  def self.print_children(parent, pad = 2)
+    parent.children.each do |key, value|
+      obj = key
+      puts "#{' ' * pad}-> #{obj.title}#{value unless value.empty?}"
+      print_children(obj, pad + 2) if defined?(obj.children) && !obj.children.nil?
+    end
+  end
+end

data/lib/train/platforms/common.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Train::Platforms
+  module Common
+    # Add a family connection. This will create a family
+    # if it does not exist and add a child relationship.
+    def in_family(family)
+      if self.class == Train::Platforms::Family && @name == family
+        fail "Unable to add family #{@name} to itself: '#{@name}.in_family(#{family})'"
+      end
+
+      # add family to the family list
+      family = Train::Platforms.family(family)
+      family.children[self] = @condition
+
+      @families[family] = @condition
+      @condition = nil
+      self
+    end
+
+    def detect(&block)
+      if block_given?
+        @detect = block
+        self
+      elsif @detect.nil?
+        # we are returning a block that just returns false here
+        # to skip the family/platform evaluation if detect is not set
+        ->(_) { false }
+      else
+        @detect
+      end
+    end
+  end
+end

data/lib/train/platforms/detect.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Train::Platforms
+  module Detect
+    # Main detect method to scan all platforms for a match
+    #
+    # @return Train::Platform instance or error if none found
+    def self.scan(backend)
+      Scanner.new(backend).scan
+    end
+  end
+end

data/lib/train/platforms/detect/helpers/os_common.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require 'train/platforms/detect/helpers/os_linux'
+require 'train/platforms/detect/helpers/os_windows'
+require 'rbconfig'
+
+module Train::Platforms::Detect::Helpers
+  module OSCommon # rubocop:disable Metrics/ModuleLength
+    include Train::Platforms::Detect::Helpers::Linux
+    include Train::Platforms::Detect::Helpers::Windows
+
+    def ruby_host_os(regex)
+      ::RbConfig::CONFIG['host_os'] =~ regex
+    end
+
+    def winrm?
+      Object.const_defined?('Train::Transports::WinRM::Connection') &&
+        @backend.class == Train::Transports::WinRM::Connection
+    end
+
+    def unix_file_contents(path)
+      # keep a log of files incase multiple checks call the same one
+      return @files[path] if @files.key?(path)
+
+      res = @backend.run_command("test -f #{path} && cat #{path}")
+      # ignore files that can't be read
+      @files[path] = res.exit_status.zero? ? res.stdout : nil
+      @files[path]
+    end
+
+    def unix_file_exist?(path)
+      @backend.run_command("test -f #{path}").exit_status.zero?
+    end
+
+    def command_output(cmd)
+      res = @backend.run_command(cmd).stdout
+      res.strip! unless res.nil?
+      res
+    end
+
+    def unix_uname_s
+      return @uname[:s] if @uname.key?(:s)
+      @uname[:s] = command_output('uname -s')
+    end
+
+    def unix_uname_r
+      return @uname[:r] if @uname.key?(:r)
+      @uname[:r] = command_output('uname -r')
+    end
+
+    def unix_uname_m
+      return @uname[:m] if @uname.key?(:m)
+      @uname[:m] = command_output('uname -m')
+    end
+
+    def brocade_version
+      return @cache[:brocade] if @cache.key?(:brocade)
+      res = command_output('version')
+
+      m = res.match(/^Fabric OS:\s+v(\S+)$/)
+      unless m.nil?
+        return @cache[:brocade] = { version: m[1], type: 'fos' }
+      end
+
+      @cache[:brocade] = nil
+    end
+
+    def cisco_show_version
+      return @cache[:cisco] if @cache.key?(:cisco)
+      res = command_output('show version')
+
+      m = res.match(/^Cisco IOS Software, [^,]+? \(([^,]+?)\), Version (\d+\.\d+)/)
+      unless m.nil?
+        return @cache[:cisco] = { version: m[2], model: m[1], type: 'ios' }
+      end
+
+      m = res.match(/^Cisco IOS Software, IOS-XE Software, [^,]+? \(([^,]+?)\), Version (\d+\.\d+\.\d+[A-Z]*)/)
+      unless m.nil?
+        return @cache[:cisco] = { version: m[2], model: m[1], type: 'ios-xe' }
+      end
+
+      m = res.match(/^Cisco Nexus Operating System \(NX-OS\) Software/)
+      unless m.nil?
+        v = res[/^\s*system:\s+version (\d+\.\d+)/, 1]
+        return @cache[:cisco] = { version: v, type: 'nexus' }
+      end
+
+      @cache[:cisco] = nil
+    end
+
+    def unix_uuid
+      uuid = unix_uuid_from_chef
+      uuid = unix_uuid_from_machine_file if uuid.nil?
+      uuid = uuid_from_command if uuid.nil?
+      raise Train::TransportError, 'Cannot find a UUID for your node.' if uuid.nil?
+      uuid
+    end
+
+    def unix_uuid_from_chef
+      file = @backend.file('/var/chef/cache/data_collector_metadata.json')
+      if file.exist? && !file.size.zero?
+        json = ::JSON.parse(file.content)
+        return json['node_uuid'] if json['node_uuid']
+      end
+    end
+
+    def unix_uuid_from_machine_file
+      %W(
+        /etc/chef/chef_guid
+        #{ENV['HOME']}/.chef/chef_guid
+        /etc/machine-id
+        /var/lib/dbus/machine-id
+        /var/db/dbus/machine-id
+      ).each do |path|
+        file = @backend.file(path)
+        next unless file.exist? && !file.size.zero?
+        return file.content.chomp if path =~ /guid/
+        return uuid_from_string(file.content.chomp)
+      end
+      nil
+    end
+
+    # This takes a command from the platform detect block to run.
+    # We expect the command to return a unique identifier which
+    # we turn into a UUID.
+    def uuid_from_command
+      return unless @platform[:uuid_command]
+      result = @backend.run_command(@platform[:uuid_command])
+      uuid_from_string(result.stdout.chomp) if result.exit_status.zero? && !result.stdout.empty?
+    end
+
+    # This hashes the passed string into SHA1.
+    # Then it downgrades the 160bit SHA1 to a 128bit
+    # then we format it as a valid UUIDv5.
+    def uuid_from_string(string)
+      hash = Digest::SHA1.new
+      hash.update(string)
+      ary = hash.digest.unpack('NnnnnN')
+      ary[2] = (ary[2] & 0x0FFF) | (5 << 12)
+      ary[3] = (ary[3] & 0x3FFF) | 0x8000
+      # rubocop:disable Style/FormatString
+      '%08x-%04x-%04x-%04x-%04x%08x' % ary
+    end
+  end
+end