specinfra-cisco 2.40.2

data/lib/specinfra/host_inventory/domain.rb

@@ -0,0 +1,16 @@
+module Specinfra
+  class HostInventory
+    class Domain < Base
+      def get
+        cmd = backend.command.get(:get_inventory_domain)
+        result = backend.run_command(cmd)
+
+        if result.exit_status == 0
+          result.stdout.strip
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/ec2.rb

@@ -0,0 +1,11 @@
+require 'specinfra/ec2_metadata'
+
+module Specinfra
+  class HostInventory
+    class Ec2 < Base
+      def get
+        Specinfra::Ec2Metadata.new(@host_inventory).get
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/filesystem.rb

@@ -0,0 +1,31 @@
+module Specinfra
+  class HostInventory
+    class Filesystem < Base
+      def get
+        cmd = backend.command.get(:get_inventory_filesystem)
+        ret = backend.run_command(cmd)
+        if ret.exit_status == 0
+          parse(ret.stdout)
+        else
+          nil
+        end
+      end
+      def parse(ret)
+        filesystem = {}
+        ret.each_line do |line|
+          next if line =~ /^Filesystem\s+/
+          if line =~ /^(.+?)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+\%)\s+(.+)$/
+            device = $1
+            filesystem[device] = {}
+            filesystem[device]['kb_size'] = $2
+            filesystem[device]['kb_used'] = $3
+            filesystem[device]['kb_available'] = $4
+            filesystem[device]['percent_used'] = $5
+            filesystem[device]['mount'] = $6
+          end
+        end
+        filesystem
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/fqdn.rb

@@ -0,0 +1,16 @@
+module Specinfra
+  class HostInventory
+    class Fqdn < Base
+      def get
+        cmd = backend.command.get(:get_inventory_fqdn)
+        result = backend.run_command(cmd)
+
+        if result.exit_status == 0
+          result.stdout.strip
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/hostname.rb

@@ -0,0 +1,16 @@
+module Specinfra
+  class HostInventory
+    class Hostname < Base
+      def get
+        cmd = backend.command.get(:get_inventory_hostname)
+        result = backend.run_command(cmd)
+
+        if result.exit_status == 0
+          result.stdout.strip
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/kernel.rb

@@ -0,0 +1,27 @@
+module Specinfra
+  class HostInventory
+    class Kernel < Base
+      def get
+        kernel = {}
+        kernel['machine'] = backend.os_info[:arch]
+
+        cmd = backend.command.get(:get_inventory_kernel)
+        ret = backend.run_command(cmd)
+        if ret.exit_status == 0
+          kernel = kernel.merge(parse_uname(ret.stdout))
+        end
+        kernel
+      end
+
+      def parse_uname(ret)
+        match = ret.match(/^(\w+) (((\d+\.\d+)\.\d+).*)$/)
+        if match
+          name, release, version, major = match.captures
+          Hash['name', name, "release", release, "version", version, "version_major", major]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/memory.rb

