train 3.2.14 → 3.2.20

data/lib/train/platforms.rb

@@ -1,102 +0,0 @@
-# encoding: utf-8
-
-require_relative "platforms/common"
-require_relative "platforms/detect"
-require_relative "platforms/detect/scanner"
-require_relative "platforms/detect/specifications/os"
-require_relative "platforms/detect/specifications/api"
-require_relative "platforms/detect/uuid"
-require_relative "platforms/family"
-require_relative "platforms/platform"
-
-module Train::Platforms
-  # Retrieve the current platform list
-  #
-  # @return [Hash] map with platform names and their objects
-  def self.list
-    @list ||= {}
-  end
-
-  # Retrieve the current family list
-  #
-  # @return [Hash] map with family names and their objects
-  def self.families
-    @families ||= {}
-  end
-
-  # Clear all platform settings. Only used for testing.
-  def self.__reset
-    @list = {}
-    @families = {}
-  end
-
-  # Create or update a platform
-  #
-  # @return Train::Platform
-  def self.name(name, condition = {})
-    # TODO: refactor this against family. They're stupidly similar
-    # 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
-    empty_list =     list.select { |_key, value| value.families.empty? }
-    empty_fams = families.select { |_key, value| value.families.empty? }
-
-    empty_list.merge empty_fams
-  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
-
-  def self.export
-    export = []
-    list.each do |name, platform|
-      platform.find_family_hierarchy
-      export << {
-        name: name,
-        families: platform.family_hierarchy,
-      }
-    end
-    export.sort_by { |platform| platform[:name] }
-  end
-end

data/lib/train/platforms/common.rb

@@ -1,34 +0,0 @@
-# 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
-        raise "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

@@ -1,12 +0,0 @@
-# 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

