smart_proxy_onboard 0.1.1 → 0.2.1

data/.travis.yml

@@ -5,7 +5,7 @@ notifications:
 sudo: false
 language: ruby
 rvm:
-  - 2.0.0
+  - 2.7.1
 before_install:
-  - gem install bundler -v 1.14.3
+  - gem install bundler
   - mkdir ./logs

data/Gemfile

@@ -6,5 +6,10 @@ gemspec
 group :development do
   gem 'smart_proxy',
       git: 'https://github.com/theforeman/smart-proxy.git',
-      branch: '1.15-stable'
+      branch: 'develop'
+end
+
+group :test do
+  gem 'rubocop', require: false
+  gem 'simplecov', require: false
 end

data/README.md

@@ -33,7 +33,8 @@ This plugin is made for the following combination of software:
 
 ### Currently Implemented
 
- - IPMI IP range scanner
+ - Scan IP ranges for IPMI appliances
+ - Clear FreeIPMI sensor data repository (SDR) cache
 
 ### Planned
 
@@ -41,9 +42,9 @@ No additional features have been planned so far.
 
 ## API
 
-### `GET /bmc/scan`
+### `GET /onboard/bmc/scan`
 
-Shows available resources `/bmc/scan/range` and `/bmc/scan/cidr`
+Shows available resources `/onboard/bmc/scan/range` and `/onboard/bmc/scan/cidr`
 
     {
       "available_resources": [
@@ -52,27 +53,27 @@ Shows available resources `/bmc/scan/range` and `/bmc/scan/cidr`
       ]
     }
 
-### `GET /bmc/scan/range`
+### `GET /onboard/bmc/scan/range`
 
 Shows usage on specifying a beginning IP address and an ending IP address for making a scan request
 
     {
-      "message": "You need to supply a range with /bmc/scan/range/:address_first/:address_last"
+      "message": "You need to supply a range with /onboard/bmc/scan/range/:address_first/:address_last"
     }
 
-### `GET /bmc/scan/cidr`
+### `GET /onboard/bmc/scan/cidr`
 
 Shows usage on specifying an IP address and its netmask in dot decimal format or prefixlen format for making a scan request
 
     {
-      "message": "You need to supply a CIDR with /bmc/scan/cidr/:address/:netmask (e.g. \"192.168.1.1/24\" or \"192.168.1.1/255.255.255.0\")"
+      "message": "You need to supply a CIDR with /onboard/bmc/scan/cidr/:address/:netmask (e.g. \"192.168.1.1/24\" or \"192.168.1.1/255.255.255.0\")"
     }
 
-### `GET /bmc/scan/range/:address_first/:address_last`
+### `GET /onboard/bmc/scan/range/:address_first/:address_last`
 
 Performs an IPMI ping scan from `:address_first` to `:address_last` and returns the result in key "`result`" of a JSON hash
 
-Sample output for `/bmc/scan/range/10.246.0.65/10.246.0.71`:
+Sample output for `/onboard/bmc/scan/range/10.246.0.65/10.246.0.71`:
 
     {
       "result": [
@@ -86,11 +87,11 @@ Sample output for `/bmc/scan/range/10.246.0.65/10.246.0.71`:
       ]
     }
 
-### `GET /bmc/scan/cidr/:address/:netmask`
+### `GET /onboard/bmc/scan/cidr/:address/:netmask`
 
 Performs an IPMI ping scan in the CIDR range of `:address`/`:netmask`, where `:netmask` is in decimal format (e.g. "`255.255.255.0`") or in prefixlen format (e.g. "`24`")
 
-Sample output for `/bmc/scan/cidr/10.246.0.65/29`:
+Sample output for `/onboard/bmc/scan/cidr/10.246.0.65/29`:
 
     {
       "result": [
@@ -103,3 +104,42 @@ Sample output for `/bmc/scan/cidr/10.246.0.65/29`:
         "10.246.0.71"
       ]
     }
