oxidized 0.1.1

data/lib/oxidized/config/vars.rb

@@ -0,0 +1,10 @@
+module Oxidized::Config::Vars
+  # convenience method for accessing node, group or global level user variables
+  # nil values will be ignored
+  def vars name
+    r =   @node.vars[name] unless @node.vars.nil?
+    r ||= Oxidized::CFG.groups[@node.group].vars[name.to_s] if Oxidized::CFG.groups.has_key?(@node.group)
+    r ||= Oxidized::CFG.vars[name.to_s] if Oxidized::CFG.vars.has_key?(name)
+    r
+  end
+end

data/lib/oxidized/core.rb

@@ -0,0 +1,41 @@
+module Oxidized
+  require 'oxidized/log'
+  require 'oxidized/string'
+  require 'oxidized/config'
+  require 'oxidized/config/vars'
+  require 'oxidized/worker'
+  require 'oxidized/nodes'
+  require 'oxidized/manager'
+  class << self
+    def new *args
+      Core.new args
+    end
+  end
+
+  class Core
+    def initialize args
+      Oxidized.mgr = Manager.new
+      nodes        = Nodes.new
+      @worker      = Worker.new nodes
+      if CFG.rest?
+        begin
+          require 'oxidized/web'
+        rescue LoadError
+          raise OxidizedError, 'oxidized-web not found: sudo gem install oxidized-web - or disable web support by setting "rest: false" in your configuration'
+        end
+        @rest        = API::Web.new nodes, CFG.rest
+        @rest.run
+      end
+      run
+    end
+
+    private
+
+    def run
+      while true
+        @worker.work
+        sleep Config::Sleep
+      end
+    end
+  end
+end

data/lib/oxidized/input/cli.rb

@@ -0,0 +1,48 @@
+module Oxidized
+  class Input
+    module CLI
+
+      def initialize
+        @post_login = []
+        @pre_logout = []
+        @username, @password, @exec = nil
+      end
+
+      def get
+        connect_cli
+        d = @node.model.get
+        disconnect
+        d
+      end
+
+      def connect_cli
+        @post_login.each { |command, block| block ? block.call : (cmd command) }
+      end
+
+      def disconnect_cli
+        @pre_logout.each { |command, block| block ? block.call : (cmd command, nil) }
+      end
+
+      def post_login _post_login=nil, &block
+        unless @exec
+          @post_login << [_post_login, block]
+        end
+      end
+
+      def pre_logout _pre_logout=nil, &block
+        unless @exec
+          @pre_logout <<  [_pre_logout, block]
+        end
+      end
+
+      def username re=/^(Username|login)/
+        @username or @username = re
+      end
+
+      def password re=/^Password/
+        @password or @password = re
+      end
+
+    end
+  end
+end

data/lib/oxidized/input/input.rb

@@ -0,0 +1,19 @@
+module Oxidized
+  class Input
+    include Oxidized::Config::Vars
+
+    RescueFail = {
+      :debug => [
+        Errno::ECONNREFUSED,
+      ],
+      :warn => [
+        IOError,
+        Timeout::Error,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH,
+        Errno::EPIPE,
+      ],
+    }
+  end
+end

data/lib/oxidized/input/ssh.rb

@@ -0,0 +1,111 @@
+module Oxidized
+  require 'net/ssh'
+  require 'timeout'
+  require 'oxidized/input/cli'
+  class SSH < Input
+    RescueFail = {
+      :debug => [
+        Net::SSH::Disconnect,
+      ],
+      :warn => [
+        RuntimeError,
+        Net::SSH::AuthenticationFailed,
+      ],
+    }
+    include Input::CLI
+    class NoShell < OxidizedError; end
+
+    def connect node
+      @node       = node
+      @output     = ''
+      @node.model.cfg['ssh'].each { |cb| instance_exec(&cb) }
+      secure = CFG.input.ssh.secure
+      @ssh = Net::SSH.start @node.ip, @node.auth[:username],
+                            :password => @node.auth[:password], :timeout => CFG.timeout,
+                            :paranoid => secure
+      unless @exec
+        shell_open @ssh
+        @username ? shell_login : expect(@node.prompt)
+      end
+      connected?
+    end
+
+    def connected?
+      @ssh and not @ssh.closed?
+    end
+
+    def cmd cmd, expect=@node.prompt
+      Log.debug "SSH: #{cmd} @ #{@node.name}"
+      if @exec
+        @ssh.exec! cmd
+      else
+        cmd_shell(cmd, expect).gsub(/\r\n/, "\n")
+      end
+    end
+
+    def send data
+      @ses.send_data data
+    end
+
+    def output
+      @output
+    end
+
+    private
+
+    def disconnect
+      disconnect_cli
+      # if disconnect does not disconnect us, give up after timeout
+      Timeout::timeout(CFG.timeout) { @ssh.loop }
+    rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError
+    ensure
+      @ssh.close if not @ssh.closed?
+    end
+
+    def shell_open ssh
+      @ses = ssh.open_channel do |ch|
+        ch.on_data do |_ch, data|
+          @output << data
+          @output = @node.model.expects @output
+        end
+        ch.request_pty 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
+        end
+      end
+    end
+
+    # Cisco WCS has extremely dubious SSH implementation, SSH auth is always
+    # success, it always opens shell and then run auth in shell. I guess
+    # they'll never support exec() :)
+    def shell_login
+      expect username
+      cmd @node.auth[:username], password
+      cmd @node.auth[:password]
+    end
+
+    def exec state=nil
+      state == nil ? @exec : (@exec=state)
+    end
+
+    def cmd_shell(cmd, expect_re)
+      @output = ''
+      @ses.send_data cmd + "\n"
+      @ses.process
+      expect expect_re if expect_re
+      @output
+    end
+
+    def expect regexp
+      Timeout::timeout(CFG.timeout) do
+        @ssh.loop(0.1) do
+          sleep 0.1
+          not @output.match regexp
+        end
+      end
+    end
+
+  end
+end

