zabbirc 0.0.11 → 0.1.0

data/lib/zabbirc/irc/settings_command.rb

@@ -0,0 +1,159 @@
+module Zabbirc
+  module Irc
+    class SettingsCommand < BaseCommand
+      register_help "settings", "Manage your op specific settings. Usage: !settings [show | set]"
+      register_help "settings set", [
+          "Set your op specific settings. Usage: !setting set <setting-name> <setting-value> [hostgroups <host-group-name>[,<host-group-name>] | hostgroups-all]",
+          "Some settings can be set per hostgroup. Flag `hostgroup-all` means that it will rewrite setting for all hostgroups.",
+          "When used without optional part(hostgroup), it will change default settings."
+      ]
+
+      private
+      def perform
+        sub_cmd = @args.shift
+        case sub_cmd
+        when nil, "show"
+          show
+        when "set"
+          set
+        else
+          reply "settings: unknown command `#{sub_cmd}`"
+          reply help_features["settings"], prefix: "HELP settings: "
+        end
+      end
+
+      def show
+        inline = @op.setting.collect do |key, value|
+          next if key == "host_groups"
+          "#{key}: #{value}"
+        end.compact.join(", ")
+
+        reply "Default settings: #{inline}"
+
+        host_group_options = []
+        @op.setting.get(:host_groups).each do |group_id, options|
+          if options.any?
+            group = Zabbix::HostGroup.find(group_id)
+            group_options = options.collect{|k,v| "#{k}: #{v}" }.sort.join(", ")
+            host_group_options << " - #{group.name}: #{group_options}"
+          end
+        end
+
+        if host_group_options.any?
+          reply "Host group settings:"
+          reply host_group_options
+        end
+      end
+
+      def set
+        key, value, host_groups_flag, host_groups  = parse_set_command
+        case key
+        when "notify", "notify_recoveries"
+          value = validate_boolean key, value
+        when "events_priority"
+          value = validate_events_priority value
+        when "primary_channel"
+          value = validate_primary_channel value
+        when nil, ""
+          reply help_features["settings set"]
+        else
+          reply "unknown setting `#{key}`"
+        end
+
+        set_value key, value, host_groups_flag, host_groups
+      end
+
+      def validate_boolean key, value
+        raise UserInputError, "#{key} allowed values: true, on, 1, false, off, 0" if value.blank?
+
+        case value
+        when "true", "on", "1" then true
+        when "false", "off", "0" then false
+        else
+          raise UserInputError, "uknown value `#{value}`. Allowed values: true, on, 1, false, off, 0"
+        end
+      end
+
+      def validate_events_priority value
+        allowed_values = "#{Priority::PRIORITIES.values.collect{|v| "`#{v}`"}.join(', ')} or numeric #{Priority::PRIORITIES.keys.join(", ")} "
+        raise UserInputError, "events_priority allowed values: #{allowed_values}" if value.blank?
+        begin
+          value = value.to_i if value =~ /^\d+$/
+          priority = Priority.new value
+        rescue ArgumentError
+          raise UserInputError, "uknown value `#{value}`. Allowed values: #{allowed_values}"
+        end
+        priority.code
+      end
+
+      def validate_primary_channel value
+        channel_names = @op.channels.collect(&:name)
+        raise UserInputError, "primary_channel allowed values: #{channel_names.join(", ")}" if value.blank?
+        raise UserInputError, "uknown value `#{value}`. Allowed values: #{channel_names.join(", ")}" unless channel_names.include? value
+        value
+      end
+
+      def set_value key, value, host_groups_flag, host_groups
+        case host_groups_flag
+        when :none
+          @op.setting.set key, value
+          reply "setting `#{key}` has been set to `#{@op.setting.get key}`"
+        when :all
+          @op.setting.set key, value
+          host_groups.each do |host_group|
+            @op.setting.set key, value, host_group_id: host_group.id
+          end
+          reply "setting `#{key}` has been set to `#{@op.setting.get key}` for all host groups"
+        when :some
+          host_groups.each do |host_group|
+            @op.setting.set key, value, host_group_id: host_group.id
+          end
+          reply "setting `#{key}` has been set to `#{value}` for host groups: #{host_groups.collect(&:name).join(", ")}"
+        end
+      end
+
+      private
+      def parse_set_command
+        key = @args.shift
+        value = @args.shift
+        host_groups_arg = @args.shift
+
+        case host_groups_arg
+        when 'hostgroups-all'
+          host_groups = Zabbix::HostGroup.get
+          host_groups_flag = :all
+        when 'hostgroups'
+          names = @args.join(" ").split(",").collect(&:strip)
+          raise UserInputError, ['no hostgroups specified'] + Array.wrap(help_features["settings set"]) if names.empty?
+          host_groups = find_host_groups names
+          host_groups_flag = :some
+        when nil, ""
+          host_groups = []
+          host_groups_flag = :none
+        else
+          raise UserInputError, help_features["settings set"]
+        end
+        [key, value, host_groups_flag, host_groups]
+      end
+
+      def find_host_groups names
+        names.collect do |name|
+          host_group = Zabbix::HostGroup.get(search: { name: name })
+          case host_group.size
+          when 0
+            raise UserInputError, "Cannot find hostgroup with name: `#{name}`"
+          when 1
+            host_group.first
+          when 2..10
+            raise UserInputError, "Found #{host_group.size} host groups using name: `#{name}` be more specific. Host groups: #{host_group.collect(&:name).join(", ")}"
+          else
+            raise UserInputError, "Found #{host_group.size} host groups using name: `#{name}` be more specific"
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# TODO filtrovanie eventov podla hostgroup

