zabbirc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa6b2a62b76aecb1541a8608444b54aa0435258a
+  data.tar.gz: cd3e76f12c22caed15cf276cf4518dac82160946
+SHA512:
+  metadata.gz: ec786a1141cff5e769b91cefe1ca45b9e2fa97b7f4a15ad70f5fa13c614acfb63c4674f606f365d473e2f92938589fc154703ea2cad767b661f8869196141be9
+  data.tar.gz: 3a0b23a5017ceb2f8aabdcc73af0a300bb2795595a2f813a77d1ff054a35d0ed469b7b44869c9a2dfd5071777eca7269b20af4d07651cb9bc907098fb5748a4a

data/bin/zabbirc

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require 'zabbirc'
+require 'pry'
+this_file = __FILE__
+config_path = File.expand_path(ARGV[0])
+
+unless config_path
+  $stderr.puts "No config path specified"
+  exit false
+end
+unless File.exists?(config_path)
+  $stderr.puts "Could not find config file: #{config_path}"
+  exit false
+end
+
+require_relative config_path
+
+Zabbirc.logger # initializes logger
+exit false unless Zabbirc::Zabbix::Connection.test_connection
+
+s = Zabbirc::Service.new
+
+trap "SIGINT" do
+  s.stop
+end
+
+trap "SIGTERM" do
+  s.stop
+end
+
+s.start
+s.join

data/bin/zabbirc-install

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+case ARGV.size
+when 0
+  install_path = Dir.pwd
+when 1
+  install_path = ARGV[0]
+when 2
+  puts "Too many arguments"
+  exit 1
+end
+
+puts "Installing config file into: #{install_path}"
+templates_path = Pathname.new(File.expand_path(Pathname.new(File.dirname(__FILE__)).join("../templates")))
+
+FileUtils.cp(templates_path.join("zabbirc_config.rb"), install_path)
+puts "Installed"

data/config/config.rb

@@ -0,0 +1,5 @@
+Zabbirc.configure do |config|
+  config.zabbix_api_url = ENV['ZABBIX_API_URL']
+  config.zabbix_login = ENV['ZABBIX_LOGIN']
+  config.zabbix_password = ENV['ZABBIX_PASSWORD']
+end

data/lib/zabbirc/configuration.rb

@@ -0,0 +1,43 @@
+require 'active_support/configurable'
+
+module Zabbirc
+  def self.configure(&block)
+    block.call(@config ||= Zabbirc::Configuration.new)
+  end
+
+  def self.config
+    @config
+  end
+
+  class Configuration #:nodoc:
+    include ActiveSupport::Configurable
+
+    config_accessor :zabbix_api_url
+    config_accessor :zabbix_login
+    config_accessor :zabbix_password
+
+    config_accessor :irc_server
+    config_accessor :irc_channels
+
+    config_accessor :events_check_interval
+    config_accessor :notify_about_events_from_last
+
+    def param_name
+      config.param_name.respond_to?(:call) ? config.param_name.call : config.param_name
+    end
+
+    # define param_name writer (copied from AS::Configurable)
+    writer, line = 'def param_name=(value); config.param_name = value; end', __LINE__
+    singleton_class.class_eval writer, __FILE__, line
+    class_eval writer, __FILE__, line
+  end
+
+  # this is ugly. why can't we pass the default value to config_accessor...?
+  configure do |config|
+    config.events_check_interval = 10.seconds
+    config.notify_about_events_from_last = 5.minutes
+
+    config.irc_server = "irc.freenode.org"
+    config.irc_channels = ["#zabbirc-test", "#zabbirc-test-2"]
+  end
+end

data/lib/zabbirc/irc/plugin.rb