data/lib/oxidized/input/telnet.rb

@@ -0,0 +1,145 @@
+module Oxidized
+  require 'net/telnet'
+  require 'oxidized/input/cli'
+  class Telnet < Input
+    RescueFail = {}
+    include Input::CLI
+    attr_reader :telnet
+
+    def connect node
+      @node    = node
+      @timeout = CFG.timeout
+      @node.model.cfg['telnet'].each { |cb| instance_exec(&cb) }
+      @telnet  = Net::Telnet.new 'Host' => @node.ip, 'Timeout' => @timeout,
+                                 'Model' => @node.model
+      expect username
+      @telnet.puts @node.auth[:username]
+      expect password
+      @telnet.puts @node.auth[:password]
+      expect @node.prompt
+    end
+
+    def connected?
+      @telnet and not @telnet.sock.closed?
+    end
+
+    def cmd cmd, expect=@node.prompt
+      Log.debug "Telnet: #{cmd} @#{@node.name}"
+      args = { 'String' => cmd }
+      args.merge!({ 'Match' => expect, 'Timeout' => @timeout }) if expect
+      @telnet.cmd args
+    end
+
+    def send data
+      @telnet.write data
+    end
+
+    def output
+      @telnet.output
+    end
+
+    private
+
+    def expect re
+      @telnet.waitfor 'Match' => re, 'Timeout' => @timeout
+    end
+
+    def disconnect
+      begin
+        disconnect_cli
+        @telnet.close
+      rescue Errno::ECONNRESET
+      end
+    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"]
+    model    = @options["Model"]
+
+    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
+
+    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
+        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
+        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
+      end
+    end
+    line
+  end
+end

data/lib/oxidized/job.rb

@@ -0,0 +1,14 @@
+module Oxidized
+  class Job < Thread
+    attr_reader :start, :end, :status, :time, :node, :config
+    def initialize node
+      @node         = node
+      @start        = Time.now.utc
+      super do |node|
+        @status, @config = node.run
+        @end             = Time.now.utc
+        @time            = @end - @start
+      end
+    end
+  end
+end

data/lib/oxidized/jobs.rb

@@ -0,0 +1,24 @@
+module Oxidized
+  class Jobs < Array
+    attr_accessor :interval, :duration, :max, :want
+    def initialize max, interval, nodes
+      @max       = max
+      #@interval  = interval * 60
+      @interval  = interval
+      @nodes     = nodes
+      @duration  = 4
+      new_count
+      super()
+    end
+    def duration last
+      @duration = (@duration + last) / 2
+      new_count
+    end
+    def new_count
+      @want = ((@nodes.size * @duration) / @interval).to_i
+      @want = 1 if @want < 1
+      @want = @nodes.size if @want > @nodes.size
+      @want = @max if @want > @max
+    end
+  end
+end

data/lib/oxidized/log.rb

@@ -0,0 +1,21 @@
+module Oxidized
+
+  begin
+    require 'syslog/logger'
+    Log = Syslog::Logger.new 'oxidized'
+    Log.define_singleton_method(:file=){|arg|}
+  rescue LoadError
+    # 1.9.3 has no love for syslog
+    require 'logger'
+    class Logger < Logger
+     def initialize target=STDOUT
+       super target
+     end
+     def file= target
+       @logdev = LogDevice.new target
+     end
+    end
+    Log = Logger.new
+  end
+
+end