data/lib/zabbirc/op.rb

@@ -1,7 +1,7 @@
 module Zabbirc
   class Op
 
-    attr_reader :channels, :setting, :nick, :login
+    attr_reader :channels, :setting, :nick, :login, :irc_user
     def initialize zabbix_user
       raise ArgumentError, 'zabbix_user' if zabbix_user.nil?
       @login= zabbix_user.alias
@@ -38,8 +38,10 @@ module Zabbirc
       end
     end
 
-    def interesting_priority
-      Priority.new @setting.get(:events_priority)
+    def interesting_priorities host_groups
+      host_settings(:events_priority, host_groups).collect do |setting|
+        Priority.new setting
+      end
     end
 
     def add_channel channel
@@ -63,10 +65,18 @@ module Zabbirc
     end
 
     def interested_in? event
-      return false unless setting.get :notify
+      host_groups = event.host_groups
+      return false if host_settings(:notify, host_groups).all?{|x| x == false }
       return false if @notified_events.key? event.id
-      return false if event.value == :ok and not setting.get :notify_recoveries
-      event.priority >= interesting_priority
+      return false if event.value == :ok and host_settings(:notify_recoveries, host_groups).all?{|x| x == false }
+      interesting_priorities(host_groups).any? do |interesting_priority|
+        event.priority >= interesting_priority
+      end
+    end
+
+    def host_settings name, host_groups
+      settings = host_groups.collect{|hg| setting.get name, host_group_id: hg.id }
+      settings.uniq
     end
 
     def event_notified event

data/lib/zabbirc/setting.rb

@@ -4,9 +4,11 @@ module Zabbirc
         notify: true,
         notify_recoveries: true,
         primary_channel: nil,
-        events_priority: Zabbirc.config.default_events_priority
+        events_priority: Zabbirc.config.default_events_priority,
+        host_groups: ActiveSupport::HashWithIndifferentAccess.new
     })
 
+    delegate :collect, to: :@options
     def initialize
       @options = ActiveSupport::HashWithIndifferentAccess.new DEFAULTS.deep_dup
     end
@@ -18,26 +20,61 @@ module Zabbirc
       @options = DEFAULTS.deep_dup.merge(stored_options)
     end
 
-    def set name, value
-      @options[name] = value
+    def set name, value, *options
+      host_group_id = parse_host_group_id(options)
+      if host_group_id
+        set_with_host_group name, value, host_group_id
+      else
+        @options[name] = value
+      end
     end
 
