oxidized 0.20.0 → 0.28.0

data/lib/oxidized/input/ssh.rb

@@ -5,61 +5,42 @@ 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" }
       @node.model.cfg['ssh'].each { |cb| instance_exec(&cb) }
-      secure = Oxidized.config.input.ssh.secure
       @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-ssh", 'w') if Oxidized.config.input.debug?
-      port = vars(:ssh_port) || 22
-      if proxy_host = vars(:ssh_proxy)
-        proxy_command =  "ssh "
-        proxy_command += "-o StrictHostKeyChecking=no " unless secure
-        proxy_command += "#{proxy_host} -W %h:%p"
-        proxy =  Net::SSH::Proxy::Command.new(proxy_command)
-      end
-      ssh_opts = {
-        :port => port.to_i,
-        :password => @node.auth[:password], :timeout => Oxidized.config.timeout,
-        :paranoid => secure,
-        :auth_methods => %w(none publickey password keyboard-interactive),
-        :number_of_password_prompts => 0,
-        :proxy => proxy,
-      }
-      ssh_opts[:keys] = vars(:ssh_keys).is_a?(Array) ? vars(:ssh_keys) : [vars(:ssh_keys)] if vars(:ssh_keys)
-      ssh_opts[:kex]  = vars(:ssh_kex).split(/,\s*/) if vars(:ssh_kex)
-      ssh_opts[:encryption] = vars(:ssh_encryption).split(/,\s*/) if vars(:ssh_encryption)
 
       Oxidized.logger.debug "lib/oxidized/input/ssh.rb: Connecting to #{@node.name}"
-      @ssh = Net::SSH.start(@node.ip, @node.auth[:username], ssh_opts)
+      @ssh = Net::SSH.start(@node.ip, @node.auth[:username], make_ssh_opts)
       unless @exec
         shell_open @ssh
         begin
           login
         rescue Timeout::Error
-          raise PromptUndetect, [ @output, 'not matching configured prompt', @node.prompt ].join(' ')
+          raise PromptUndetect, [@output, 'not matching configured prompt', @node.prompt].join(' ')
         end
       end
       connected?
     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
@@ -68,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
 
@@ -85,25 +64,26 @@ module Oxidized
     def disconnect
       disconnect_cli
       # if disconnect does not disconnect us, give up after timeout
-      Timeout::timeout(Oxidized.config.timeout) { @ssh.loop }
+      Timeout.timeout(Oxidized.config.timeout) { @ssh.loop }
     rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError
     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?
             @log.print data
-            @log.fsync
+            @log.flush
           end
           @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|
             raise NoShell, "Can't get shell" unless success_shell
           end
@@ -111,22 +91,10 @@ module Oxidized
       end
     end
 
-    # some models have SSH auth or terminal auth based on version of code
-    # if SSH is configured for terminal auth, we'll still try to detect prompt
-    def login
-      if @username
-        match = expect username, @node.prompt
-        if match == username
-          cmd @node.auth[:username], password
-          cmd @node.auth[:password]
-        end
-      else
-        expect @node.prompt
-      end
-    end
+    def exec(state = nil)
+      return nil if vars(:ssh_no_exec)
 
-    def exec state=nil
-      state == nil ? @exec : (@exec=state) unless vars :ssh_no_exec
+      state.nil? ? @exec : (@exec = state)
     end
 
     def cmd_shell(cmd, expect_re)
@@ -137,18 +105,58 @@ 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 }
           return match if match
+
           true
         end
       end
     end
 
+    def make_ssh_opts
+      secure = Oxidized.config.input.ssh.secure?
+      ssh_opts = {
+        number_of_password_prompts: 0,
+        keepalive:                  vars(:ssh_no_keepalive) ? false : true,
+        verify_host_key:            secure ? :always : :never,
+        password:                   @node.auth[:password],
+        timeout:                    Oxidized.config.timeout,
+        port:                       (vars(:ssh_port) || 22).to_i
+      }
+
+      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))
+        proxy_command =  "ssh "
+        proxy_command += "-o StrictHostKeyChecking=no " unless secure
+        if (proxy_port = vars(:ssh_proxy_port))
+          proxy_command += "-p #{proxy_port} "
+        end
+        proxy_command += "#{proxy_host} -W %h:%p"
+        proxy = Net::SSH::Proxy::Command.new(proxy_command)
+        ssh_opts[:proxy] = proxy
+      end
+
+      ssh_opts[:keys]       = [vars(:ssh_keys)].flatten if vars(:ssh_keys)
+      ssh_opts[:kex]        = vars(:ssh_kex).split(/,\s*/) if vars(:ssh_kex)
+      ssh_opts[:encryption] = vars(:ssh_encryption).split(/,\s*/) if vars(:ssh_encryption)
+      ssh_opts[:host_key]   = vars(:ssh_host_key).split(/,\s*/) if vars(:ssh_host_key)
+      ssh_opts[:hmac]       = vars(:ssh_hmac).split(/,\s*/) if vars(:ssh_hmac)
+
+      if Oxidized.config.input.debug?
+        ssh_opts[:logger]  = Oxidized.logger
+        ssh_opts[:verbose] = Logger::DEBUG
+      end
+
+      ssh_opts
+    end
   end
 end