+
+### `DELETE /onboard/bmc/sdr_cache`
+
+(_FreeIPMI only_) Deletes the sensor data repository (SDR) cache from the Smart Proxy.  This is useful when you run something like `GET /bmc/10.246.0.69/fru/list` with `bmc_provider=freeipmi` and you get a reply like this:
+
+    {
+      "action": "list",
+      "result": {
+        "": {
+          "sdr_cache_'/tmp/.freeipmi-foreman-proxy/.freeipmi/sdr-cache/sdr-cache-smartproxyhostname.10.246.0.69'_invalid": "Please flush the cache and regenerate it"
+        }
+      }
+    }
+
+Instead of manually logging in to the Smart Proxy and deleting `/tmp/.freeipmi-foreman-proxy/.freeipmi/sdr-cache`, just run this method, and you'll get this reply:
+
+    {
+      "result": true,
+      "message": "SDR cache deleted"
+    }
+
+If there's no SDR cache present, you'll see:
+
+    {
+      "result": true,
+      "message": "No SDR cache to delete"
+    }
+
+If the deletion failed, you'll see something like this:
+
+    {
+      "errors": [
+        "Permission denied @ dir_s_rmdir - /tmp/.freeipmi-foreman-proxy/.freeipmi/sdr-cache"
+      ],
+      "result": false,
+      "message": "Failed to delete one or more SDR cache location candidates"
+    }
+
+As long as `{"result":true}`, you will not encounter the `sdr_cache_…_invalid` error next time.

data/lib/bmc/basescanner.rb

@@ -6,7 +6,7 @@ module Proxy
     module BMC
       # This is the interface for scanning BMC IP address ranges.
       class BaseScanner
-        def initialize(args = { })
+        def initialize(args = {})
           if args.key? :address_first
             address_first = IPAddr.new args[:address_first]
             address_last  = IPAddr.new args[:address_last]
@@ -18,34 +18,34 @@ module Proxy
           end
           # Disallow range too large
           scanner_max_range_size = max_range_size
-          if @range.first(scanner_max_range_size+1).size > scanner_max_range_size
+          if @range.first(scanner_max_range_size + 1).size > scanner_max_range_size
             @range = nil
             @invalid_reason = "Range too large. Batch supports only #{scanner_max_range_size} IP addresses at a time."
           end
-        rescue
+        rescue StandardError
           @range = nil
-          if args.is_a?(Hash) && args.key?(:address)
-            @invalid_reason = "Invalid CIDR provided"
-          else
-            @invalid_reason = "Invalid IP address provided"
-          end
+          @invalid_reason = if args.is_a?(Hash) && args.key?(:address)
+                              'Invalid CIDR provided'
+                            else
+                              'Invalid IP address provided'
+                            end
         end
-  
+
         def valid?
           @range.is_a? Range
         end
-  
+
         def error_string
           @invalid_reason
         end
-  
+
         def max_range_size
           Proxy::Onboard::Plugin.settings.bmc_scanner_max_range_size || 65_536
         end
-  
+
         # Run the scanner and return results as array
         def scan_to_list
-          raise NotImplementedError.new
+          raise NotImplementedError
         end
       end
     end

data/lib/bmc/ipmiscanner.rb

@@ -7,13 +7,13 @@ module Proxy
       class IPMIScanner < BaseScanner
         include Proxy::Log
         include Proxy::Util
-  
+
         # This is an IPMI ping, not an ICMP ping.
         def address_pings?(address)
           begin
             socket = UDPSocket.new
           rescue Errno::EMFILE
-            logger.warn "IPMIScanner: Ran out of free file descriptors while creating UDPSocket! Consider increasing file open limit."
+            logger.warn 'IPMIScanner: Ran out of free file descriptors while creating UDPSocket! Consider increasing file open limit.'
             retry
           end
           socket.connect(address.to_s, 623)
@@ -22,59 +22,52 @@ module Proxy
           socket.close
           !selections.nil?
         end
-  
+
         # Not used because of slowness
         def scan_unthreaded_to_list