-    def get name
-      @options[name]
+    def get name, *options
+      host_group_id = parse_host_group_id(options)
+      if host_group_id
+        first_not_nil(host_group_options(host_group_id)[name], @options[name])
+      else
+        @options[name]
+      end
     end
 
-    def fetch name, value
-      @options[name] ||= value
-    end
+    def fetch name, value, *options
+      host_group_id = parse_host_group_id(options)
 
-    def to_s
-      @options.collect do |k, v|
-        "#{k}: #{v}"
-      end.join(", ")
+      if host_group_id
+        if host_group_options(host_group_id)[name].nil?
+          set_with_host_group name, value, host_group_id
+        else
+          get name, host_group_id: host_group_id
+        end
+      else
+        @options[name] ||= value
+      end
     end
 
     def to_hash
       @options.to_hash.deep_dup
     end
+
+    private
+    def parse_host_group_id args
+      args.extract_options![:host_group_id]
+    end
+
+    def set_with_host_group name, value, host_group_id
+      if get(name) == value
+        host_group_options(host_group_id).delete(name)
+      else
+        host_group_options(host_group_id)[name] = value
+      end
+    end
+
+    def host_group_options host_group_id
+      @options[:host_groups][host_group_id] ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def first_not_nil *args
+      args.find{|x| not x.nil? }
+    end
   end
 end

data/lib/zabbirc/version.rb

@@ -0,0 +1,3 @@
+module Zabbirc
+  VERSION = "0.1.0"
+end

data/lib/zabbirc/zabbix/event.rb

@@ -12,13 +12,28 @@ module Zabbirc
             selectHosts: :extend
         }.merge(options)
 
+
+
         priority_from = Priority.new(params.delete(:priority_from))
         events = get params
+
+        preload_host_groups events
+
         events = events.find_all{|e| e.priority >= priority_from }
         events.sort{|x,y| x.priority <=> y.priority }
       end
 
+      def self.preload_host_groups events
+        host_ids = events.flat_map(&:hosts).collect(&:id).uniq
+        hosts = Host.get(hostids: host_ids, selectGroups: :extend)
+        events.each do |event|
+          event_host_ids = event.hosts.collect(&:id)
+          event.host_groups = hosts.select{|h| event_host_ids.include? h.id }.flat_map(&:groups)
+        end
+      end
+
       attr_reader :attrs
+      attr_writer :host_groups
 
       delegate :priority, :priority_code, to: :related_object
 
@@ -28,6 +43,14 @@ module Zabbirc
         @related_object ||= determine_related_object
       end
 
+      def host_groups
+        @host_groups ||= begin
+          host_ids = hosts.collect(&:id).uniq
+          hosts = Host.get(hostids: host_ids, selectGroups: :extend)
+          hosts.flat_map(&:groups)
+        end
+      end
+
       def acknowledge message
         res = api.event.acknowledge(eventids: id, message: message)
         res["eventids"].collect(&:to_i).include? id.to_i

data/lib/zabbirc/zabbix/host.rb

@@ -1,6 +1,7 @@
 module Zabbirc
   module Zabbix
     class Host < Resource::Base
+      has_many :groups, class_name: "HostGroup"
     end
   end
 end

data/lib/zabbirc/zabbix/host_group.rb

@@ -0,0 +1,8 @@
+module Zabbirc
+  module Zabbix
+    class HostGroup < Resource::Base
+      set_model_name "hostgroup"
+      set_id_attr_name "groupid"
+    end
+  end
+end

data/lib/zabbirc/zabbix/resource/associations.rb

@@ -2,16 +2,22 @@ module Zabbirc
   module Zabbix
     module Resource
       module Associations
-        def has_many name
+        def has_many name, *options
+          options = options.extract_options!.reverse_merge({
+            zabbix_attribute: name,
+            class_name: name.to_s.singularize.camelize
+          })
+
+          extend_key = :"select#{options[:zabbix_attribute].to_s.camelize.pluralize || name.to_s.camelize}"
           define_method name do
             @associations ||= ActiveSupport::HashWithIndifferentAccess.new
             @associations[name] ||= begin
