train-core 1.4.4

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

@@ -0,0 +1,75 @@
+# 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 /derived from .*linux/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.empty?
+        key, value = line.split('=', 2)
+        memo[key] = value.gsub(/\A"|"\Z/, '') unless 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

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+module Train::Platforms::Detect::Helpers
+  module Windows
+    def detect_windows
+      res = @backend.run_command('cmd /c ver')
+      return false if res.exit_status != 0 or 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)
+      unless release[:name].nil?
+        # 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
+
+      # try to use wmic, but lets keep it optional
+      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 { |line|
+          m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
+          sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
+        }
+
+        @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 { |line|
+          m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
+          sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
+        }
+      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.zero?
+      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.zero?
+      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.zero?
+      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.zero?
+      result.stdout.chomp
+    end
+  end
+end

data/lib/train/platforms/detect/scanner.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require 'train/platforms/detect/helpers/os_common'
+
+module Train::Platforms::Detect
+  class Scanner
+    include Train::Platforms::Detect::Helpers::OSCommon
+
+    def initialize(backend)
+      @backend = backend
+      @platform = {}
+      @family_hierarchy = []
+
+      # detect cache variables
+      @files = {}
+      @uname = {}
+      @lsb = {}
+      @cache = {}
+    end
+
+    # Main detect method to scan all platforms for a match
+    #
+    # @return Train::Platform instance or error if none found
+    def scan
+      # start with the platform/families who have no families (the top levels)
+      top = Train::Platforms.top_platforms
+      top.each do |_name, plat|
+        # we are doing a instance_eval here to make sure we have the proper
+        # context with all the detect helper methods
+        next unless instance_eval(&plat.detect) == true
+
+        # if we have a match start looking at the children
+        plat_result = scan_children(plat)
+        next if plat_result.nil?
+
+        # return platform to backend
+        @family_hierarchy << plat.name
+        return get_platform(plat_result)
+      end
+
+      fail Train::PlatformDetectionFailed, 'Sorry, we are unable to detect your platform'
+    end
+
+    def scan_children(parent)
+      parent.children.each do |plat, condition|
+        next unless instance_eval(&plat.detect) == true
+
+        if plat.class == Train::Platforms::Platform
+          return plat if condition.empty? || check_condition(condition)
+        elsif plat.class == Train::Platforms::Family
+          plat = scan_family_children(plat)
+          return plat unless plat.nil?
+        end
+      end
+
+      nil
+    end
+
+    def scan_family_children(plat)
+      child_result = scan_children(plat) unless plat.children.nil?
+      return if child_result.nil?
+      @family_hierarchy << plat.name
+      child_result
+    end
+
+    def check_condition(condition)
+      condition.each do |k, v|
+        op, expected = v.strip.split(' ')
+        op = '==' if op == '='
+        return false if @platform[k].nil? || !instance_eval("'#{@platform[k]}' #{op} '#{expected}'")
+      end
+
+      true
+    end
+
+    def get_platform(plat)
+      plat.backend = @backend
+      plat.platform = @platform
+      plat.add_platform_methods
+      plat.family_hierarchy = @family_hierarchy
+      plat
+    end
+  end
+end

data/lib/train/platforms/detect/specifications/api.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Train::Platforms::Detect::Specifications
+  class Api
+    def self.load
+      plat = Train::Platforms
+
+      plat.family('api')
+
+      plat.family('cloud').in_family('api')
+      plat.name('aws').in_family('cloud')
+      plat.name('azure').in_family('cloud')
+    end
+  end
+end

data/lib/train/platforms/detect/specifications/os.rb

