oxidized 0.20.0 → 0.28.0

data/lib/oxidized/hook/slackdiff.rb

@@ -1,5 +1,8 @@
 require 'slack'
 
+# defaults to posting a diff, if messageformat is supplied them a message will be posted too
+# diff defaults to true
+
 class SlackDiff < Oxidized::Hook
   def validate_cfg!
     raise KeyError, 'hook.token is required' unless cfg.has_key?('token')
@@ -7,28 +10,38 @@ class SlackDiff < Oxidized::Hook
   end
 
   def run_hook(ctx)
-    if ctx.node
-      if ctx.event.to_s == "post_store"
-        log "Connecting to slack"
-        Slack.configure do |config|
-           config.token = cfg.token
-           config.proxy = cfg.proxy if cfg.has_key?('proxy')
-        end
-        client = Slack::Client.new
-        client.auth_test
-        log "Connected"
-        gitoutput = ctx.node.output.new
-        diff = gitoutput.get_diff ctx.node, ctx.node.group, ctx.commitref, nil
-        title = "#{ctx.node.name.to_s} #{ctx.node.group.to_s} #{ctx.node.model.class.name.to_s.downcase}"
+    return unless ctx.node
+    return unless ctx.event.to_s == "post_store"
+
+    log "Connecting to slack"
+    Slack.configure do |config|
+      config.token = cfg.token
+      config.proxy = cfg.proxy if cfg.has_key?('proxy')
+    end
+    client = Slack::Client.new
+    client.auth_test
+    log "Connected"
+    if cfg.has_key?("diff") ? cfg.diff : true
+      gitoutput = ctx.node.output.new
+      diff = gitoutput.get_diff ctx.node, ctx.node.group, ctx.commitref, nil
+      unless diff == "no diffs"
+        title = "#{ctx.node.name} #{ctx.node.group} #{ctx.node.model.class.name.to_s.downcase}"
         log "Posting diff as snippet to #{cfg.channel}"
         client.files_upload(channels: cfg.channel, as_user: true,
-                             content: diff[:patch].lines.to_a[4..-1].join,
-                             filetype: "diff",
-                             title: title,
-                             filename: "change"
-                            )
-        log "Finished"
+                            content: diff[:patch].lines.to_a[4..-1].join,
+                            filetype: "diff",
+                            title: title,
+                            filename: "change")
       end
     end
+    # message custom formatted - optional
+    if cfg.message?
+      log cfg.message
+      msg = cfg.message % { node: ctx.node.name.to_s, group: ctx.node.group.to_s, commitref: ctx.commitref, model: ctx.node.model.class.name.to_s.downcase }
+      log msg
+      log "Posting message to #{cfg.channel}"
+      client.chat_postMessage(channel: cfg.channel, text: msg, as_user: true)
+    end
+    log "Finished"
   end
 end

data/lib/oxidized/hook/xmppdiff.rb

@@ -0,0 +1,59 @@
+require 'xmpp4r'
+require 'xmpp4r/muc/helper/simplemucclient'
+
+class XMPPDiff < Oxidized::Hook
+  def validate_cfg!
+    raise KeyError, 'hook.jid is required' unless cfg.has_key?('jid')
+    raise KeyError, 'hook.password is required' unless cfg.has_key?('password')
+    raise KeyError, 'hook.channel is required' unless cfg.has_key?('channel')
+    raise KeyError, 'hook.nick is required' unless cfg.has_key?('nick')
+  end
+
+  def run_hook(ctx)
+    return unless ctx.node
+    return unless ctx.event.to_s == "post_store"
+
+    begin
+      Timeout.timeout(15) do
+        gitoutput = ctx.node.output.new
+        diff = gitoutput.get_diff ctx.node, ctx.node.group, ctx.commitref, nil
+
+        interesting = diff[:patch].lines.to_a[4..-1].any? do |line|
+          ["+", "-"].include?(line[0]) && (not ["#", "!"].include?(line[1]))
+        end
+        interesting &&= diff[:patch].lines.to_a[5..-1].any? { |line| line[0] == '-' }
+        interesting &&= diff[:patch].lines.to_a[5..-1].any? { |line| line[0] == '+' }
+
+        if interesting
+          log "Connecting to XMPP"
+          client = Jabber::Client.new(Jabber::JID.new(cfg.jid))
+          client.connect
+          sleep 1
+          client.auth(cfg.password)
+          sleep 1
+
+          log "Connected"
+
+          m = Jabber::MUC::SimpleMUCClient.new(client)
+          m.join(cfg.channel + "/" + cfg.nick)
+
+          log "Joined"
+
+          title = "#{ctx.node.name} #{ctx.node.group} #{ctx.node.model.class.name.to_s.downcase}"
+          log "Posting diff as snippet to #{cfg.channel}"
+
+          m.say(title + "\n\n" + diff[:patch].lines.to_a[4..-1].join)
+
+          sleep 1
+
+          client.close
+
+          log "Finished"
+
+        end
+      end
+    rescue Timeout::Error
+      log "timed out"
+    end
+  end
+end