data/lib/oxidized/input/telnet.rb

@@ -2,48 +2,49 @@ 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
 
-      opt = { 'Host'    => @node.ip,
-              'Port'    => port.to_i,
-              'Timeout' => @timeout,
-              'Model'   => @node.model }
-      opt['Output_log'] = Oxidized::Config::Log + "/#{@node.ip}-telnet" if Oxidized.config.input.debug?
+      telnet_opts = {
+        'Host'    => @node.ip,
+        'Port'    => port.to_i,
+        'Timeout' => @timeout,
+        'Model'   => @node.model,
+        'Log'     => @log
+      }
 
-      @telnet  = Net::Telnet.new opt
-      if @node.auth[:username] and @node.auth[:username].length > 0
-        expect username
-        @telnet.puts @node.auth[:username]
-      end
-      expect password
-      @telnet.puts @node.auth[:password]
+      @telnet = Net::Telnet.new telnet_opts
       begin
-        expect @node.prompt
+        login
       rescue Timeout::Error
-        raise PromptUndetect, [ 'unable to detect prompt:', @node.prompt ].join(' ')
+        raise PromptUndetect, ['unable to detect prompt:', @node.prompt].join(' ')
       end
+      connected?
     end
 
     def connected?
-      @telnet and not @telnet.sock.closed?
+      @telnet && (not @telnet.sock.closed?)
     end
 
-    def cmd cmd, expect=@node.prompt
-      Oxidized.logger.debug "Telnet: #{cmd} @#{@node.name}"
-      args = { 'String' => cmd }
-      args.merge!({ 'Match' => expect, 'Timeout' => @timeout }) if expect
+    def cmd(cmd_str, expect = @node.prompt)
+      return send(cmd_str + "\r\n") unless expect
+
+      Oxidized.logger.debug "Telnet: #{cmd_str} @#{@node.name}"
+      args = { 'String'  => cmd_str,
+               'Match'   => expect,
+               'Timeout' => @timeout }
       @telnet.cmd args
     end
 
-    def send data
+    def send(data)
       @telnet.write data
     end
 
@@ -53,106 +54,62 @@ module Oxidized
 
     private
 
-    def expect re
-      @telnet.waitfor 'Match' => re, 'Timeout' => @timeout
+    def expect(regex)
+      @telnet.oxidized_expect expect: regex, timeout: @timeout
     end
 
     def disconnect
-      begin
-        disconnect_cli
-        @telnet.close
-      rescue Errno::ECONNRESET
-      end
+      disconnect_cli
+      @telnet.close
+    rescue Errno::ECONNRESET
+    ensure
+      @log.close if Oxidized.config.input.debug?
+      (@telnet.close rescue true) unless @telnet.sock.closed?
     end
-
   end
 end
 
-
 class Net::Telnet
-  ## FIXME: we just need 'line = model.expects line' to handle pager
   ## 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 waitfor(options) # :yield: recvdata
-    time_out = @options["Timeout"]
-    waittime = @options["Waittime"]
-    fail_eof = @options["FailEOF"]
+  def oxidized_expect(options)
     model    = @options["Model"]
+    @log     = @options["Log"]
 
-    if options.kind_of?(Hash)
-      prompt   = if options.has_key?("Match")
-                   options["Match"]
-                 elsif options.has_key?("Prompt")
-                   options["Prompt"]
-                 elsif options.has_key?("String")
-                   Regexp.new( Regexp.quote(options["String"]) )
-                 end
-      time_out = options["Timeout"]  if options.has_key?("Timeout")
-      waittime = options["Waittime"] if options.has_key?("Waittime")
-      fail_eof = options["FailEOF"]  if options.has_key?("FailEOF")
-    else
-      prompt = options
-    end
+    expects  = [options[:expect]].flatten
+    time_out = options[:timeout] || @options["Timeout"] || Oxidized.config.timeout?
 
-    if time_out == false
-      time_out = nil
-    end
-
-    line = ''
-    buf = ''
-    rest = ''
-    until(prompt === line and not IO::select([@sock], nil, nil, waittime))
-      unless IO::select([@sock], nil, nil, time_out)
-        raise TimeoutError, "timed out while waiting for more data"
-      end
-      begin
+    Timeout.timeout(time_out) do
+      line = ""
+      rest = ""
+      buf  = ""
+      loop do
         c = @sock.readpartial(1024 * 1024)
         @output = c