-              assoc_class = Zabbix.const_get(name.to_s.singularize.camelize)
-              hash_data = @attrs[name]
+              assoc_class = Zabbix.const_get(options[:class_name])
+              hash_data = @attrs[options[:zabbix_attribute]]
               if hash_data.blank?
-                this = self.class.find id, :"select#{name.to_s.camelize}" => :extend
-                raise StandardError, "zabbix response does not contain #{name}" if this[name].blank?
-                hash_data = this[name]
+                this = self.class.find id, extend_key => :extend
+                raise StandardError, "zabbix response does not contain #{options[:zabbix_attribute]}" if this[options[:zabbix_attribute]].blank?
+                hash_data = this[options[:zabbix_attribute]]
               end
 
               hash_data.collect do |obj|

data/lib/zabbirc/zabbix/resource/base.rb

@@ -18,6 +18,14 @@ module Zabbirc
           @model_name ||= name.split(/::/).last.underscore
         end
 
+        def self.id_attr_name
+          @id_attr_name ||= "#{model_name}id"
+        end
+
+        def self.set_id_attr_name id_attr_name
+          @id_attr_name = id_attr_name
+        end
+
         def self.api
           Connection.get_connection.client
         end
@@ -28,11 +36,11 @@ module Zabbirc
 
         def initialize attrs
           @attrs = ActiveSupport::HashWithIndifferentAccess.new attrs
-          raise ArgumentError, "attribute `#{self.class.model_name}id` not found, probably not a #{self.class.model_name}" unless @attrs.key? :"#{self.class.model_name}id"
+          raise ArgumentError, "attribute `#{self.class.id_attr_name}` not found, probably not a #{self.class.model_name}" unless @attrs.key? :"#{self.class.id_attr_name}"
         end
 
         def id
-          @attrs["#{self.class.model_name}id"]
+          @attrs[self.class.id_attr_name]
         end
 
         def [] attr

data/lib/zabbirc/zabbix/resource/finders.rb

@@ -5,7 +5,7 @@ module Zabbirc
         def find id, *options
           options = options.extract_options!
           options = options.reverse_merge({
-                                              :"#{model_name}ids" => id
+                                              :"#{id_attr_name}s" => id
                                           })
           res = api.send(model_name).get options
           ret = if res.size == 0

data/lib/zabbirc.rb

@@ -2,6 +2,7 @@ require 'active_support/all'
 require 'singleton'
 require 'dotenv'
 require 'yaml'
+require 'pathname'
 Dotenv.load
 
 def require_dir dir
@@ -29,4 +30,4 @@ require_dir "zabbirc/irc/*.rb"
 require 'zabbirc/zabbix/resource/base'
 require_dir "zabbirc/zabbix/*.rb"
 require 'zabbirc/services/base'
-require_dir "zabbirc/services/*.rb"
+require_dir "zabbirc/services/*.rb"

data/spec/event_command_spec.rb