@@ -0,0 +1,83 @@
+module Specinfra
+  class HostInventory
+    class Memory < Base
+      def get
+        cmd = backend.command.get(:get_inventory_memory)
+        ret = backend.run_command(cmd)
+        if ret.exit_status == 0
+          parse(ret.stdout)
+        else
+          nil
+        end
+      end
+      def parse(ret)
+        memory = { 'swap' => {} }
+        ret.each_line do |line|
+          case line
+          when /^SwapCached:\s+(\d+) (.+)$/
+            memory['swap']['cached'] = "#{$1}#{$2}"
+          when /^SwapTotal:\s+(\d+) (.+)$/
+            memory['swap']['total'] = "#{$1}#{$2}"
+          when /^SwapFree:\s+(\d+) (.+)$/
+            memory['swap']['free'] = "#{$1}#{$2}"
+          when /^MemTotal:\s+(\d+) (.+)$/
+            memory['total'] = "#{$1}#{$2}"
+          when /^MemFree:\s+(\d+) (.+)$/
+            memory['free'] = "#{$1}#{$2}"
+          when /^Buffers:\s+(\d+) (.+)$/
+            memory['buffers'] = "#{$1}#{$2}"
+          when /^Cached:\s+(\d+) (.+)$/
+            memory['cached'] = "#{$1}#{$2}"
+          when /^Active:\s+(\d+) (.+)$/
+            memory['active'] = "#{$1}#{$2}"
+          when /^Inactive:\s+(\d+) (.+)$/
+            memory['inactive'] = "#{$1}#{$2}"
+          when /^Dirty:\s+(\d+) (.+)$/
+            memory['dirty'] = "#{$1}#{$2}"
+          when /^Writeback:\s+(\d+) (.+)$/
+            memory['writeback'] = "#{$1}#{$2}"
+          when /^AnonPages:\s+(\d+) (.+)$/
+            memory['anon_pages'] = "#{$1}#{$2}"
+          when /^Mapped:\s+(\d+) (.+)$/
+            memory['mapped'] = "#{$1}#{$2}"
+          when /^Slab:\s+(\d+) (.+)$/
+            memory['slab'] = "#{$1}#{$2}"
+          when /^SReclaimable:\s+(\d+) (.+)$/
+            memory['slab_reclaimable'] = "#{$1}#{$2}"
+          when /^SUnreclaim:\s+(\d+) (.+)$/
+            memory['slab_unreclaim'] = "#{$1}#{$2}"
+          when /^PageTables:\s+(\d+) (.+)$/
+            memory['page_tables'] = "#{$1}#{$2}"
+          when /^NFS_Unstable:\s+(\d+) (.+)$/
+            memory['nfs_unstable'] = "#{$1}#{$2}"
+          when /^Bounce:\s+(\d+) (.+)$/
+            memory['bounce'] = "#{$1}#{$2}"
+          when /^CommitLimit:\s+(\d+) (.+)$/
+            memory['commit_limit'] = "#{$1}#{$2}"
+          when /^Committed_AS:\s+(\d+) (.+)$/
+            memory['committed_as'] = "#{$1}#{$2}"
+          when /^VmallocTotal:\s+(\d+) (.+)$/
+            memory['vmalloc_total'] = "#{$1}#{$2}"
+          when /^VmallocUsed:\s+(\d+) (.+)$/
+            memory['vmalloc_used'] = "#{$1}#{$2}"
+          when /^VmallocChunk:\s+(\d+) (.+)$/
+            memory['vmalloc_chunk'] = "#{$1}#{$2}"
+          when /^AnonHugePages:\s+(\d+) (.+)$/
+            memory['annon_huge_pages'] = "#{$1}#{$2}"
+          when /^HugePages_Total:\s+(\d+)$/
+            memory['huge_pages_total'] = "#{$1}"
+          when /^HugePages_Free:\s+(\d+)$/
+            memory['huge_pages_free'] = "#{$1}"
+          when /^HugePages_Rsvd:\s+(\d+)$/
+            memory['huge_pages_rsvd'] = "#{$1}"
+          when /^HugePages_Surp:\s+(\d+)$/
+            memory['huge_pages_surp'] = "#{$1}"
+          when /^Hugepagesize:\s+(\d+) (.+)$/
+            memory['huge_page_size'] = "#{$1}#{$2}"
+          end
+        end
+        memory
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/platform.rb

@@ -0,0 +1,9 @@
+module Specinfra
+  class HostInventory
+    class Platform < Base
+      def get
+        backend.os_info[:family]
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/platform_version.rb

@@ -0,0 +1,15 @@
+module Specinfra
+  class HostInventory
+    class PlatformVersion < Base
+      def get
+        backend.os_info[:release]
+      end
+    end
+  end
+end
+
+
+
+
+
+

data/lib/specinfra/host_inventory/virtualization.rb

@@ -0,0 +1,39 @@
+module Specinfra
+  class HostInventory
+    class Virtualization < Base
+      def get
+        res = {}
+        if backend.run_command('ls /.dockerinit').success?
+          res[:system] = 'docker'
+          return res
+        end
+
+        if backend.run_command('ls /usr/sbin/dmidecode').success?
+          ret = backend.run_command('dmidecode')
+          if ret.exit_status == 0
+            case ret.stdout
+            when /Manufacturer: VMware/
+              if ret.stdout =~ /Product Name: VMware Virtual Platform/
+                res[:system] = 'vmware'
+              end
+            when /Manufacturer: Oracle Corporation/
+              if ret.stdout =~ /Product Name: VirtualBox/
+                res[:system] = 'vbox'
+              end
+            when /Product Name: KVM/
+              res[:system] = 'kvm'
+            when /Product Name: OpenStack/
+              res[:system] = 'openstack'
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        res
+      end
+    end
+  end
+end

