specinfra-rb19 2.44.7

data/lib/specinfra/host_inventory/base.rb

@@ -0,0 +1,14 @@
+module Specinfra
+  class HostInventory
+    class Base
+      def initialize(host_inventory)
+        @host_inventory = host_inventory
+      end
+
+      def backend
+        @host_inventory.backend
+      end
+    end
+  end
+end
+

data/lib/specinfra/host_inventory/block_device.rb

@@ -0,0 +1,35 @@
+module Specinfra
+  class HostInventory
+    class BlockDevice < Base
+      # examples:
+      #   /sys/block/sda/size	10000
+      #   /sys/block/sr0/device/model	CD-ROM
+      BLOCK_DEVICE_REGEX = %r|\A/sys/block/(\w+)/(\w+)(?:/(\w+))?\t(.+)\z|
+
+      def get
+        cmd = backend.command.get(:get_inventory_block_device)
+        ret = backend.run_command(cmd)
+        if ret.exit_status == 0
+          parse(ret.stdout)
+        else
+          nil
+        end
+      end
+      def parse(ret)
+        block_device = {}
+        ret.each_line do |line|
+          line.strip!
+          if m = line.match(BLOCK_DEVICE_REGEX)
+            device = m[1].to_s
+            check = m[3].nil? ? m[2].to_s : m[3].to_s
+            value = m[4].to_s
+
+            block_device[device] = {} if block_device[device].nil?
+            block_device[device][check] = value
+          end
+        end
+        block_device
+      end
+    end
+  end
+end

data/lib/specinfra/host_inventory/cpu.rb

@@ -0,0 +1,77 @@
+module Specinfra
+  class HostInventory
+    class Cpu < Base
+      def get
+        cmd = backend.command.get(:get_inventory_cpu)
+        ret = backend.run_command(cmd)
+        if ret.exit_status == 0
+           parse(ret.stdout)
+        else
+           nil
+        end
+      end
+      def parse(cmd_ret)
+        cpuinfo = {}
+        cpus = cmd_ret.split(/[^^]processor/)
+        cpuinfo['total'] = cpus.length.to_s
+        cpus.each_with_index do |cpu, idx|
+          idx = idx.to_s
+          cpuinfo[idx] = {}
+          cpu.each_line do |line|
+            case line
+            when /^vendor_id\s*:\s+(.+)$/
+              cpuinfo[idx]['vendor_id'] = $1
+            when /^cpu family\s*:\s+(\d+)$/
+              cpuinfo[idx]['cpu_family'] = $1
+            when /^model\s*:\s+(\d+)$/
+              cpuinfo[idx]['model'] = $1
+            when /^model\sname\s*:\s+(.+)$/
+              cpuinfo[idx]['model_name'] = $1
+            when /^stepping\s*:\s+(\d+)$/
+              cpuinfo[idx]['stepping'] = $1
+            when /^microcode\s*:\s+(.+)$/
+              cpuinfo[idx]['microcode'] = $1
+            when /^cpu MHz\s*:\s+(.+)$/
+              cpuinfo[idx]['cpu_mhz'] = $1
+            when /^cache size\s*:\s+(\d+) (.+)$/
+              cpuinfo[idx]['cache_size'] = "#{$1}#{$2}"
+            when /^physical id\s*:\s+(\d+)$/
+              cpuinfo[idx]['physical_id'] = $1
+            when /^siblings\s*:\s+(\d+)$/
+              cpuinfo[idx]['siblings'] = $1
+            when /^core id\s*:\s+(\d+)$/
+              cpuinfo[idx]['core_id'] = $1
+            when /^cpu cores\s*:\s+(\d+)$/
+              cpuinfo[idx]['cpu_cores'] = $1
+            when /^apicid\s*:\s+(\d+)$/
+              cpuinfo[idx]['apicid'] = $1
+            when /^initial apicid\s*:\s+(\d+)$/
+              cpuinfo[idx]['initial_apicid'] = $1
+            when /^fpu\s*:\s+(.+)$/
+              cpuinfo[idx]['fpu'] = $1
+            when /^fpu_exception\s*:\s+(.+)$/
+              cpuinfo[idx]['fpu_exception'] = $1
+            when /^cpuid level\s*:\s+(\d+)$/
+              cpuinfo[idx]['cpuid_level'] = $1
+            when /^wp\s*:\s+(.+)$/
+              cpuinfo[idx]['wp'] = $1
+            when /^flags\s*:\s+(.+)$/
+              cpuinfo[idx]['flags'] = $1.split(/\s/)
+            when /^bogomips\s*:\s+(.+)$/
+              cpuinfo[idx]['bogomips'] = $1
+            when /^clflush size\s*:\s+(\d+)$/
+              cpuinfo[idx]['clflush_size'] = $1
+            when /^cache_alignment\s*:\s+(\d+)$/
+              cpuinfo[idx]['cache_alignment'] = $1
+            when /^address sizes\s*:\s+(.+)$/
+              cpuinfo[idx]['address_sizes'] = $1
+            when /^power management\s*:\s+(.*)$/
+              cpuinfo[idx]['power_management'] = $1
+            end
+          end
+        end
+        cpuinfo
+      end
+    end
+  end
+end

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,45 @@
+module Specinfra
+  class HostInventory
+    class Virtualization < Base
+      def get
+        res = {}
+        ## docker 
+        if backend.run_command('ls /.dockerinit').success?
+          res[:system] = 'docker'
+          return res
+        end
+
+        ## OpenVZ on Linux 
+        if backend.run_command('test -d /proc/vz -a ! -d /proc/bc').success?
+          res[:system] = 'openvz'
+          return res
+        end
+
+        cmd = backend.command.get(:get_inventory_system_product_name)
+        ret = backend.run_command(cmd)
+        if ret.exit_status == 0
+           res[:system] = parse_system_product_name(ret.stdout)   
+        end 
+
+        res 
+      end 
+
+      def parse_system_product_name(ret)
+        product_name = case ret
+          when /.*VMware Virtual Platform/
+            'vmware'
+          when /.*VirtualBox/
+            'vbox'
+          when /.*KVM/
+            'kvm'
+          when /.*OpenStack/
+            'openstack'
+          else
+            nil
+        end
+        product_name
+      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" or "stop/waiting".
+      return false if ret.stdout =~ /stop(ped)?\/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