data/lib/oxidized/hook.rb

@@ -1,88 +1,87 @@
 module Oxidized
-class HookManager
-  class << self
-    def from_config cfg
-      mgr = new
-      cfg.hooks.each do |name,h_cfg|
-        h_cfg.events.each do |event|
-          mgr.register event.to_sym, name, h_cfg.type, h_cfg
+  class HookManager
+    class << self
+      def from_config(cfg)
+        mgr = new
+        cfg.hooks.each do |name, h_cfg|
+          h_cfg.events.each do |event|
+            mgr.register event.to_sym, name, h_cfg.type, h_cfg
+          end
         end
+        mgr
       end
-      mgr
     end
-  end
-
-  # HookContext is passed to each hook. It can contain anything related to the
-  # event in question. At least it contains the event name
-  class HookContext < OpenStruct; end
 
-  # RegisteredHook is a container for a Hook instance
-  class RegisteredHook < Struct.new(:name, :hook); end
+    # HookContext is passed to each hook. It can contain anything related to the
+    # event in question. At least it contains the event name
+    class HookContext < OpenStruct; end
 
-  Events = [
-    :node_success,
-    :node_fail,
-    :post_store,
-  ]
-  attr_reader :registered_hooks
+    # RegisteredHook is a container for a Hook instance
+    RegisteredHook = Struct.new(:name, :hook)
 
-  def initialize
-    @registered_hooks = Hash.new {|h,k| h[k] = []}
-  end
+    Events = %i[
+      node_success
+      node_fail
+      post_store
+      nodes_done
+    ].freeze
+    attr_reader :registered_hooks
 
-  def register event, name, hook_type, cfg
-    unless Events.include? event
-      raise ArgumentError,
-        "unknown event #{event}, available: #{Events.join ','}"
+    def initialize
+      @registered_hooks = Hash.new { |h, k| h[k] = [] }
     end
 
-    Oxidized.mgr.add_hook hook_type
-    begin
-      hook = Oxidized.mgr.hook.fetch(hook_type).new
-    rescue KeyError
-      raise KeyError, "cannot find hook #{hook_type.inspect}"
-    end
+    def register(event, name, hook_type, cfg)
+      unless Events.include? event
+        raise ArgumentError,
+              "unknown event #{event}, available: #{Events.join ','}"
+      end
 
-    hook.cfg = cfg
+      Oxidized.mgr.add_hook(hook_type) || raise("cannot load hook '#{hook_type}', not found")
+      begin
+        hook = Oxidized.mgr.hook.fetch(hook_type).new
+      rescue KeyError
+        raise KeyError, "cannot find hook #{hook_type.inspect}"
+      end
 
-    @registered_hooks[event] << RegisteredHook.new(name, hook)
-    Oxidized.logger.debug "Hook #{name.inspect} registered #{hook.class} for event #{event.inspect}"
-  end
+      hook.cfg = cfg
 
-  def handle event, ctx_params={}
-    ctx = HookContext.new ctx_params
-    ctx.event = event
+      @registered_hooks[event] << RegisteredHook.new(name, hook)
+      Oxidized.logger.debug "Hook #{name.inspect} registered #{hook.class} for event #{event.inspect}"
+    end
 
-    @registered_hooks[event].each do |r_hook|
-      begin
-        r_hook.hook.run_hook ctx
-      rescue => e
-        Oxidized.logger.error "Hook #{r_hook.name} (#{r_hook.hook}) failed " +
-                  "(#{e.inspect}) for event #{event.inspect}"
+    def handle(event, ctx_params = {})
+      ctx = HookContext.new ctx_params
+      ctx.event = event
+
+      @registered_hooks[event].each do |r_hook|
+        begin
+          r_hook.hook.run_hook ctx
+        rescue StandardError => e
+          Oxidized.logger.error "Hook #{r_hook.name} (#{r_hook.hook}) failed " \
+                                "(#{e.inspect}) for event #{event.inspect}"
+        end
       end
     end
   end
-end
 
-# Hook abstract base class
-class Hook
-  attr_reader :cfg
+  # Hook abstract base class
+  class Hook
+    attr_reader :cfg
 
-  def initialize
-  end
+    def initialize; end
 
-  def cfg=(cfg)
-    @cfg = cfg
-    validate_cfg! if self.respond_to? :validate_cfg!
-  end
+    def cfg=(cfg)
+      @cfg = cfg
+      validate_cfg! if respond_to? :validate_cfg!
+    end
 