@@ -0,0 +1,20 @@
+require_relative "plugin_methods"
+
+module Zabbirc
+  module Irc
+    class Plugin
+      include Cinch::Plugin
+      include PluginMethods
+
+      listen_to :join, method: :sync_ops
+      listen_to :leaving, method: :sync_ops
+
+      match "settings", method: :show_settings
+      match /settings set ([#_a-zA-Z0-9]+)( ([#\-_a-zA-Z0-9]+))?/, method: :set_setting
+      match "events", method: :list_events
+      match /status ([a-zA-Z0-9\-.]+)/, method: :host_status
+      match /latest ([a-zA-Z0-9\-.]+)( (\d+))?/, method: :host_latest
+      match /ack (\d+) (.*)/, method: :acknowledge_event
+    end
+  end
+end

data/lib/zabbirc/irc/plugin_methods.rb

@@ -0,0 +1,208 @@
+module Zabbirc
+  module Irc
+    module PluginMethods
+
+      def acknowledge_event m, eventid, message
+        return unless authenticate m.user.nick
+        op = get_op m
+        event = find_event m, eventid
+        return unless event
+
+        if event.acknowledge "#{op.nick}: #{message}"
+          m.reply "#{op.nick}: Event `#{event.label}` acknowledged with message: #{message}"
+        else
+          m.reply "#{op.nick}: Could not acknowledge event `#{event.label}`"
+        end
+      end
+
+      def host_status m, host
+        return unless authenticate m.user.nick
+        op = get_op m
+        host = find_host m, host
+        return unless host
+
+        triggers = Zabbix::Trigger.get(hostids: host.id, filter: {value: 1}, selectHosts: :extend)
+        triggers = triggers.sort{|x,y| x.priority <=> y.priority }
+        msg = ["#{op.nick}: Host: #{host.name}"]
+        if triggers.empty?
+          msg[0] << " - status: OK"
+        else
+          msg[0] << " - status: #{triggers.size} problems"
+          triggers.each do |trigger|
+            msg << "#{op.nick}: status: #{trigger.label}"
+          end
+        end
+        m.reply msg.join("\n")
+      end
+
+      def host_latest m, host, _rest, limit
+        limit ||= 8
+        return unless authenticate m.user.nick
+        op = get_op m
+        host = find_host m, host
+        return unless host
+
+        msg = ["#{op.nick}: Host: #{host.name}"]
+        events = Zabbix::Event.get(hostids: host.id, limit: limit, selectHosts: :extend, selectRelatedObject: :extend, sortfield: :clock, sortorder: "DESC")
+        if events.empty?
+          msg[0] << " - no events found"
+        else
+          msg[0] << " - showing last #{events.size} events"
+          events.each do |event|
+            msg << "#{op.nick}: !latest: #{event.label}"
+          end
+        end
+        m.reply msg.join("\n")
+      end
+
+      def sync_ops m, u=nil
+        return if u and u.nick == bot.nick
+        bot.zabbirc_service.ops_service.iterate
+      end
+
+      ### Settings
+      def show_settings m
+        return unless authenticate m.user.nick
+        op = get_op m
+        m.reply "#{op.nick}: #{op.setting}"
+      end
+
+      def set_setting m, key, _rest, value
+        return unless authenticate m.user.nick
+        op = get_op m
+        case key
+        when "notify"
+          set_notify m, op, value
+        when "events_priority"
+          set_events_priority m, op, value
+        when "primary_channel"
+          set_primary_channel m, op, value
+        else
+          m.reply "#{op.nick}: unknown setting `#{key}`"
+        end
+      end
+
+      def set_notify m, op, value
+        if value.nil?
+          m.reply "#{op.nick}: notify allowed values: true, on, 1, false, off, 0"
+          return
+        end
+        case value
+        when "true", "on", "1"
+          op.setting.set :notify, true
+        when "false", "off", "0"
+          op.setting.set :notify, false
+        else
+          m.reply "#{op.nick}: uknown value `#{value}`. Allowed values: true, on, 1, false, off, 0"
+          return
+        end
+        m.reply "#{op.nick}: setting `notify` was set to `#{op.setting.get :notify}`"
+      end
+
+      def set_events_priority m, op, value
+        if value.nil?
+          m.reply "#{op.nick}: events_priority allowed values: #{Priority::PRIORITIES.values.collect{|v| "`#{v}`"}.join(', ')} or numeric #{Priority::PRIORITIES.keys.join(", ")} "
+          return
+        end
+        begin
+          value = value.to_i if value =~ /^\d+$/
+          priority = Priority.new value
+        rescue ArgumentError
+          m.reply "#{op.nick}: uknown value `#{value}`. Allowed values: #{Priority::PRIORITIES.values.collect{|v| "`#{v}`"}.join(', ')} or numeric #{Priority::PRIORITIES.keys.join(", ")} "
+          return
+        end
+        op.setting.set :events_priority, priority.code
+        m.reply "#{op.nick}: setting `events_priority` was set to `#{op.setting.get :events_priority}`"
+      end
+
+      def set_primary_channel m, op, value
+        channel_names = op.channels.collect(&:name)
+        if value.nil?
+          m.reply "#{op.nick}: notify allowed values: #{channel_names.join(", ")}"
+          return
+        end
+        case value
+        when *channel_names
+          op.setting.set :primary_channel, value
+        else
+          m.reply "#{op.nick}: uknown value `#{value}`. Allowed values: #{channel_names.join(", ")}"
+          return
+        end
+        m.reply "#{op.nick}: setting `primary_channel` was set to `#{op.setting.get :primary_channel}`"
+      end
+
+      ### Events
+      def list_events m
+        return unless authenticate m.user.nick
+        events = Zabbix::Event.recent
+        msg = if events.any?
+                events.collect do |e|
+                  "#{m.user.nick}: #{e.label}"
+                end.join("\n")
+              else
+                "#{m.user.nick}: No last events"
+              end
+        m.reply msg
+      end
+
+      def ops
+        @ops ||= bot.zabbirc_service.ops
+      end
+
+      ### Authentication and helpers
+      def authenticate obj
+        nick = get_nick obj
+        ops.authenticate nick
+      end
+
+      def get_op obj
+        nick = get_nick obj
+        ops.get nick
+      end
+
+      def get_nick obj
+        case obj
+        when Cinch::Message
+          obj.user.nick
+        when Cinch::User
+          obj.nick
+        when String
+          obj
+        end
+      end
+
+      private
+
+      def find_host m, host
+        op = get_op m
+        hosts = Zabbix::Host.get(search: {host: host})
+        case hosts.size
+        when 0
+          m.reply "#{op.nick}: Host not found `#{host}`"
+        when 1
+          return hosts.first
+        when 2..10
+          m.reply "#{op.nick}: Found #{hosts.size} hosts: #{hosts.collect(&:name).join(', ')}. Be more specific"
+        else
+          m.reply "#{op.nick}: Found #{hosts.size} Be more specific"
+        end
+        false
+      end
+
+      def find_event m, eventid
+        op = get_op m
+        begin
+          event = Zabbix::Event.find(eventid, {selectHosts: :extend, selectRelatedObject: :extend})
+          if event.nil?
+            m.reply "#{op.nick} Could not find event with id `#{eventid}`"
+            return false
+          end
+          event
+        rescue Zabbix::IDNotUniqueError => e
+          m.reply "#{op.nick} Could not find event: #{e}"
+          false
+        end
+      end
+    end
+  end
+end

data/lib/zabbirc/logger.rb

@@ -0,0 +1,45 @@
+module Zabbirc
+  def self.logger
+    @logger ||= ::Logger.new(STDERR, 10, 1.megabyte).tap do |logger|
+      logger.formatter = Zabbirc::Logger::Formatter.new
+    end
+  end
+
+  module Logger
+    class Formatter
+      Format = "%s, [%s#%d T%d] %5s -- %s: %s\n"
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        Format % [severity[0..0], format_datetime(time), $$, Thread.current.object_id, severity, progname, msg2str(msg)]
+      end
+
+      private
+
+      def format_datetime(time)
+        if @datetime_format.nil?
+          time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
+        else
+          time.strftime(@datetime_format)
+        end
+      end
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{ msg.message } (#{ msg.class })\n" <<
+              (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end

data/lib/zabbirc/op.rb

@@ -0,0 +1,67 @@
+module Zabbirc
+  class Op
+
+    attr_reader :channels, :setting, :nick
+    def initialize zabbix_user: nil, irc_user: nil
+      raise ArgumentError, 'zabbix_user' if zabbix_user.nil?
+      raise ArgumentError, 'irc_user' if irc_user.nil?
+      @nick = zabbix_user.alias
+      @zabbix_user = zabbix_user
+      @irc_user = irc_user
+
+      @notified_events = {}
+      @channels = Set.new
+      @setting = Setting.new
+    end
+
+    def primary_channel
+      @channels.find{|c| c.name == @setting.get(:primary_channel) }
+    end
+
+    def interesting_priority
+      Priority.new @setting.get(:events_priority)
+    end
+
+    def add_channel channel
+      @setting.fetch :primary_channel, channel
+      @channels << channel
+    end
+
+    def remove_channel channel
+      @channels.delete channel
+
+      if channel == @setting.get(:primary_channel)
+        @setting.set :primary_channel, @channels.first
+      end
+    end
+
+    def notify event
+      return if event.priority < interesting_priority
+      @notified_events ||= {}
+      return if @notified_events.key? event.id
+      channel = primary_channel
+      return unless channel
+      channel.send "#{@nick}: #{event.label}"
+      @notified_events[event.id] = Time.now
+      clear_notified_events
+    end
+
+    def interested_in? event
+      return false unless setting.get :notify
+      return false if @notified_events.key? event.id
+      event.priority >= interesting_priority
+    end
+
+    def event_notified event
+      @notified_events[event.id] = Time.now
+    end
+
+    private
+
+    def clear_notified_events
+      @notified_events.delete_if do |event_id, timestamp|
+        timestamp < (Zabbirc.config.notify_about_events_from_last * 2).seconds.ago
+      end
+    end
+  end
+end

data/lib/zabbirc/op_list.rb

@@ -0,0 +1,47 @@
+module Zabbirc
+  class OpList
+    include Enumerable
+
+    def initialize ops=nil
+      @ops = {}
+      if ops
+        ops.each do |op|
+          add op
+        end
+      end
+    end
+
+    def authenticate name
+      @ops.key? name
+    end
+
+    alias_method :exists?, :authenticate
+
+    def get name
+      @ops[name]
+    end
+
+    def add op
+      if exists? op.nick
+        return get(op.nick)
+      end
+      @ops[op.nick] = op
+    end
+
+    def each &block
+      @ops.values.each &block
+    end
+
+    def interested_in event
+      self.class.new(find_all{ |op| op.interested_in? event })
+    end
+
+    def notify event
+      group_by(&:primary_channel).each do |channel, ops|
+        op_targets = ops.collect{|op| "#{op.nick}:" }.join(" ")
+        channel.send "#{op_targets} #{event.label}"
+        ops.each{ |op| op.event_notified event }
+      end
+    end
+  end
+end

data/lib/zabbirc/priority.rb

@@ -0,0 +1,38 @@
+module Zabbirc
+  class Priority
+    include Comparable
+
+    PRIORITIES = {
+        0 => :not_classified,
+        1 => :information,
+        2 => :warning,
+        3 => :average,
+        4 => :high,
+        5 => :disaster
+    }
+
+    attr_reader :number, :code
+    def initialize priority
+      case priority
+      when String, Symbol
+        raise ArgumentError, "unknown priority `#{priority}`" unless PRIORITIES.key(priority.to_sym)
+        @number = PRIORITIES.key(priority.to_sym)
+        @code = priority.to_sym
+      when Integer
+        raise ArgumentError, "unknown priority `#{priority}`" unless PRIORITIES[priority]
+        @number = priority
+        @code = PRIORITIES[@number]
+      else
+        raise ArgumentError, "cannot create priority from `#{priority}` of class `#{priority.class}`"
+      end
+    end
+
+    def <=> other
+      number <=> other.number
+    end
+
+    def to_s
+      code.to_s
+    end
+  end
+end

data/lib/zabbirc/service.rb

@@ -0,0 +1,86 @@
+require 'cinch'
+
+module Zabbirc
+  class Service
+    attr_reader :cinch_bot
+    attr_reader :ops, :ops_service
+    attr_reader :running
+
+    def initialize
+      @semaphores_mutex = Mutex.new
+      @semaphores       = Hash.new { |h, k| h[k] = Mutex.new }
+      @ops = OpList.new
+      @running = false
+
+      initialize_bot
+
+      @ops_service = Services::Ops.new self, @cinch_bot
+      @events_service = Services::Events.new self, @cinch_bot
+    end
+
+    def initialize_bot
+      @cinch_bot = Cinch::Bot.new do
+        configure do |c|
+          c.server = Zabbirc.config.irc_server
+          c.channels = Zabbirc.config.irc_channels
+          c.nick = "zabbirc"
+          c.plugins.plugins = [Irc::Plugin]
+        end
+      end
+
+      # Stores reference to this Zabbirc::Service to be available in plugins
+      @cinch_bot.instance_variable_set :@zabbirc_service, self
+      @cinch_bot.class_eval do
+        attr_reader :zabbirc_service
+      end
+    end
+
+    def synchronize(name, &block)
+      # Must run the default block +/ fetch in a thread safe way in order to
+      # ensure we always get the same mutex for a given name.
+      semaphore = @semaphores_mutex.synchronize { @semaphores[name] }
+      semaphore.synchronize(&block)
+    end
+
+    def start join=true
+      return if @running
+      @running = true
+      @cinch_bot_thread = Thread.new do
+        begin
+          @cinch_bot.start
+        rescue => e
+          Zabbirc.logger.fatal "Cinch bot start error: #{e}"
+        end
+      end
+
+      @controll_thread = Thread.new do
+        begin
+          sleep
+        rescue StopError
+          @ops_service.stop
+          @events_service.stop
+
+          Zabbirc.logger.info "Stopping ops service: #{@ops_service.join}"
+          Zabbirc.logger.info "Stopping events service: #{@events_service.join}"
+
+          @cinch_bot.quit
+        ensure
+          @running = false
+        end
+      end
+
+      @ops_service.start
+      @events_service.start
+
+      @cinch_bot_thread.join if join
+    end
+
+    def stop
+      @controll_thread.raise StopError
+    end
+
+    def join
+      @cinch_bot_thread.join
+    end
+  end
+end

data/lib/zabbirc/services/base.rb

@@ -0,0 +1,56 @@
+module Zabbirc
+  module Services
+    class Base
+      LOOP_SLEEP = 10
+      attr_reader :running
+
+      def initialize service, cinch_bot
+        @service   = service
+        @cinch_bot = cinch_bot
+        @running   = false
+        @mutex     = Mutex.new
+      end
+
+      def synchronize &block
+        @mutex.synchronize &block
+      end
+
+      def join
+        slept = 0
+        while slept < (LOOP_SLEEP * 2)
+          return true if @running == false
+          sleep 1
+          slept += 1
+        end
+        false
+      end
+
+      def start
+        main_thread = Thread.current
+        @thread     = Thread.new do
+          begin
+            loop do
+              Thread.handle_interrupt(StopError => :never) do
+                @running = true
+                iterate
+              end
+              Thread.handle_interrupt(StopError => :immediate) do
+                sleep LOOP_SLEEP
+              end
+            end
+          rescue StopError => e
+            # nothing, ensure block sets the variables
+          rescue => e
+            main_thread.raise e
+          ensure
+            @running = false
+          end
+        end
+      end
+
+      def stop
+        @thread.raise StopError
+      end
+    end
+  end
+end