-          return false if !valid?
-          pinged = Array.new
+          return false unless valid?
+          pinged = []
           @range.each do |address|
-            if address_pings?(address)
-              pinged << address
-            end
+            pinged << address if address_pings?(address)
           end
           pinged
         end
-  
+
         # Determine maximum number of threads
         def calculate_max_threads
           max_threads = Proxy::Onboard::Plugin.settings.bmc_scanner_max_threads_per_request || 500
           begin
-            sockets = Array.new
+            sockets = []
             # @range.first(max_threads).size performs much better than @range.count if @range is large.
             (1..[max_threads, @range.first(max_threads).size].min).each do
-              socket = UDPSocket.new
-              sockets << socket
+              sockets << UDPSocket.new
             end
           rescue Errno::EMFILE
             # Running low on free file descriptors; only allow use of half of the remaining
             max_threads = [sockets.length / 2, 1].max
             # Clean up sockets
-            sockets.each do |sock|
-              sock.close
-            end
+            sockets.each(&:close)
             logger.warn "IPMIScanner: Running low on free file descriptors! Can only allocate #{sockets.length}, so using #{max_threads} to avoid hitting the limit."
           end
           max_threads
         end
-  
+
         def scan_threaded_to_list
-          return false if !valid?
-          pinged = Array.new
+          return false unless valid?
+          pinged = []
           pool = Concurrent::ThreadPoolExecutor.new(max_threads: calculate_max_threads)
           @range.each do |address|
             pool.post do
-              if address_pings?(address)
-                pinged << address
-              end
+              pinged << address if address_pings?(address)
             end
           end
           pool.shutdown
           pool.wait_for_termination
           pinged
         end
-  
+
         def scan_to_list
-          return false if !valid?
+          return false unless valid?
           scan_threaded_to_list
         end
       end

data/lib/bmc/sdr_cache.rb

@@ -0,0 +1,68 @@
+require 'smart_proxy_onboard'
+require 'fileutils'
+
+module Proxy
+  module Onboard
+    module BMC
+      class SDRCache
+        include Proxy::Log
+        include Proxy::Util
+
+        # Determined from
+        # https://git.savannah.gnu.org/cgit/freeipmi.git/tree/common/toolcommon/tool-sdr-cache-common.c?h=Release-1_4_11
+        def possible_paths
+          paths = []
+          sdr_cache_directory = sdr_cache_directory_from_freeipmi_conf
+          paths << sdr_cache_directory unless sdr_cache_directory.nil?
+          etc = Etc.getpwuid(Process.uid)
+          paths + [
+            "#{etc.dir}/.freeipmi/sdr-cache",
+            "/tmp/.freeipmi-#{etc.name}/.freeipmi/sdr-cache"
+          ]
+        end
+
+        def existing_possible_paths
+          paths = []
+          possible_paths.each do |path|
+            paths << path if File.exist?(path)
+          end
+          paths
+        end
+
+        def present?
+          !existing_possible_paths.empty?
+        end
+
+        def delete
+          errors = []
+          existing_possible_paths.each do |path|
+            begin
+              FileUtils.remove_entry_secure(path)
+            rescue Errno::ENOENT
+              next
+            rescue SystemCallError => e
+              errors << e
+              next
+            end
+          end
+          return { errors: errors } unless errors.empty?
+          true
+        end
+
+        private
+
+        def sdr_cache_directory_from_freeipmi_conf
+          freeipmi_conf_handle = File.open('/etc/freeipmi/freeipmi.conf', 'r')
+          match = %r{^[[:blank:]]*sdr-cache-directory[[:blank:]]+\/}
+          freeipmi_conf_handle.grep(match).last.gsub(match, '/').gsub(/\n$/, '')
+        rescue SystemCallError
+          logger.debug 'Cannot determine sdr-cache-directory from FreeIPMI configuration file'
+          nil
+        rescue NoMethodError
+          logger.debug 'FreeIPMI configuration file does not contain sdr-cache-directory'
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_onboard/api_bmc.rb

@@ -1,49 +1,63 @@
 require 'smart_proxy'