-        @dumplog.log_dump('<', c) if @options.has_key?("Dump_log")
-        if @options["Telnetmode"]
-          c = rest + c
-          if Integer(c.rindex(/#{IAC}#{SE}/no) || 0) <
-             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)
-            buf = preprocess(c[0 ... pt])
-            rest = c[pt .. -1]
-          else
-            buf = preprocess(c)
-            rest = ''
-          end
-       else
-         # Not Telnetmode.
-         #
-         # We cannot use preprocess() on this data, because that
-         # method makes some Telnetmode-specific assumptions.
-         buf = rest + c
-         rest = ''
-         unless @options["Binmode"]
-           if pt = buf.rindex(/\r\z/no)
-             buf = buf[0 ... pt]
-             rest = buf[pt .. -1]
-           end
-           buf.gsub!(/#{EOL}/no, "\n")
-         end
+        c = rest + c
+
+        if Integer(c.rindex(/#{IAC}#{SE}/no) || 0) <
+           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))
+          buf = preprocess(c[0...pt])
+          rest = c[pt..-1]
+        else
+          buf = preprocess(c)
+          rest = ''
+        end
+        if Oxidized.config.input.debug?
+          @log.print buf
+          @log.flush
         end
-        @log.print(buf) if @options.has_key?("Output_log")
         line += buf
         line = model.expects line
-        line = yield line if block_given?
-        yield buf if block_given?
-      rescue EOFError # End of file reached
-        raise if fail_eof
-        if line == ''
-          line = nil
-          yield nil if block_given?
-        end
-        break
+        match = expects.find { |re| line.match re }
+        return match if match
       end
     end
-    line
   end
 end

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 
+      # 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,19 +16,19 @@ 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
         @durations.fill AVERAGE_DURATION, @durations.size...@nodes.size
       end
       @durations.push(last).shift
-      @duration = @durations.inject(:+).to_f / @nodes.size #rolling average
+      @duration = @durations.inject(:+).to_f / @nodes.size # rolling average
       new_count
     end
 
@@ -44,10 +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
-    end
+      return unless @want <= size && @want < @nodes.size
 
+      @want += 1 if (Time.now.utc - @last) > MAX_INTER_JOB_GAP
+    end
   end
 end

data/lib/oxidized/manager.rb

@@ -5,62 +5,60 @@ module Oxidized
   require 'oxidized/source/source'
   class Manager
     class << self
-      def load dir, file
-        begin
-          require File.join dir, file+'.rb'
-          klass = nil
-          [Oxidized, Object].each do |mod|
-            klass = mod.constants.find { |const| const.to_s.downcase == file.downcase }
-            klass = mod.constants.find { |const| const.to_s.downcase == 'oxidized'+ file.downcase } unless klass
-            klass = mod.const_get klass if klass
-            break if klass
-          end
-          i = klass.new
-          i.setup if i.respond_to? :setup
-          { file => klass }
-        rescue LoadError
-          {}
+      def load(dir, file)
+        require File.join dir, file + '.rb'
+        klass = nil
+        [Oxidized, Object].each do |mod|
+          klass   = mod.constants.find { |const| const.to_s.casecmp(file).zero? }
+          klass ||= mod.constants.find { |const| const.to_s.downcase == 'oxidized' + file.downcase }
+          klass   = mod.const_get klass if klass
+          break if klass
         end
+        i = klass.new
+        i.setup if i.respond_to? :setup
+        { file => klass }
+      rescue LoadError
+        false
       end
     end
-    attr_reader :input, :output, :model, :source, :hook
+
+    attr_reader :input, :output, :source, :model, :hook
     def initialize
       @input  = {}
       @output = {}
-      @model  = {}
       @source = {}
-      @hook = {}
+      @model  = {}
+      @hook   = {}
+    end
+
+    def add_input(name)
+      loader @input, Config::InputDir, "input", name
     end
-    def add_input method
-      method = Manager.load Config::InputDir, method
-      return false if method.empty?
-      @input.merge! method
+
+    def add_output(name)
+      loader @output, Config::OutputDir, "output", name
     end
-    def add_output method
-      method = Manager.load Config::OutputDir, method
-      return false if method.empty?
-      @output.merge! method
+
+    def add_source(name)
+      loader @source, Config::SourceDir, "source", name
     end
-    def add_model _model
-      name = _model
-      _model = Manager.load File.join(Config::Root, 'model'), name
-      _model = Manager.load Config::ModelDir, name if _model.empty?
-      return false if _model.empty?
-      @model.merge! _model
+
+    def add_model(name)
+      loader @model, Config::ModelDir, "model", name
     end
-    def add_source _source
-      return nil if @source.key? _source
-      _source = Manager.load Config::SourceDir, _source
-      return false if _source.empty?
-      @source.merge! _source
+
+    def add_hook(name)
+      loader @hook, Config::HookDir, "hook", name
     end
-    def add_hook _hook
-      return nil if @hook.key? _hook
-      name = _hook
-      _hook = Manager.load File.join(Config::Root, 'hook'), name
-      _hook = Manager.load Config::HookDir, name if _hook.empty?
-      return false if _hook.empty?
-      @hook.merge! _hook
+
+    private
+
+    # if local version of file exists, load it, else load global - return falsy value if nothing loaded
+    def loader(hash, global_dir, local_dir, name)
+      dir   = File.join(Config::Root, local_dir)
+      map   = Manager.load(dir, name) if File.exist? File.join(dir, name + ".rb")
+      map ||= Manager.load(global_dir, name)
+      hash.merge!(map) if map
     end
   end
 end