oxidized 0.25.1 → 0.26.0

data/lib/oxidized/input/ftp.rb

@@ -5,17 +5,17 @@ module Oxidized
 
   class FTP < Input
     RescueFail = {
-      :debug => [
+      debug: [
         # Net::SSH::Disconnect,
       ],
-      :warn => [
+      warn:  [
         # RuntimeError,
         # Net::SSH::AuthenticationFailed,
-      ],
-    }
+      ]
+    }.freeze
     include Input::CLI
 
-    def connect node
+    def connect(node)
       @node = node
       @node.model.cfg['ftp'].each { |cb| instance_exec(&cb) }
       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-ftp", 'w') if Oxidized.config.input.debug?
@@ -26,16 +26,16 @@ module Oxidized
     end
 
     def connected?
-      @ftp and not @ftp.closed?
+      @ftp && (not @ftp.closed?)
     end
 
-    def cmd file
+    def cmd(file)
       Oxidized.logger.debug "FTP: #{file} @ #{@node.name}"
       @ftp.getbinaryfile file, nil
     end
 
     # meh not sure if this is the best way, but perhaps better than not implementing send
-    def send my_proc
+    def send(my_proc)
       my_proc.call
     end
 

data/lib/oxidized/input/http.rb

@@ -1,35 +1,58 @@
 module Oxidized
-  require_relative "cli"
-
-  begin
-    require "mechanize"
-  rescue LoadError
-    raise OxidizedError, "mechanize not found: sudo gem install mechanize"
-  end
+  require "oxidized/input/cli"
+  require "net/http"
+  require "json"
 
   class HTTP < Input
     include Input::CLI
 
-    def connect node
+    def connect(node)
       @node = node
-      @m    = Mechanize.new
-      @log  = File.open(Oxidized::Config::Log + "/#{@node.ip}-http", "w") if Oxidized.config.input.debug?
-
+      @secure = false
+      @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-http", "w") if Oxidized.config.input.debug?
       @node.model.cfg["http"].each { |cb| instance_exec(&cb) }
 
+      return true unless @main_page && defined?(login)
+
+      begin
+        require "mechanize"
+      rescue LoadError
+        raise OxidizedError, "mechanize not found: sudo gem install mechanize"
+      end
+
+      @m = Mechanize.new
       url = URI::HTTP.build host: @node.ip, path: @main_page
       @m_page = @m.get(url.to_s)
       login
     end
 
-    def cmd callback
+    def cmd(callback_or_string)
+      return cmd_cb callback_or_string if callback_or_string.is_a?(Proc)
+
+      cmd_str callback_or_string
+    end
+
+    def cmd_cb(callback)
       instance_exec(&callback)
     end
 
+    def cmd_str(string)
+      path = string % { password: @node.auth[:password] }
+      get_http path
+    end
+
     private
 
-    def log str
-      @log.write(str) if @log
+    def get_http(path)
+      schema = @secure ? "https://" : "http://"
+      uri = URI.join schema + @node.ip, path
+      http = Net::HTTP.new uri.host, uri.port
+      http.use_ssl = true if uri.scheme == "https"
+      http.get(uri).body
+    end
+
+    def log(str)
+      @log&.write(str)
     end
 
     def disconnect

data/lib/oxidized/input/input.rb

@@ -4,10 +4,10 @@ module Oxidized
     include Oxidized::Config::Vars
 
     RescueFail = {
-      :debug => [
-        Errno::ECONNREFUSED,
+      debug: [
+        Errno::ECONNREFUSED
       ],
-      :warn => [
+      warn:  [
         IOError,
         PromptUndetect,
         Timeout::Error,
@@ -15,8 +15,8 @@ module Oxidized
         Errno::EHOSTUNREACH,
         Errno::ENETUNREACH,
         Errno::EPIPE,
-        Errno::ETIMEDOUT,
-      ],
-    }
+        Errno::ETIMEDOUT
+      ]
+    }.freeze
   end
 end