-  def run_hook ctx
-    raise NotImplementedError
-  end
+    def run_hook(_ctx)
+      raise NotImplementedError
+    end
 
-  def log(msg, level=:info)
-    Oxidized.logger.send(level, "#{self.class.name}: #{msg}")
+    def log(msg, level = :info)
+      Oxidized.logger.send(level, "#{self.class.name}: #{msg}")
+    end
   end
-
-end
 end

data/lib/oxidized/input/cli.rb

@@ -32,26 +32,36 @@ module Oxidized
         @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
+      def post_login(cmd = nil, &block)
+        return if @exec
+
+        @post_login << [cmd, block]
       end
 
-      def pre_logout _pre_logout=nil, &block
-        unless @exec
-          @pre_logout <<  [_pre_logout, block]
-        end
+      def pre_logout(cmd = nil, &block)
+        return if @exec
+
+        @pre_logout << [cmd, block]
       end
 
-      def username re=/^(Username|login)/
-        @username or @username = re
+      def username(regex = /^(Username|login)/)
+        @username || (@username = regex)
       end
 
-      def password re=/^Password/
-        @password or @password = re
+      def password(regex = /^Password/)
+        @password || (@password = regex)
       end
 
+      def login
+        match_re = [@node.prompt]
+        match_re << @username if @username
+        match_re << @password if @password
+        until (match = expect(match_re)) == @node.prompt
+          cmd(@node.auth[:username], nil) if match == @username
+          cmd(@node.auth[:password], nil) if match == @password
+          match_re.delete match
+        end
+      end
     end
   end
 end

data/lib/oxidized/input/exec.rb

@@ -0,0 +1,28 @@
+module Oxidized
+  require "oxidized/input/cli"
+
+  class Exec < Input
+    include Input::CLI
+
+    def connect(node)
+      @node = node
+      @node.model.cfg["exec"].each { |cb| instance_exec(&cb) }
+      @log = File.open(Oxidized::Config::Log + "/#{@node.ip}-exec", "w") if Oxidized.config.input.debug?
+    end
+
+    def cmd(cmd_str)
+      Oxidized.logger.debug "EXEC: #{cmd_str} @ #{@node.name}"
+      # I'd really like to do popen3 with separate arguments, but that would
+      # require refactoring cmd to take parameters
+      %x(#{cmd_str})
+    end
+
+    private
+
+    def disconnect
+      true
+    ensure
+      @log.close if Oxidized.config.input.debug?
+    end
+  end
+end

data/lib/oxidized/input/ftp.rb

@@ -5,35 +5,37 @@ module Oxidized
 
   class FTP < Input
     RescueFail = {
-      :debug => [
-        #Net::SSH::Disconnect,
+      debug: [
+        # Net::SSH::Disconnect,
       ],
-      :warn => [
-        #RuntimeError,
-        #Net::SSH::AuthenticationFailed,
-      ],
-    }
+      warn:  [
+        # RuntimeError,
+        # Net::SSH::AuthenticationFailed,
+      ]
+    }.freeze
     include Input::CLI
 
-    def connect node
-      @node       = 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?
-      @ftp = Net::FTP.new @node.ip, @node.auth[:username], @node.auth[:password]
+      @ftp = Net::FTP.new(@node.ip)
+      @ftp.passive = Oxidized.config.input.ftp.passive
+      @ftp.login @node.auth[:username], @node.auth[:password]
       connected?
     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
 
@@ -45,10 +47,9 @@ module Oxidized
 
     def disconnect
       @ftp.close
-    #rescue Errno::ECONNRESET, IOError
+    # rescue Errno::ECONNRESET, IOError
     ensure
       @log.close if Oxidized.config.input.debug?
     end
-
   end
 end

data/lib/oxidized/input/http.rb

@@ -0,0 +1,72 @@
+module Oxidized
+  require "oxidized/input/cli"
+  require "net/http"
+  require "json"
+
+  class HTTP < Input
+    include Input::CLI
+
+    def connect(node)
+      @node = node
+      @secure = false
+      @username = nil
+      @password = nil
+      @headers = {}
+      @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_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 get_http(path)
+      schema = @secure ? "https://" : "http://"
+      uri = URI("#{schema}#{@node.ip}#{path}")
+      req = Net::HTTP::Get.new(uri)
+      req.basic_auth @username, @password unless @username.nil?
+      @headers.each do |header, value|
+        req.add_field(header, value)
+      end
+      ssl_verify = Oxidized.config.input.http.ssl_verify? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", verify_mode: ssl_verify) do |http|
+        http.request(req)
+      end
+      res.body
+    end
+
+    def log(str)
+      @log&.write(str)
+    end
+
+    def disconnect
+      @log.close if Oxidized.config.input.debug?
+    end
+  end
+end

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