data/lib/specinfra/processor.rb

@@ -0,0 +1,229 @@
+module Specinfra
+  class Processor
+    def self.check_service_is_running(service)
+      cmd = Specinfra.command.get(:check_service_is_running, service)
+      ret = Specinfra.backend.run_command(cmd)
+
+      # In Ubuntu, some services are under upstart and "service foo status" returns
+      # exit status 0 even though they are stopped.
+      # So return false if stdout contains "stopped/waiting".
+      return false if ret.stdout =~ /stopped\/waiting/
+
+      # If the service is not registered, check by ps command
+      if ret.exit_status == 1
+        cmd = Specinfra.command.get(:check_process_is_running, service)
+        ret = Specinfra.backend.run_command(cmd)
+      end
+
+      ret.success?
+    end
+
+    def self.check_service_is_monitored_by_monit(process)
+      cmd = Specinfra.command.get(:check_service_is_monitored_by_monit, process)
+      ret = Specinfra.backend.run_command(cmd)
+      return false unless ret.stdout != nil && ret.success?
+
+      retlines = ret.stdout.split(/[\r\n]+/).map(&:strip)
+      proc_index = retlines.index("Process '#{process}'")
+      return false unless proc_index
+
+      retlines[proc_index+2].match(/\Amonitoring status\s+monitored\Z/i) != nil
+    end
+
+    def self.check_file_is_readable(file, by_whom)
+      cmd = Specinfra.command.get(:get_file_mode, file)
+      mode = sprintf('%04s',Specinfra.backend.run_command(cmd).stdout.strip)
+      mode = mode.split('')
+      mode_octal = mode[0].to_i * 512 + mode[1].to_i * 64 + mode[2].to_i * 8 + mode[3].to_i * 1
+      case by_whom.to_s
+      when ''
+        mode_octal & 0444 != 0
+      when 'owner'
+        mode_octal & 0400 != 0
+      when 'group'
+        mode_octal & 0040 != 0
+      when 'others'
+        mode_octal & 0004 != 0
+      end
+    end
+
+    def self.check_file_is_writable(file, by_whom)
+      cmd = Specinfra.command.get(:get_file_mode, file)
+      mode = sprintf('%04s',Specinfra.backend.run_command(cmd).stdout.strip)
+      mode = mode.split('')
+      mode_octal = mode[0].to_i * 512 + mode[1].to_i * 64 + mode[2].to_i * 8 + mode[3].to_i * 1
+      case by_whom.to_s
+      when ''
+        mode_octal & 0222 != 0
+      when 'owner'
+        mode_octal & 0200 != 0
+      when 'group'
+        mode_octal & 0020 != 0
+      when 'others'
+        mode_octal & 0002 != 0
+      end
+    end
+
+    def self.check_file_is_executable(file, by_whom)
+      cmd  = Specinfra.command.get(:get_file_mode, file)
+      mode = sprintf('%04s',Specinfra.backend.run_command(cmd).stdout.strip)
+      mode = mode.split('')
+      mode_octal = mode[0].to_i * 512 + mode[1].to_i * 64 + mode[2].to_i * 8 + mode[3].to_i * 1
+      case by_whom.to_s
+      when ''
+        mode_octal & 0111 != 0
+      when 'owner'
+        mode_octal & 0100 != 0
+      when 'group'
+        mode_octal & 0010 != 0
+      when 'others'
+        mode_octal & 0001 != 0
+      end
+    end
+
+    def self.check_file_is_mounted(path, expected_attr, only_with)
+      cmd = Specinfra.command.get(:check_file_is_mounted, path)
+      ret = Specinfra.backend.run_command(cmd)
+      if expected_attr.nil? || ret.failure?
+        return ret.success?
+      end
+
+      mount = ret.stdout.scan(/\S+/)
+      actual_attr    = { :device => mount[0], :type => mount[4] }
+      mount[5].gsub(/\(|\)/, '').split(',').each do |option|
+        name, val = option.split('=')
+        if val.nil?
+          actual_attr[name.to_sym] = true
+        else
+          val = val.to_i if val.match(/^\d+$/)
+          actual_attr[name.to_sym] = val
+        end
+      end
+
+      if ! expected_attr[:options].nil?
+        expected_attr.merge!(expected_attr[:options])
+        expected_attr.delete(:options)
+      end
+
+      if only_with
+        actual_attr == expected_attr
+      else
+        expected_attr.each do |key, val|
+          return false if actual_attr[key] != val
+        end
+        true
+      end
+    end
+
+    def self.check_fstab_has_entry(expected_attr)
+      return false unless expected_attr[:mount_point]
+      cmd = Specinfra.command.get(:get_fstab_entry, expected_attr[:mount_point])
+      ret = Specinfra.backend.run_command(cmd)
+      return false if ret.failure?
+
+      fstab = ret.stdout.scan(/\S+/)
+      actual_attr = {
+        :device      => fstab[0],
+        :mount_point => fstab[1],
+        :type        => fstab[2],
+        :dump        => fstab[4].to_i,
+        :pass        => fstab[5].to_i
+      }
+      fstab[3].split(',').each do |option|
+        name, val = option.split('=')
+        if val.nil?
+          actual_attr[name.to_sym] = true
+        else
+          val = val.to_i if val.match(/^\d+$/)
+          actual_attr[name.to_sym] = val
+        end
+      end
+
+      unless expected_attr[:options].nil?
+        expected_attr.merge!(expected_attr[:options])
+        expected_attr.delete(:options)
+      end
+
+      expected_attr.each do |key, val|
+        return false if actual_attr[key] != val
+      end
+      true
+    end
+
+    def self.check_routing_table_has_entry(expected_attr)
+      return false if ! expected_attr[:destination]
+      cmd = Specinfra.command.get(:get_routing_table_entry, expected_attr[:destination])
+      ret = Specinfra.backend.run_command(cmd)
+      return false if ret.failure?
+
+      ret.stdout.gsub!(/\r\n/, "\n")
+
+      if os[:family] == 'openbsd'
+        match = ret.stdout.match(/^(\S+)\s+(\S+).*?(\S+[0-9]+)(\s*)$/)
+        actual_attr = {
+          :destination => $1,
+          :gateway     => $2,
+          :interface   => expected_attr[:interface] ? $3 : nil
+        }
+      else
+        matches = ret.stdout.scan(/^(\S+)(?: via (\S+))? dev (\S+).+\n|^(\S+).+\n|\s+nexthop via (\S+)\s+dev (\S+).+/)
+        if matches.length > 1
+          # ECMP route
+          destination = nil
+          matches.each do |groups|
+            if groups[3]
+              destination = groups[3]
+              next
+            else
+              next unless expected_attr[:interface] == groups[5]
+            end
+
+            actual_attr = {
+              :destination => destination,
+              :gateway => groups[4],
+              :interface => groups[5]
+            }
+          end
+        elsif matches.length == 1
+          # Non-ECMP route
+          groups = matches[0]
+          actual_attr = {
+            :destination => groups[0],
+            :gateway     => groups[1] ? groups[1] : groups[3],
+            :interface   => expected_attr[:interface] ? groups[2] : nil
+          }
+        end
+
+      end
+
+      expected_attr.each do |key, val|
+        return false if actual_attr[key] != val
+      end
+      true
+    end
+
+    def self.get_default_gateway(attr)
+      cmd = Specinfra.command.get(:get_routing_table_entry, 'default')
+      ret = Specinfra.backend.run_command(cmd)
+      return false if ret.failure?
+
+      ret.stdout.gsub!(/\r\n/, "\n")
+
+      if os[:family] == 'openbsd'
+        match = ret.stdout.match(/^(\S+)\s+(\S+).*?(\S+[0-9]+)(\s*)$/)
+        if attr == :gateway
+          $2
+        elsif attr == :interface
+          $3
+        end
+      else
+        ret.stdout =~ /^(\S+)(?: via (\S+))? dev (\S+).+\n(?:default via (\S+))?/
+        if attr == :gateway
+          $2 ? $2 : $4
+        elsif attr == :interface
+          $3
+        end
+      end
+    end
+  end
+end