data/lib/oxidized/input/ssh.rb

@@ -5,18 +5,18 @@ module Oxidized
   require 'oxidized/input/cli'
   class SSH < Input
     RescueFail = {
-      :debug => [
-        Net::SSH::Disconnect,
+      debug: [
+        Net::SSH::Disconnect
       ],
-      :warn => [
+      warn:  [
         RuntimeError,
-        Net::SSH::AuthenticationFailed,
-      ],
-    }
+        Net::SSH::AuthenticationFailed
+      ]
+    }.freeze
     include Input::CLI
     class NoShell < OxidizedError; end
 
-    def connect node
+    def connect(node)
       @node        = node
       @output      = ''
       @pty_options = { term: "vt100" }
@@ -37,10 +37,10 @@ module Oxidized
     end
 
     def connected?
-      @ssh and not @ssh.closed?
+      @ssh && (not @ssh.closed?)
     end
 
-    def cmd cmd, expect = node.prompt
+    def cmd(cmd, expect = node.prompt)
       Oxidized.logger.debug "lib/oxidized/input/ssh.rb #{cmd} @ #{node.name} with expect: #{expect.inspect}"
       if @exec
         @ssh.exec! cmd
@@ -49,15 +49,13 @@ module Oxidized
       end
     end
 
-    def send data
+    def send(data)
       @ses.send_data data
     end
 
-    def output
-      @output
-    end
+    attr_reader :output
 
-    def pty_options hash
+    def pty_options(hash)
       @pty_options = @pty_options.merge hash
     end
 
@@ -66,14 +64,14 @@ module Oxidized
     def disconnect
       disconnect_cli
       # if disconnect does not disconnect us, give up after timeout
-      Timeout::timeout(Oxidized.config.timeout) { @ssh.loop }
-    rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError
+      Timeout.timeout(Oxidized.config.timeout) { @ssh.loop }
+    rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError # rubocop:disable Lint/HandleExceptions
     ensure
       @log.close if Oxidized.config.input.debug?
       (@ssh.close rescue true) unless @ssh.closed?
     end
 
-    def shell_open ssh
+    def shell_open(ssh)
       @ses = ssh.open_channel do |ch|
         ch.on_data do |_ch, data|
           if Oxidized.config.input.debug?
@@ -83,7 +81,7 @@ module Oxidized
           @output << data
           @output = @node.model.expects @output
         end
-        ch.request_pty (@pty_options) do |_ch, success_pty|
+        ch.request_pty(@pty_options) do |_ch, success_pty|
           raise NoShell, "Can't get PTY" unless success_pty
 
           ch.send_channel_request 'shell' do |_ch, success_shell|
@@ -93,8 +91,10 @@ module Oxidized
       end
     end
 
-    def exec state = nil
-      state == nil ? @exec : (@exec = state) unless vars :ssh_no_exec
+    def exec(state = nil)
+      return nil if vars(:ssh_no_exec)
+
+      state.nil? ? @exec : (@exec = state)
     end
 
     def cmd_shell(cmd, expect_re)
@@ -105,10 +105,10 @@ module Oxidized
       @output
     end
 
-    def expect *regexps
+    def expect(*regexps)
       regexps = [regexps].flatten
       Oxidized.logger.debug "lib/oxidized/input/ssh.rb: expecting #{regexps.inspect} at #{node.name}"
-      Timeout::timeout(Oxidized.config.timeout) do
+      Timeout.timeout(Oxidized.config.timeout) do
         @ssh.loop(0.1) do
           sleep 0.1
           match = regexps.find { |regexp| @output.match regexp }
@@ -122,22 +122,22 @@ module Oxidized
     def make_ssh_opts
       secure = Oxidized.config.input.ssh.secure?
       ssh_opts = {
-        port:         (vars(:ssh_port) || 22).to_i,
-        paranoid:     secure,
-        keepalive:    vars(:ssh_no_keepalive) ? false : true,
-        password:     @node.auth[:password],
-        timeout:      Oxidized.config.timeout,
-        number_of_password_prompts: 0
+        number_of_password_prompts: 0,
+        keepalive:                  vars(:ssh_no_keepalive) ? false : true,
+        paranoid:                   secure,
+        password:                   @node.auth[:password],
+        timeout:                    Oxidized.config.timeout,
+        port:                       (vars(:ssh_port) || 22).to_i
       }
 