@@ -0,0 +1,578 @@
+# encoding: utf-8
+
+# rubocop:disable Style/Next
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/ClassLength
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/PerceivedComplexity
+
+module Train::Platforms::Detect::Specifications
+  class OS
+    def self.load
+      plat = Train::Platforms
+
+      # master family
+      plat.family('os').detect { true }
+
+      plat.family('windows').in_family('os')
+          .detect {
+            if winrm? || (@backend.local? && ruby_host_os(/mswin|mingw32|windows/))
+              true
+            end
+          }
+      # windows platform
+      plat.name('windows').in_family('windows')
+          .detect {
+            true if detect_windows == true
+          }
+
+      # unix master family
+      plat.family('unix').in_family('os')
+          .detect {
+            # we want to catch a special case here where cisco commands
+            # don't return an exit status and still print to stdout
+            if unix_uname_s =~ /./ && !unix_uname_s.start_with?('Line has invalid autocommand ') && !unix_uname_s.start_with?('The command you have entered')
+              @platform[:arch] = unix_uname_m
+              true
+            end
+          }
+
+      # linux master family
+      plat.family('linux').in_family('unix')
+          .detect {
+            true if unix_uname_s =~ /linux/i
+          }
+
+      # debian family
+      plat.family('debian').in_family('linux')
+          .detect {
+            true unless unix_file_contents('/etc/debian_version').nil?
+          }
+      plat.name('ubuntu').title('Ubuntu Linux').in_family('debian')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /ubuntu/i
+              @platform[:release] = lsb[:release]
+              true
+            end
+          }
+      plat.name('linuxmint').title('LinuxMint').in_family('debian')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /linuxmint/i
+              @platform[:release] = lsb[:release]
+              true
+            end
+          }
+      plat.name('raspbian').title('Raspbian Linux').in_family('debian')
+          .detect {
+            if (linux_os_release && linux_os_release['NAME'] =~ /raspbian/i) || \
+               unix_file_exist?('/usr/bin/raspi-config')
+              @platform[:release] = unix_file_contents('/etc/debian_version').chomp
+              true
+            end
+          }
+      plat.name('debian').title('Debian Linux').in_family('debian')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /debian/i
+              @platform[:release] = lsb[:release]
+              true
+            end
+
+            # if we get this far we have to be some type of debian
+            @platform[:release] = unix_file_contents('/etc/debian_version').chomp
+            true
+          }
+
+      # fedora family
+      plat.family('fedora').in_family('linux')
+          .detect {
+            true if linux_os_release && linux_os_release['NAME'] =~ /fedora/i
+          }
+      plat.name('fedora').title('Fedora').in_family('fedora')
+          .detect {
+            @platform[:release] = linux_os_release['VERSION_ID']
+            true
+          }
+
+      # arista_eos family
+      # this checks for the arista bash shell
+      # must come before redhat as it uses fedora under the hood
+      plat.family('arista_eos').title('Arista EOS Family').in_family('linux')
+          .detect {
+            true
+          }
+      plat.name('arista_eos_bash').title('Arista EOS Bash Shell').in_family('arista_eos')
+          .detect {
+            if unix_file_exist?('/usr/bin/FastCli')
+              cmd = @backend.run_command('FastCli -p 15 -c "show version | json"')
+              if cmd.exit_status == 0 && !cmd.stdout.empty?
+                require 'json'
+                begin
+                  eos_ver = JSON.parse(cmd.stdout)
+                  @platform[:release] = eos_ver['version']
+                  @platform[:arch] = eos_ver['architecture']
+                  true
+                rescue JSON::ParserError
+                  nil
+                end
+              end
+            end
+          }
+
+      # redhat family
+      plat.family('redhat').in_family('linux')
+          .detect {
+            # I am not sure this returns true for all redhats in this family
+            # for now we are going to just try each platform
+            # return true unless unix_file_contents('/etc/redhat-release').nil?
+
+            true
+          }
+      plat.name('centos').title('Centos Linux').in_family('redhat')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /centos/i
+              @platform[:release] = lsb[:release]
+              true
+            elsif linux_os_release && linux_os_release['NAME'] =~ /centos/i
+              @platform[:release] = redhatish_version(unix_file_contents('/etc/redhat-release'))
+              true
+            end
+          }
+      plat.name('oracle').title('Oracle Linux').in_family('redhat')
+          .detect {
+            if !(raw = unix_file_contents('/etc/oracle-release')).nil?
+              @platform[:release] = redhatish_version(raw)
+              true
+            elsif !(raw = unix_file_contents('/etc/enterprise-release')).nil?
+              @platform[:release] = redhatish_version(raw)
+              true
+            end
+          }
+      plat.name('scientific').title('Scientific Linux').in_family('redhat')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /scientific/i
+              @platform[:release] = lsb[:release]
+              true
+            end
+          }
+      plat.name('xenserver').title('Xenserer Linux').in_family('redhat')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /xenserver/i
+              @platform[:release] = lsb[:release]
+              true
+            end
+          }
+      plat.name('parallels-release').title('Parallels Linux').in_family('redhat')
+          .detect {
+            if !(raw = unix_file_contents('/etc/parallels-release')).nil?
+              @platform[:name] = redhatish_platform(raw)
+              @platform[:release] = raw[/(\d\.\d\.\d)/, 1]
+              true
+            end
+          }
+      plat.name('wrlinux').title('Wind River Linux').in_family('redhat')
+          .detect {
+            if linux_os_release && linux_os_release['ID_LIKE'] =~ /wrlinux/i
+              @platform[:release] = linux_os_release['VERSION']
+              true
+            end
+          }
+      plat.name('amazon').title('Amazon Linux').in_family('redhat')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /amazon/i
+              @platform[:release] = lsb[:release]
+              true
+            elsif (raw = unix_file_contents('/etc/system-release')) =~ /amazon/i
+              @platform[:name] = redhatish_platform(raw)
+              @platform[:release] = redhatish_version(raw)
+              true
+            end
+          }
+      plat.name('cloudlinux').title('CloudLinux').in_family('redhat')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /cloudlinux/i
+              @platform[:release] = lsb[:release]
+              true
+            elsif (raw = unix_file_contents('/etc/redhat-release')) =~ /cloudlinux/i
+              @platform[:name] = redhatish_platform(raw)
+              @platform[:release] = redhatish_version(raw)
+              true
+            end
+          }
+      # keep redhat at the end as a fallback for anything with a redhat-release
+      plat.name('redhat').title('Red Hat Linux').in_family('redhat')
+          .detect {
+            lsb = read_linux_lsb
+            if lsb && lsb[:id] =~ /redhat/i
+              @platform[:release] = lsb[:release]
+              true
+            elsif !(raw = unix_file_contents('/etc/redhat-release')).nil?
+              # must be some type of redhat
+              @platform[:name] = redhatish_platform(raw)
+              @platform[:release] = redhatish_version(raw)
+              true
+            end
+          }
+
+      # suse family
+      plat.family('suse').in_family('linux')
+          .detect {
+            if !(suse = unix_file_contents('/etc/SuSE-release')).nil?
+              version = suse.scan(/VERSION = (\d+)\nPATCHLEVEL = (\d+)/).flatten.join('.')
+              version = suse[/VERSION = ([\d\.]{2,})/, 1] if version == ''
+              @platform[:release] = version
+              true
+            end
+          }
+      plat.name('opensuse').title('OpenSUSE Linux').in_family('suse')
+          .detect {
+            true if unix_file_contents('/etc/SuSE-release') =~ /^opensuse/i
+          }
+      plat.name('suse').title('Suse Linux').in_family('suse')
+          .detect {
+            true if unix_file_contents('/etc/SuSE-release') =~ /suse/i
+          }
+
+      # arch
+      plat.name('arch').title('Arch Linux').in_family('linux')
+          .detect {
+            if !unix_file_contents('/etc/arch-release').nil?
+              # Because this is a rolling release distribution,
+              # use the kernel release, ex. 4.1.6-1-ARCH
+              @platform[:release] = unix_uname_r
+              true
+            end
+          }
+
+      # slackware
+      plat.name('slackware').title('Slackware Linux').in_family('linux')
+          .detect {
+            if !(raw = unix_file_contents('/etc/slackware-version')).nil?
+              @platform[:release] = raw.scan(/(\d+|\.+)/).join
+              true
+            end
+          }
+
+      # gentoo
+      plat.name('gentoo').title('Gentoo Linux').in_family('linux')
+          .detect {
+            if !(raw = unix_file_contents('/etc/gentoo-release')).nil?
+              @platform[:release] = raw.scan(/(\d+|\.+)/).join
+              true
+            end
+          }
+
+      # exherbo
+      plat.name('exherbo').title('Exherbo Linux').in_family('linux')
+          .detect {
+            unless unix_file_contents('/etc/exherbo-release').nil?
+              # Because this is a rolling release distribution,
+              # use the kernel release, ex. 4.1.6
+              @platform[:release] = unix_uname_r
+              true
+            end
+          }
+
+      # alpine
+      plat.name('alpine').title('Alpine Linux').in_family('linux')
+          .detect {
+            if !(raw = unix_file_contents('/etc/alpine-release')).nil?
+              @platform[:release] = raw.strip
+              true
+            end
+          }
+
+      # coreos
+      plat.name('coreos').title('CoreOS Linux').in_family('linux')
+          .detect {
+            unless unix_file_contents('/etc/coreos/update.conf').nil?
+              lsb = read_linux_lsb
+              @platform[:release] = lsb[:release]
+              true
+            end
+          }
+
+      # brocade family detected here if device responds to 'uname' command,
+      # happens when logging in as root
+      plat.family('brocade').title('Brocade Family').in_family('linux')
+          .detect {
+            !brocade_version.nil?
+          }
+
+      # genaric linux
+      # this should always be last in the linux family list
+      plat.name('linux').title('Genaric Linux').in_family('linux')
+          .detect {
+            true
+          }
+
+      # openvms
+      plat.name('openvms').title('OpenVMS').in_family('unix')
+          .detect {
+            if unix_uname_s =~ /unrecognized command verb/i
+              cmd = @backend.run_command('show system/noprocess')
+              unless cmd.exit_status != 0 || cmd.stdout.empty?
+                @platform[:name] = cmd.stdout.downcase.split(' ')[0]
+                cmd = @backend.run_command('write sys$output f$getsyi("VERSION")')
+                @platform[:release] = cmd.stdout.downcase.split("\n")[1][1..-1]
+                cmd = @backend.run_command('write sys$output f$getsyi("ARCH_NAME")')
+                @platform[:arch] = cmd.stdout.downcase.split("\n")[1]
+                true
+              end
+            end
+          }
+
+      # aix
+      plat.family('aix').in_family('unix')
+          .detect {
+            true if unix_uname_s =~ /aix/i
+          }
+      plat.name('aix').title('Aix').in_family('aix')
+          .detect {
+            out = @backend.run_command('uname -rvp').stdout
+            m = out.match(/(\d+)\s+(\d+)\s+(.*)/)
+            unless m.nil?
+              @platform[:release] = "#{m[2]}.#{m[1]}"
+              @platform[:arch] = m[3].to_s
+            end
+            true
+          }
+
+      # solaris family
+      plat.family('solaris').in_family('unix')
+          .detect {
+            if unix_uname_s =~ /sunos/i
+              unless (version = /^5\.(?<release>\d+)$/.match(unix_uname_r)).nil?
+                @platform[:release] = version['release']
+              end
+
+              arch = @backend.run_command('uname -p')
+              @platform[:arch] = arch.stdout.chomp if arch.exit_status == 0
+              true
+            end
+          }
+      plat.name('smartos').title('SmartOS').in_family('solaris')
+          .detect {
+            rel = unix_file_contents('/etc/release')
+            if /^.*(SmartOS).*$/ =~ rel
+              true
+            end
+          }
+      plat.name('omnios').title('Omnios').in_family('solaris')
+          .detect {
+            rel = unix_file_contents('/etc/release')
+            if !(m = /^\s*(OmniOS).*r(\d+).*$/.match(rel)).nil?
+              @platform[:release] = m[2]
+              true
+            end
+          }
+      plat.name('openindiana').title('Openindiana').in_family('solaris')
+          .detect {
+            rel = unix_file_contents('/etc/release')
+            if !(m = /^\s*(OpenIndiana).*oi_(\d+).*$/.match(rel)).nil?
+              @platform[:release] = m[2]
+              true
+            end
+          }
+      plat.name('opensolaris').title('Open Solaris').in_family('solaris')
+          .detect {
+            rel = unix_file_contents('/etc/release')
+            if !(m = /^\s*(OpenSolaris).*snv_(\d+).*$/.match(rel)).nil?
+              @platform[:release] = m[2]
+              true
+            end
+          }
+      plat.name('nexentacore').title('Nexentacore').in_family('solaris')
+          .detect {
+            rel = unix_file_contents('/etc/release')
+            if /^\s*(NexentaCore)\s.*$/ =~ rel
+              true
+            end
+          }
+      plat.name('solaris').title('Solaris').in_family('solaris')
+          .detect {
+            rel = unix_file_contents('/etc/release')
+            if !(m = /Oracle Solaris (\d+)/.match(rel)).nil?
+              # TODO: should be string!
+              @platform[:release] = m[1]
+              true
+            elsif /^\s*(Solaris)\s.*$/ =~ rel
+              true
+            end
+
+            # must be some unknown solaris
+            true
+          }
+
+      # hpux
+      plat.family('hpux').in_family('unix')
+          .detect {
+            true if unix_uname_s =~ /hp-ux/i
+          }
+      plat.name('hpux').title('Hpux').in_family('hpux')
+          .detect {
+            @platform[:release] = unix_uname_r.lines[0].chomp
+            true
+          }
+
+      # qnx
+      plat.family('qnx').in_family('unix')
+          .detect {
+            true if unix_uname_s =~ /qnx/i
+          }
+      plat.name('qnx').title('QNX').in_family('qnx')
+          .detect {
+            @platform[:name] = unix_uname_s.lines[0].chomp.downcase
+            @platform[:release] = unix_uname_r.lines[0].chomp
+            @platform[:arch] = unix_uname_m
+            true
+          }
+
+      # bsd family
+      plat.family('bsd').in_family('unix')
+          .detect {
+            # we need a better way to determin this family
+            # for now we are going to just try each platform
+            true
+          }
+      plat.family('darwin').in_family('bsd')
+          .detect {
+            if unix_uname_s =~ /darwin/i
+              cmd = unix_file_contents('/usr/bin/sw_vers')
+              unless cmd.nil?
+                m = cmd.match(/^ProductVersion:\s+(.+)$/)
+                @platform[:release] = m.nil? ? nil : m[1]
+                m = cmd.match(/^BuildVersion:\s+(.+)$/)
+                @platform[:build] = m.nil? ? nil : m[1]
+              end
+              @platform[:release] = unix_uname_r.lines[0].chomp if @platform[:release].nil?
+              @platform[:arch] = unix_uname_m
+              true
+            end
+          }
+      plat.name('mac_os_x').title('macOS X').in_family('darwin')
+          .detect {
+            cmd = unix_file_contents('/System/Library/CoreServices/SystemVersion.plist')
+            @platform[:uuid_command] = "system_profiler SPHardwareDataType | awk '/UUID/ { print $3; }'"
+            true if cmd =~ /Mac OS X/i
+          }
+      plat.name('darwin').title('Darwin').in_family('darwin')
+          .detect {
+            # must be some other type of darwin
+            @platform[:name] = unix_uname_s.lines[0].chomp
+            true
+          }
+      plat.name('freebsd').title('Freebsd').in_family('bsd')
+          .detect {
+            if unix_uname_s =~ /freebsd/i
+              @platform[:name] = unix_uname_s.lines[0].chomp
+              @platform[:release] = unix_uname_r.lines[0].chomp
+              true
+            end
+          }
+      plat.name('openbsd').title('Openbsd').in_family('bsd')
+          .detect {
+            if unix_uname_s =~ /openbsd/i
+              @platform[:name] = unix_uname_s.lines[0].chomp
+              @platform[:release] = unix_uname_r.lines[0].chomp
+              true
+            end
+          }
+      plat.name('netbsd').title('Netbsd').in_family('bsd')
+          .detect {
+            if unix_uname_s =~ /netbsd/i
+              @platform[:name] = unix_uname_s.lines[0].chomp
+              @platform[:release] = unix_uname_r.lines[0].chomp
+              true
+            end
+          }
+
+      # arista_eos family
+      plat.family('arista_eos').title('Arista EOS Family').in_family('os')
+          .detect {
+            true
+          }
+      plat.name('arista_eos').title('Arista EOS').in_family('arista_eos')
+          .detect {
+            cmd = @backend.run_command('show version | json')
+            if cmd.exit_status == 0 && !cmd.stdout.empty?
+              require 'json'
+              begin
+                eos_ver = JSON.parse(cmd.stdout)
+                @platform[:release] = eos_ver['version']
+                @platform[:arch] = eos_ver['architecture']
+                true
+              rescue JSON::ParserError
+                nil
+              end
+            end
+          }
+
+      # esx
+      plat.family('esx').title('ESXi Family').in_family('os')
+          .detect {
+            true if unix_uname_s =~ /vmkernel/i
+          }
+      plat.name('vmkernel').in_family('esx')
+          .detect {
+            @platform[:name] = unix_uname_s.lines[0].chomp
+            @platform[:release] = unix_uname_r.lines[0].chomp
+            true
+          }
+
+      # cisco_ios family
+      plat.family('cisco').title('Cisco Family').in_family('os')
+          .detect {
+            !cisco_show_version.nil?
+          }
+      plat.name('cisco_ios').title('Cisco IOS').in_family('cisco')
+          .detect {
+            v = cisco_show_version
+            next unless v[:type] == 'ios'
+            @platform[:release] = v[:version]
+            @platform[:arch] = nil
+            true
+          }
+      plat.name('cisco_ios_xe').title('Cisco IOS XE').in_family('cisco')
+          .detect {
+            v = cisco_show_version
+            next unless v[:type] == 'ios-xe'
+            @platform[:release] = v[:version]
+            @platform[:arch] = nil
+            true
+          }
+      plat.name('cisco_nexus').title('Cisco Nexus').in_family('cisco')
+          .detect {
+            v = cisco_show_version
+            next unless v[:type] == 'nexus'
+            @platform[:release] = v[:version]
+            @platform[:arch] = nil
+            @platform[:uuid_command] = 'show inventory chassis | include SN'
+            true
+          }
+
+      # brocade family
+      plat.family('brocade').title('Brocade Family').in_family('os')
+          .detect {
+            !brocade_version.nil?
+          }
+
+      plat.name('brocade_fos').title('Brocade FOS').in_family('brocade')
+          .detect {
+            v = brocade_version
+            next unless v[:type] == 'fos'
+            @platform[:release] = v[:version]
+            @platform[:arch] = nil
+            true
+          }
+    end
+  end
+end