@@ -1,160 +0,0 @@
-require_relative "os_linux"
-require_relative "os_windows"
-require "rbconfig"
-
-module Train::Platforms::Detect::Helpers
-  module OSCommon
-    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?
-      backend_name == "TrainPlugins::WinRM::Connection"
-    end
-
-    def backend_name
-      @backend.class.name
-    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 == 0 ? res.stdout : nil
-      @files[path]
-    end
-
-    def unix_file_exist?(path)
-      @backend.run_command("test -f #{path}").exit_status == 0
-    end
-
-    def command_output(cmd)
-      res = @backend.run_command(cmd).stdout
-      # When you try to execute command using ssh connction as root user and you have provided ssh user identity file
-      # it gives standard output to login as authorised user other than root. To show this standard ouput as an error
-      # to user we are matching the string of stdout and raising the error here so that user gets exact information.
-      if @backend.class.to_s == "Train::Transports::SSH::Connection" && res =~ /Please login as the user/
-        raise Train::UserError, "SSH failed: #{res}"
-      end
-
-      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
-      (unix_uuid_from_chef         ||
-       unix_uuid_from_machine_file ||
-       uuid_from_command           ||
-       raise(Train::TransportError, "Cannot find a UUID for your node."))
-    end
-
-    def unix_uuid_from_chef
-      file = @backend.file("/var/chef/cache/data_collector_metadata.json")
-      if file.exist? && file.size != 0
-        json = ::JSON.parse(file.content)
-        return json["node_uuid"] if json["node_uuid"]
-      end
-    end
-
-    def unix_uuid_from_machine_file
-      # require 'pry';binding.pry
-      %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 != 0
-        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 == 0 && !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

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

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-module Train::Platforms::Detect::Helpers
-  module Linux
-    def redhatish_platform(conf)
-      conf =~ /^red hat/i ? "redhat" : /(\w+)/i.match(conf)[1].downcase
-    end
-
-    def redhatish_version(conf)
-      case conf
-      when /rawhide/i
-        /((\d+) \(Rawhide\))/i.match(conf)[1].downcase
-      when /Amazon Linux/i
-        /([\d\.]+)/.match(conf)[1]
-      when /derived from .*linux|amazon/i
-        /Linux ((\d+|\.)+)/i.match(conf)[1]
-      else
-        /release ([\d\.]+)/.match(conf)[1]
-      end
-    end
-
-    def linux_os_release
-      data = unix_file_contents("/etc/os-release")
-      return if data.nil?
-
-      os_info = parse_os_release_info(data)
-      cisco_info_file = os_info["CISCO_RELEASE_INFO"]
-      if cisco_info_file
-        os_info.merge!(parse_os_release_info(unix_file_contents(cisco_info_file)))
-      end
-
-      os_info
-    end
-
-    def parse_os_release_info(raw)
-      return {} if raw.nil?
-
-      raw.lines.each_with_object({}) do |line, memo|
-        line.strip!
-        next if line.nil? || line.empty?
-        next if line.start_with?("#")
-
-        key, value = line.split("=", 2)
-        memo[key] = value.gsub(/\A"|"\Z/, "") unless value.nil? || value.empty?
-      end
-    end
-
-    def lsb_config(content)
-      id = /^DISTRIB_ID=["']?(.+?)["']?$/.match(content)
-      release = /^DISTRIB_RELEASE=["']?(.+?)["']?$/.match(content)
-      codename = /^DISTRIB_CODENAME=["']?(.+?)["']?$/.match(content)
-      {
-        id: id.nil? ? nil : id[1],
-        release: release.nil? ? nil : release[1],
-        codename: codename.nil? ? nil : codename[1],
-      }
-    end
-
-    def lsb_release(content)
-      id = /^Distributor ID:\s+(.+)$/.match(content)
-      release = /^Release:\s+(.+)$/.match(content)
-      codename = /^Codename:\s+(.+)$/.match(content)
-      {
-        id: id.nil? ? nil : id[1],
-        release: release.nil? ? nil : release[1],
-        codename: codename.nil? ? nil : codename[1],
-      }
-    end
-
-    def read_linux_lsb
-      return @lsb unless @lsb.empty?
-
-      if !(raw = unix_file_contents("/etc/lsb-release")).nil?
-        @lsb = lsb_config(raw)
-      elsif !(raw = unix_file_contents("/usr/bin/lsb-release")).nil?
-        @lsb = lsb_release(raw)
-      end
-    end
-  end
-end

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

@@ -1,142 +0,0 @@
-module Train::Platforms::Detect::Helpers
-  module Windows
-    def detect_windows
-      check_cmd || check_powershell
-    end
-
-    def check_cmd
-      # try to detect windows, use cmd.exe to also support Microsoft OpenSSH
-      res = @backend.run_command("cmd.exe /c ver")
-
-      return false if (res.exit_status != 0) || res.stdout.empty?
-
-      # if the ver contains `Windows`, we know its a Windows system
-      version = res.stdout.strip
-      return false unless version.downcase =~ /windows/
-
-      @platform[:family] = "windows"
-
-      # try to extract release from eg. `Microsoft Windows [Version 6.3.9600]`
-      release = /\[(?<name>.*)\]/.match(version)
-      if release[:name]
-        # release is 6.3.9600 now
-        @platform[:release] = release[:name].downcase.gsub("version", "").strip
-        # fallback, if we are not able to extract the name from wmic later
-        @platform[:name] = "Windows #{@platform[:release]}"
-      end
-
-      read_wmic
-      true
-    end
-
-    def check_powershell
-      command = @backend.run_command(
-        "Get-WmiObject Win32_OperatingSystem | Select Caption,Version | ConvertTo-Json"
-      )
-      return false if (command.exit_status != 0) || command.stdout.empty?
-
-      payload = JSON.parse(command.stdout)
-      @platform[:family] = "windows"
-      @platform[:release] = payload["Version"]
-      @platform[:name] = payload["Caption"]
-
-      read_wmic
-      true
-    end
-
-    # reads os name and version from wmic
-    # @see https://msdn.microsoft.com/en-us/library/bb742610.aspx#EEAA
-    # Thanks to Matt Wrock (https://github.com/mwrock) for this hint
-    def read_wmic
-      res = @backend.run_command("wmic os get * /format:list")
-      if res.exit_status == 0
-        sys_info = {}
-        res.stdout.lines.each do |line|
-          m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
-          sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
-        end
-
-        @platform[:release] = sys_info[:Version]
-        # additional info on windows
-        @platform[:build] = sys_info[:BuildNumber]
-        @platform[:name] = sys_info[:Caption]
-        @platform[:name] = @platform[:name].gsub("Microsoft", "").strip unless @platform[:name].empty?
-        @platform[:arch] = read_wmic_cpu
-      end
-    end
-
-    # `OSArchitecture` from `read_wmic` does not match a normal standard
-    # For example, `x86_64` shows as `64-bit`
-    def read_wmic_cpu
-      res = @backend.run_command("wmic cpu get architecture /format:list")
-      if res.exit_status == 0
-        sys_info = {}
-        res.stdout.lines.each do |line|
-          m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
-          sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
-        end
-      end
-
-      # This converts `wmic os get architecture` output to a normal standard
-      # https://msdn.microsoft.com/en-us/library/aa394373(VS.85).aspx
-      arch_map = {
-        0 => "i386",
-        1 => "mips",
-        2 => "alpha",
-        3 => "powerpc",
-        5 => "arm",
-        6 => "ia64",
-        9 => "x86_64",
-      }
-
-      # The value of `wmic cpu get architecture` is always a number between 0-9
-      arch_number = sys_info[:Architecture].to_i
-      arch_map[arch_number]
-    end
-
-    # This method scans the target os for a unique uuid to use
-    def windows_uuid
-      uuid = windows_uuid_from_chef
-      uuid = windows_uuid_from_machine_file if uuid.nil?
-      uuid = windows_uuid_from_wmic if uuid.nil?
-      uuid = windows_uuid_from_registry if uuid.nil?
-      raise Train::TransportError, "Cannot find a UUID for your node." if uuid.nil?
-
-      uuid
-    end
-
-    def windows_uuid_from_machine_file
-      %W{
-        #{ENV["SYSTEMDRIVE"]}\\chef\\chef_guid
-        #{ENV["HOMEDRIVE"]}#{ENV["HOMEPATH"]}\\.chef\\chef_guid
-      }.each do |path|
-        file = @backend.file(path)
-        return file.content.chomp if file.exist? && file.size != 0
-      end
-      nil
-    end
-
-    def windows_uuid_from_chef
-      file = @backend.file("#{ENV["SYSTEMDRIVE"]}\\chef\\cache\\data_collector_metadata.json")
-      return if !file.exist? || file.size == 0
-
-      json = JSON.parse(file.content)
-      json["node_uuid"] if json["node_uuid"]
-    end
-
-    def windows_uuid_from_wmic
-      result = @backend.run_command("wmic csproduct get UUID")
-      return unless result.exit_status == 0
-
-      result.stdout.split("\r\n")[-1].strip
-    end
-
-    def windows_uuid_from_registry
-      cmd = '(Get-ItemProperty "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography" -Name "MachineGuid")."MachineGuid"'
-      result = @backend.run_command(cmd)
-      return unless result.exit_status == 0
-
-      result.stdout.chomp
-    end
-  end
-end