-      auth_methods = vars(:auth_methods) || %w(none publickey password)
+      auth_methods = vars(:auth_methods) || %w[none publickey password]
       ssh_opts[:auth_methods] = auth_methods
       Oxidized.logger.debug "AUTH METHODS::#{auth_methods}"
 
-      if proxy_host = vars(:ssh_proxy)
+      if (proxy_host = vars(:ssh_proxy))
         proxy_command =  "ssh "
         proxy_command += "-o StrictHostKeyChecking=no " unless secure
-        if proxy_port = vars(:ssh_proxy_port)
+        if (proxy_port = vars(:ssh_proxy_port))
           proxy_command += "-p #{proxy_port} "
         end
         proxy_command += "#{proxy_host} -W %h:%p"

data/lib/oxidized/input/telnet.rb

@@ -2,22 +2,24 @@ module Oxidized
   require 'net/telnet'
   require 'oxidized/input/cli'
   class Telnet < Input
-    RescueFail = {}
+    RescueFail = {}.freeze
     include Input::CLI
     attr_reader :telnet
 
-    def connect node
+    def connect(node)
       @node    = node
       @timeout = Oxidized.config.timeout
       @node.model.cfg['telnet'].each { |cb| instance_exec(&cb) }
       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-telnet", 'w') if Oxidized.config.input.debug?
       port = vars(:telnet_port) || 23
 
-      telnet_opts = { 'Host'    => @node.ip,
-                      'Port'    => port.to_i,
-                      'Timeout' => @timeout,
-                      'Model'   => @node.model,
-                      'Log'     => @log }
+      telnet_opts = {
+        'Host'    => @node.ip,
+        'Port'    => port.to_i,
+        'Timeout' => @timeout,
+        'Model'   => @node.model,
+        'Log'     => @log
+      }
 
       @telnet = Net::Telnet.new telnet_opts
       begin
@@ -29,10 +31,10 @@ module Oxidized
     end
 
     def connected?
-      @telnet and not @telnet.sock.closed?
+      @telnet && (not @telnet.sock.closed?)
     end
 
-    def cmd cmd_str, expect = @node.prompt
+    def cmd(cmd_str, expect = @node.prompt)
       return send(cmd_str + "\n") unless expect
 
       Oxidized.logger.debug "Telnet: #{cmd_str} @#{@node.name}"
@@ -42,7 +44,7 @@ module Oxidized
       @telnet.cmd args
     end
 
-    def send data
+    def send(data)
       @telnet.write data
     end
 
@@ -52,19 +54,17 @@ module Oxidized
 
     private
 
-    def expect re
-      @telnet.oxidized_expect expect: re, timeout: @timeout
+    def expect(regex)
+      @telnet.oxidized_expect expect: regex, timeout: @timeout
     end
 
     def disconnect
-      begin
-        disconnect_cli
-        @telnet.close
-      rescue Errno::ECONNRESET
-      ensure
-        @log.close if Oxidized.config.input.debug?
-        (@telnet.close rescue true) unless @telnet.sock.closed?
-      end
+      disconnect_cli
+      @telnet.close
+    rescue Errno::ECONNRESET # rubocop:disable Lint/HandleExceptions
+    ensure
+      @log.close if Oxidized.config.input.debug?
+      (@telnet.close rescue true) unless @telnet.sock.closed?
     end
   end
 end
@@ -73,14 +73,14 @@ class Net::Telnet
   ## how to do this, without redefining the whole damn thing
   ## FIXME: we also need output (not sure I'm going to support this)
   attr_reader :output