@@ -0,0 +1,114 @@
+describe Zabbirc::Irc::HostCommand do
+  let(:ops_builder) { Zabbirc::OpsBuilder.new }
+  let(:mock_nick) { "op1" }
+  let(:mock_op) { ops_builder.build_op(mock_nick, mock_user_settings) }
+  let(:mock_message) { double("Cinch::Message", user: mock_op.irc_user) }
+  let(:mock_user_settings) { nil }
+  let(:event_command) { Zabbirc::Irc::EventCommand.new ops_builder.ops, mock_message, cmd }
+
+
+  describe "events", focus: true do
+    context "no host arg" do
+      let(:cmd) { "events" }
+      let(:event1) { double "Event", label: "Event 1 label", priority: Zabbirc::Priority.new(:high) }
+      let(:event2) { double "Event", label: "Event 2 label", priority: Zabbirc::Priority.new(:high) }
+      let(:events) { [event1, event2] }
+
+      let(:expected_msg) do
+        events.collect do |event|
+          "#{mock_nick}: #{event.label}"
+        end.join("\n")
+      end
+      before do
+        allow(Zabbirc::Zabbix::Event).to receive(:recent).and_return(events)
+      end
+
+      it "should report latest events" do
+        expect(mock_message).to receive(:reply).with(expected_msg)
+        event_command.run
+      end
+    end
+
+    context "with priority arg" do
+      let(:priority) { Zabbirc::Priority.new "high" }
+      let(:cmd) { "events #{priority}" }
+      let(:event_high) { double "Event", label: "Event High label", priority: Zabbirc::Priority.new(:high) }
+      let(:event_average) { double "Event", label: "Event Average label", priority: Zabbirc::Priority.new(:average) }
+      let(:events) { [event_high, event_average] }
+      let(:expected_events) { events.select{|e| e.priority == priority } }
+
+      let(:expected_msg) do
+        expected_events.collect do |event|
+          "#{mock_nick}: #{event.label}"
+        end.join("\n")
+      end
+      before do
+        allow(Zabbirc::Zabbix::Event).to receive(:recent).and_return(events)
+      end
+
+      it "should report latest events" do
+        expect(mock_message).to receive(:reply).with(expected_msg)
+        event_command.run
+      end
+    end
+
+
+    context "with priority and host arg" do
+      let(:host) { "host1" }
+      let(:priority) { Zabbirc::Priority.new "high" }
+      let(:cmd) { "events #{priority} #{host}" }
+      let(:event_high_good_host) { double "Event", label: "Event High label", priority: Zabbirc::Priority.new(:high) }
+      let(:event_high_bad_host) { double "Event", label: "Event High label", priority: Zabbirc::Priority.new(:high) }
+      let(:event_average) { double "Event", label: "Event Average label", priority: Zabbirc::Priority.new(:average) }
+      let(:events) { [event_high_good_host, event_high_bad_host, event_average] }
+      let(:expected_events) { events.select{|e| e.priority == priority }.select{|e| e.any_host_matches? host } }
+
+      let(:expected_msg) do
+        expected_events.collect do |event|
+          "#{mock_nick}: #{event.label}"
+        end.join("\n")
+      end
+      before do
+        allow(Zabbirc::Zabbix::Event).to receive(:recent).and_return(events)
+        allow(event_high_good_host).to receive(:any_host_matches?).with(/#{host}/).and_return(true)
+        allow(event_high_bad_host).to receive(:any_host_matches?).with(/#{host}/).and_return(false)
+      end
+
+      it "should report latest events" do
+        expect(mock_message).to receive(:reply).with(expected_msg)
+        event_command.run
+      end
+    end
+  end
+
+  describe "ack" do
+    let(:event) { double "Event", eventid: 1, label: "Event to ack" }
+    let(:message) { "ack message" }
+    let(:cmd) { "ack #{short_event_id} #{message}" }
+
+    context "bad short_event_id" do
+      let(:short_event_id) { "XXX" }
+      let(:expected_msg) { "#{mock_nick}: Bad event id `#{short_event_id}`" }
+
+      it "should report error message" do
+        expect(mock_message).to receive(:reply).with(expected_msg)
+        event_command.run
+      end
+    end
+
+    context "good short_event_id" do
+      let(:short_event_id) { Zabbirc.events_id_shortener.get_shorten_id(event.eventid) }
+      let(:expected_msg) { "#{mock_nick}: Event `#{event.label}` acknowledged with message: #{message}" }
+      before do
+        allow(Zabbirc::Zabbix::Event).to receive(:find).with(event.eventid, anything).and_return(event)
+        allow(event).to receive(:acknowledge).and_return(true)
+      end
+
+      it "should acknowledge event" do
+        expect(mock_message).to receive(:reply).with(expected_msg)
+        event_command.run
+      end
+    end
+  end
+
+end

data/spec/host_command_spec.rb

@@ -0,0 +1,106 @@
+describe Zabbirc::Irc::HostCommand do
+  let(:ops_builder) { Zabbirc::OpsBuilder.new }
+  let(:mock_nick) { "op1" }
+  let(:mock_op) { ops_builder.build_op(mock_nick, mock_user_settings) }
+  let(:mock_message) { double("Cinch::Message", user: mock_op.irc_user) }
+  let(:mock_user_settings) { nil }
+  let(:host_command) { Zabbirc::Irc::HostCommand.new ops_builder.ops, mock_message, cmd }
+
+  describe "#host_status" do
+    before do
+      allow(Zabbirc::Zabbix::Host).to receive(:get).and_return(hosts)
+    end
+
+    context "reporting" do
+      before do
+        allow(Zabbirc::Zabbix::Trigger).to receive(:get).and_return(problem_triggers)
+      end
+      let(:cmd) { "status #{host.name}" }
+      let(:host) { double "Host", id: 1, name: "Host-1" }
+      let(:hosts) { [host] }
+      let(:problem_trigger) { double "Trigger", priority: Zabbirc::Priority.new(1), label: "problem_trigger", value: 1 }
+      context "problem trigger" do
+        let(:problem_triggers) { [problem_trigger] }
+        let(:expected_msg) do
+          msg = ["#{mock_nick}: Host: #{host.name} - status: #{problem_triggers.size} problems"]
+          problem_triggers.each do |trigger|
+            msg << "#{mock_nick}: status: #{trigger.label}"
+          end
+          msg.join("\n")
+        end
+
+        it "should report problem" do
+          expect(mock_message).to receive(:reply).with(expected_msg)
+          host_command.run
+        end
+      end
+
+      context "ok trigger" do
+        let(:problem_triggers) { [] }
+        let(:expected_msg) { "#{mock_nick}: Host: #{host.name} - status: OK" }
+        it "should report problem" do
+          expect(mock_message).to receive(:reply).with(expected_msg)
+          host_command.run
+        end
+      end
+    end # context reporting
+
+    context "host identification" do
+      let(:cmd) { "status #{host_name_value}" }
+      context "no hosts" do
+        let(:hosts) { [] }
+        let(:host_name_value) { "undefined_host_name" }
+        it "should not found host" do
+          expect(mock_message).to receive(:reply).with("#{mock_nick}: Host not found `#{host_name_value}`")
+          host_command.run
+        end
+      end
+
+      context "2 - 10 hosts" do
+        let(:host1) { double "Host1", id: 1, name: "host-1" }
+        let(:host2) { double "Host2", id: 2, name: "host-2" }
+        let(:hosts) { [host1, host2] }
+        let(:host_name_value) { "host" }
+        let(:expected_msg) { "#{mock_nick}: Found #{hosts.size} hosts: #{hosts.collect(&:name).join(', ')}. Be more specific" }
+        it "should print host names" do
+          expect(mock_message).to receive(:reply).with(expected_msg)
+          host_command.run
+        end
+      end
+
+      context "more than 10 hosts" do
+        let(:hosts) { double "HostsArray", size: 11 }
+        let(:host_name_value) { "host" }
+        let(:expected_msg) { "#{mock_nick}: Found #{hosts.size} Be more specific" }
+        it "should print host names" do
+          expect(mock_message).to receive(:reply).with(expected_msg)
+          host_command.run
+        end
+      end
+    end # context host identification
+  end # context #host_status
+
+  context "#host_latest" do
+    let(:host) { double "Host", id: 1, name: "Host1" }
+    let(:hosts) { [host] }
+    let(:event1) { double "Event", label: "Event 1 label" }
+    let(:events) { [event1] }
+    let(:expected_msg) do
+      msg = ["#{mock_nick}: Host: #{host.name} - showing last #{events.size} events"]
+      events.each do |event|
+        msg << "#{mock_nick}: !latest: #{event.label}"
+      end
+      msg.join("\n")
+    end
+    before do
+      allow(Zabbirc::Zabbix::Host).to receive(:get).and_return(hosts)
+      allow(Zabbirc::Zabbix::Event).to receive(:get).and_return(events)
+    end
+
+    let(:cmd) { "latest Host1" }
+    it "should print latest events" do
+      expect(mock_message).to receive(:reply).with(expected_msg)
+      host_command.run
+    end
+  end
+end