+require 'bmc/ipmiscanner'
+require 'bmc/sdr_cache'
 
-module Proxy::Onboard
-  class ApiBmc < Sinatra::Base
-    helpers ::Proxy::Helpers
-  
-    # Scan IP range for BMC hosts
-    # Returns a list of available scanning options
-    get "/scan" do
-      { :available_resources => %w[range cidr] }.to_json
-    end
+module Proxy
+  module Onboard
+    class ApiBmc < Sinatra::Base
+      helpers ::Proxy::Helpers
 
-    # Returns a helpful message that the user should supply a beginning IP and ending IP
-    get "/scan/range" do
-      { :message => "You need to supply a range with /bmc/scan/range/:address_first/:address_last"}.to_json
-    end
+      # Scan IP range for BMC hosts
+      # Returns a list of available scanning options
+      get '/scan' do
+        { available_resources: %w[range cidr] }.to_json
+      end
 
-    # Returns a helpful message that the user should supply a CIDR
-    get "/scan/cidr" do
-      { :message => "You need to supply a CIDR with /bmc/scan/cidr/:address/:netmask (e.g. \"192.168.1.1/24\" or \"192.168.1.1/255.255.255.0\")"}.to_json
-    end
+      # Returns a helpful message that the user should supply a beginning IP and ending IP
+      get '/scan/range' do
+        { message: 'You need to supply a range with /onboard/bmc/scan/range/:address_first/:address_last' }.to_json
+      end
 
-    ["/scan/range/:address_first/?:address_last?",
-     "/scan/cidr/:address/?:netmask?"].each do |path|
-      get path do
-        scanner_setup
-        if !@scanner.valid?
-          { :error => @scanner.error_string}.to_json
-        else
-          { :result => @scanner.scan_to_list}.to_json
+      # Returns a helpful message that the user should supply a CIDR
+      get '/scan/cidr' do
+        { message: 'You need to supply a CIDR with /onboard/bmc/scan/cidr/:address/:netmask (e.g. "192.168.1.1/24" or "192.168.1.1/255.255.255.0")' }.to_json
+      end
+
+      ['/scan/range/:address_first/?:address_last?',
+       '/scan/cidr/:address/?:netmask?'].each do |path|
+        get path do
+          scanner_setup
+          if !@scanner.valid?
+            { error: @scanner.error_string }.to_json
+          else
+            { result: @scanner.scan_to_list }.to_json
+          end
         end
       end
-    end
 
-    def scanner_setup
-      args = {}
-      # /scan/cidr/:address/:netmask
-      if params.key? "address"
-        args = { :address => params[:address],
-                 :netmask => params[:netmask] }
-      # /scan/range/:address_first/:address_last
-      elsif params.key? "address_first"
-        args = { :address_first => params[:address_first],
-                 :address_last  => params[:address_last] }
+      def scanner_setup
+        args = {}
+        # /scan/cidr/:address/:netmask
+        if params.key? 'address'
+          args = { address: params[:address],
+                   netmask: params[:netmask] }
+        # /scan/range/:address_first/:address_last
+        elsif params.key? 'address_first'
+          args = { address_first: params[:address_first],
+                   address_last: params[:address_last] }
+        end
+        @scanner = Proxy::Onboard::BMC::IPMIScanner.new(args)
+      end
+
+      # Clear the SDR cache
+      delete '/sdr_cache' do
+        sdr_cache = Proxy::Onboard::BMC::SDRCache.new
+        return { result: true, message: 'No SDR cache to delete' }.to_json unless sdr_cache.present?
+        result = sdr_cache.delete
+        return result.merge(result: false, message: 'Failed to delete one or more SDR cache location candidates').to_json if result.is_a? Hash
+        return { result: true, message: 'SDR cache deleted' }.to_json if result == true
+        return { result: false, message: 'Unexpected response from delete function' }.to_json
       end
-      @scanner = Proxy::Onboard::BMC::IPMIScanner.new(args)
     end
   end
 end