-  def oxidized_expect(options) # :yield: recvdata
+  def oxidized_expect(options)
     model    = @options["Model"]
     @log     = @options["Log"]
 
     expects  = [options[:expect]].flatten
     time_out = options[:timeout] || @options["Timeout"] || Oxidized.config.timeout?
 
-    Timeout::timeout(time_out) do
+    Timeout.timeout(time_out) do
       line = ""
       rest = ""
       buf  = ""
@@ -93,8 +93,8 @@ class Net::Telnet
            Integer(c.rindex(/#{IAC}#{SB}/no) || 0)
           buf = preprocess(c[0...c.rindex(/#{IAC}#{SB}/no)])
           rest = c[c.rindex(/#{IAC}#{SB}/no)..-1]
-        elsif pt = c.rindex(/#{IAC}[^#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]?\z/no) ||
-                   c.rindex(/\r\z/no)
+        elsif (pt = c.rindex(/#{IAC}[^#{IAC}#{AO}#{AYT}#{DM}#{IP}#{NOP}]?\z/no) ||
+                   c.rindex(/\r\z/no))
           buf = preprocess(c[0...pt])
           rest = c[pt..-1]
         else

data/lib/oxidized/input/tftp.rb

@@ -1,41 +1,40 @@
 module Oxidized
   require 'stringio'
   require_relative 'cli'
-  
+
   begin
     require 'net/tftp'
   rescue LoadError
     raise OxidizedError, 'net/tftp not found: sudo gem install net-tftp'
   end
-  
+
   class TFTP < Input
-    
     include Input::CLI
-    
+
     # TFTP utilizes UDP, there is not a connection. We simply specify an IP and send/receive data.
-    def connect node
-      @node       = node
+    def connect(node)
+      @node = node
 
       @node.model.cfg['tftp'].each { |cb| instance_exec(&cb) }
       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-tftp", 'w') if Oxidized.config.input.debug?
       @tftp = Net::TFTP.new @node.ip
     end
 
-    def cmd file
+    def cmd(file)
       Oxidized.logger.debug "TFTP: #{file} @ #{@node.name}"
       config = StringIO.new
       @tftp.getbinary file, config
       config.rewind
       config.read
     end
-    
+
     private
-    
+
     def disconnect
       # TFTP uses UDP, there is no connection to close
+      true
     ensure
       @log.close if Oxidized.config.input.debug?
     end
-
   end
 end

data/lib/oxidized/jobs.rb

@@ -4,11 +4,11 @@ module Oxidized
     MAX_INTER_JOB_GAP = 300 # add job if more than X from last job started
     attr_accessor :interval, :max, :want
 
-    def initialize max, interval, nodes
+    def initialize(max, interval, nodes)
       @max       = max
       # Set interval to 1 if interval is 0 (=disabled) so we don't break
       # the 'ceil' function
-      @interval  = interval == 0 ? 1 : interval
+      @interval  = interval.zero? ? 1 : interval
       @nodes     = nodes
       @last      = Time.now.utc
       @durations = Array.new @nodes.size, AVERAGE_DURATION
@@ -16,12 +16,12 @@ module Oxidized
       super()
     end
 
-    def push arg
+    def push(arg)
       @last = Time.now.utc
       super
     end
 
-    def duration last
+    def duration(last)
       if @durations.size > @nodes.size
         @durations.slice! @nodes.size...@durations.size
       elsif @durations.size < @nodes.size
@@ -44,9 +44,9 @@ module Oxidized
       # and  b) we want less threads running than the total amount of nodes
       # and  c) there is more than MAX_INTER_JOB_GAP since last one was started
       # then we want one more thread (rationale is to fix hanging thread causing HOLB)
-      if @want <= size and @want < @nodes.size
-        @want += 1 if (Time.now.utc - @last) > MAX_INTER_JOB_GAP
-      end
+      return unless @want <= size && @want < @nodes.size
+
+      @want += 1 if (Time.now.utc - @last) > MAX_INTER_JOB_GAP
     end
   end
 end