SystemMonitoring
2.4.3
OTRS AG
http://otrs.org/
GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007
Added documentation for missnaming of dynamic fields and error messages for missnamed dynamic fields (Bug 8381).
Including new handling for TicketID param.
First version for OTRS 3.2.
Basic mail interface to System Monitoring Suites. Also provides deeper integration to Nagios (Acknowledge on lock and Checkscript).
Einfache Email Schnittstelle zu System Monitoring Suites. Weitergehende Integration mit Nagios (Acknowledge on lock and Checkscript).
3.2.x
For configuration instructions please refer to the enclosed PDF documentation.
Eine Anleitung zur Konfiguration des SystemMonitoring Moduls findet sich in der Datei doc/SystemMonitoring.txt.
# define function name
my $FunctionName = 'CodeInstall';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
# check if config option exists
my $Config = $Self->{ConfigObject}->Get( 'PostMaster::PreFilterModule' );
# update/rename config option
if ($Config && $Config->{'0001-SystemMonitoring'} ) {
$Self->{SysConfigObject} = Kernel::System::Config->new( %{$Self} );
$Self->{SysConfigObject}->ConfigItemUpdate(
Valid => 1,
Key => 'PostMaster::PreFilterModule###00-SystemMonitoring',
Value => $Config->{'0001-SystemMonitoring'},
);
}
# define function name
my $FunctionName = 'CodeUpgrade';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# The code module has just recently been copied to it's location in the file system.
# In a persistent Perl environment an old version of the module might still be loaded,
# as watchdogs like Apache2::Reload haven't had a chance to reload it.
# So we need to make sure that the new version is being loaded.
# Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC.
# This is only needed in persistent Perl environment, but does no harm in a CGI environment.
my $CodeModulePath = $CodeModule;
$CodeModulePath =~ s/::/\//g;
$CodeModulePath .= '.pm';
delete $INC{$CodeModulePath};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm.",
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm.",
);
}
}
# define function name
my $FunctionName = 'CodeUpgradeFromLowerThan_2_2_92';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
# define function name
my $FunctionName = 'CodeUninstall';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
# cleanup stats list
{
# load required modules
$Self->{MainObject}->Require('Kernel::System::CSV');
$Self->{MainObject}->Require('Kernel::System::Group');
$Self->{MainObject}->Require('Kernel::System::User');
$Self->{MainObject}->Require('Kernel::System::Stats');
# create needed objects
$Self->{CSVObject} = Kernel::System::CSV->new( %{$Self} );
$Self->{GroupObject} = Kernel::System::Group->new( %{$Self} );
$Self->{UserObject} = Kernel::System::User->new( %{$Self} );
$Self->{StatsObject} = Kernel::System::Stats->new(
%{$Self},
UserID => 1,
);
# cleanup stats list
$Self->{StatsObject}->StatsCleanUp();
}
# define function name
my $FunctionName = 'CodeReinstall';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
2013-05-28 14:31:23
opms.otrs.com
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
<?xml version="1.0" encoding="iso-8859-1" ?>
<otrs_config version="1.0" init="Application">
    <CVS>$Id: SystemMonitoring.xml,v 1.20 2012/01/31 11:15:27 md Exp $</CVS>
    <ConfigItem Name="PostMaster::PreFilterModule###1-SystemMonitoring" Required="0" Valid="1">
        <Description Translatable="1">Basic mail interface to System Monitoring Suites. Use this block if the filter should run AFTER PostMasterFilter.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::PostMaster</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::PostMaster::Filter::SystemMonitoring</Item>
                <Item Key="FromAddressRegExp">nagios@example.com</Item>
                <Item Key="StateRegExp">\s*State:\s+(\S+)</Item>
                <Item Key="HostRegExp">\s*Host:\s+(.*)\s*</Item>
                <Item Key="ServiceRegExp">\s*Service:\s+(.*)\s*</Item>
                <Item Key="NewTicketRegExp">CRITICAL|DOWN</Item>
                <Item Key="CloseTicketRegExp">OK|UP</Item>
                <Item Key="CloseActionState">closed successful</Item>
                <Item Key="ClosePendingTime">172800</Item>
                <Item Key="DefaultService">Host</Item>
                <Item Key="FreeTextHost">1</Item>
                <Item Key="FreeTextService">2</Item>
                <Item Key="SenderType">system</Item>
                <Item Key="ArticleType">note-report</Item>
                <Item Key="FreeTextState">1</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="PostMaster::PreFilterModule###00-SystemMonitoring" Required="0" Valid="0">
        <Description Translatable="1">Basic mail interface to System Monitoring Suites. Use this block if the filter should run BEFORE PostMasterFilter.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::PostMaster</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::PostMaster::Filter::SystemMonitoring</Item>
                <Item Key="FromAddressRegExp">nagios@example.com</Item>
                <Item Key="StateRegExp">\s*State:\s+(\S+)</Item>
                <Item Key="HostRegExp">\s*Host:\s+(.*)\s*</Item>
                <Item Key="ServiceRegExp">\s*Service:\s+(.*)\s*</Item>
                <Item Key="NewTicketRegExp">CRITICAL|DOWN</Item>
                <Item Key="CloseTicketRegExp">OK|UP</Item>
                <Item Key="CloseActionState">closed successful</Item>
                <Item Key="ClosePendingTime">172800</Item>
                <Item Key="DefaultService">Host</Item>
                <Item Key="FreeTextHost">1</Item>
                <Item Key="FreeTextService">2</Item>
                <Item Key="SenderType">system</Item>
                <Item Key="ArticleType">note-report</Item>
                <Item Key="FreeTextState">1</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="SystemMonitoring::SetIncidentState" Required="0" Valid="1">
        <Description Translatable="1">Set the incident state of a CI automatically when a system monitoring email arrives.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::ConfigItem</SubGroup>
        <Setting>
            <Option SelectedID="0">
                <Item Key="0">No</Item>
                <Item Key="1">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="SystemMonitoring::LinkTicketWithCI" Required="0" Valid="1">
        <Description Translatable="1">Link an already opened incident ticket with the affected CI. This is only possible when a subsequent system monitoring email arrives.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::ConfigItem</SubGroup>
        <Setting>
            <Option SelectedID="0">
                <Item Key="0">No</Item>
                <Item Key="1">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::FreeField::Host" Required="1" Valid="1">
        <Description Translatable="1">Name of TicketFreeField for Host.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">TicketFreeText1</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::FreeField::Service" Required="1" Valid="1">
        <Description Translatable="1">Name of TicketFreeField for Service.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">TicketFreeText2</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::Type" Required="0" Valid="1">
        <Description Translatable="1">Define Nagios acknowledge type.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <Option SelectedID="">
                <Item Key="">-</Item>
                <Item Key="pipe">pipe</Item>
                <Item Key="http">http</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::NamedPipe::CMD" Required="0" Valid="1">
        <Description Translatable="1">Named pipe acknowledge command.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">echo '&lt;OUTPUTSTRING&gt;' > /usr/local/nagios/var/rw/nagios.cmd</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::NamedPipe::Host" Required="0" Valid="1">
        <Description Translatable="1">Named pipe acknowledge format for host.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">[&lt;UNIXTIME&gt;] ACKNOWLEDGE_HOST_PROBLEM;&lt;HOST_NAME&gt;;1;1;1;&lt;LOGIN&gt;;&lt;a href="&lt;CONFIG_HttpType&gt;://&lt;CONFIG_FQDN&gt;/&lt;CONFIG_ScriptAlias&gt;index.pl?Action=AgentTicketZoom&amp;TicketID=&lt;TicketID&gt;"&gt;&lt;CONFIG_Ticket::Hook&gt;&lt;TicketNumber&gt;&lt;/a&gt;</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::NamedPipe::Service" Required="0" Valid="1">
        <Description Translatable="1">Named pipe acknowledge format for service.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">[&lt;UNIXTIME&gt;] ACKNOWLEDGE_SVC_PROBLEM;&lt;HOST_NAME&gt;;&lt;SERVICE_NAME&gt;;1;1;1;&lt;LOGIN&gt;;&lt;a href="&lt;CONFIG_HttpType&gt;://&lt;CONFIG_FQDN&gt;/&lt;CONFIG_ScriptAlias&gt;index.pl?Action=AgentTicketZoom&amp;TicketID=&lt;TicketID&gt;"&gt;&lt;CONFIG_Ticket::Hook&gt;&lt;TicketNumber&gt;&lt;/a&gt;</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Ticket::EventModulePost###9-NagiosAcknowledge" Required="1" Valid="1">
        <Description Translatable="1">Ticket event module to send an acknowlage to Nagios.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::NagiosAcknowledge</Item>
                <Item Key="Event">TicketLockUpdate</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::HTTP::URL" Required="0" Valid="1">
        <Description Translatable="1">The http acknowledge url.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">http://nagios.example.com/nagios/cgi-bin/cmd.cgi?cmd_typ=&lt;CMD_TYP&gt;&amp;cmd_mod=2&amp;host=&lt;HOST_NAME&gt;&amp;service=&lt;SERVICE_NAME&gt;&amp;sticky_ack=on&amp;send_notification=on&amp;persistent=on&amp;com_data=&lt;TicketNumber&gt;&amp;btnSubmit=Commit</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::HTTP::User" Required="0" Valid="1">
        <Description Translatable="1">The http acknowledge user.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">John</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::HTTP::Password" Required="0" Valid="1">
        <Description Translatable="1">The http acknowledge password.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">some_pass</String>
        </Setting>
    </ConfigItem>
</otrs_config>

IyAtLQojIEtlcm5lbC9Db25maWcvTmFnaW9zQ2hlY2sucG0uZXhhbXBsZSAtIEV4YW1wbGUgQ29uZmlnZmlsZSBmb3Igb3Rycy5OYWdpb3NDaGVjayAtIE9UUlMgTmFnaW9zIGNoZWNrZXIKIyBDb3B5cmlnaHQgKEMpIDIwMDEtMjAxMiBPVFJTIEFHLCBodHRwOi8vb3Rycy5vcmcvCiMgLS0KIyAkSWQ6IE5hZ2lvc0NoZWNrLnBtLmV4YW1wbGUsdiAxLjQgMjAxMi8xMS8yMCAxOToxMjo0OSBtaCBFeHAgJAojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKIyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBBRkZFUk8gR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKIyB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgojIGFueSBsYXRlciB2ZXJzaW9uLgojCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiMgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIwojIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBBZmZlcm8gR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxIFVTQQojIG9yIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvYWdwbC50eHQuCiMgLS0KIyBGb3IgcG9zc2libGUgc2VhcmNoIG9wdGlvbnMgc2VlOgojIGh0dHA6Ly9kZXYub3Rycy5vcmcvY3ZzL0tlcm5lbC9TeXN0ZW0vVGlja2V0Lmh0bWwgLT4gVGlja2V0U2VhcmNoKCkKIyBFeGFtcGxlcyBzZWUgYmVsb3cKIyAtLQoKJUNvbmZpZyA9ICgKICAgU2VhcmNoID0+IHsKCiAgICAgICAjIHRpY2tldHMgY3JlYXRlZCBpbiB0aGUgbGFzdCAxMjAgbWludXRlcwogICAgICAgVGlja2V0Q3JlYXRlVGltZU5ld2VyTWludXRlcyA9PiAxMjAsCgogICAgICAgIyB0aWNrZXQgbnVtYmVyIGFzIFNUUklORyBvciBhcyBBUlJBWVJFRgojICAgICAgICBUaWNrZXROdW1iZXIgPT4gJyUxMjM1NDYlJywKIyAgICAgICAgVGlja2V0TnVtYmVyID0+IFsnJTEyMzU0NiUnLCAnJTEyMzY2NiUnXSwKCiAgICAgICAjIHRpY2tldCBxdWV1ZXMKIyAgICAgICAgUXVldWVzICAgPT4gWydzeXN0ZW0gcXVldWUnLCAnb3RoZXIgcXVldWUnXSwKCiAgICAgICAjIHRpY2tldCB0eXBlcwojICAgICAgICBUeXBlcyAgID0+IFsnbm9ybWFsJywgJ2NoYW5nZScsICdpbmNpZGVudCddLAoKICAgICAgICMgdGlja2V0IHByaW9yaXRpZXMKIyAgICAgICAgUHJpb3JpdGllcyAgPT4gWycxIHZlcnkgbG93JywgJzIgbG93JywgJzMgbm9ybWFsJ10sCgogICAgICAgIyB0aWNrZXQgc2VydmljZXMKIyAgICAgICAgU2VydmljZXMgICA9PiBbJ1NlcnZpY2UgQScsICdTZXJ2aWNlIEInXSwKCiAgICAgICAjIHRpY2tldCBsb2NrcwojICAgICAgICBMb2NrcyAgID0+IFsndW5sb2NrJ10sCgogICAgICAgIyB0aWNrZXQgY3VzdG9tZXJzCiMgICAgICAgIEN1c3RvbWVySUQgPT4gJzEyMycsCiMgICAgICAgIEN1c3RvbWVySUQgPT4gWycxMjMnLCAnQUJDJ10sCgogICAgICAgIyAxLi4xNiBmcmVlIHRleHQgZmllbGRzCiMgICAgICAgIFRpY2tldEZyZWVLZXkxICA9PiAnUHJvZHVjdCcsCiMgICAgICAgIFRpY2tldEZyZWVUZXh0MSA9PiAnYWRhc2QnLAoKICAgICAgICMgb3Igd2l0aCBtdWx0aSBvcHRpb25zIGFzIGFycmF5IHJlZiBvciBzdHJpbmcgcG9zc2libGUKIyAgICAgICAgVGlja2V0RnJlZUtleTIgID0+IFsnUHJvZHVjdCcsICdQcm9kdWN0MiddLAojICAgICAgICBUaWNrZXRGcmVlVGV4dDIgPT4gWydCcm93c2VyJywgJ1NvdW5kJywgJ01vdXNlJ10sCiAgIH0sCgojIERlY2xhcmF0aW9uIG9mIHRyZXNob2xkcwojIG1pbl93YXJuX3RyZXNob2xkID4gTnVtYmVyIG9mIHRpY2tldHMgLT4gV0FSTklORwojIG1heF93YXJuX3RyZXNob2xkIDwgTnVtYmVyIG9mIHRpY2tldHMgLT4gV0FSTklORwojIG1pbl9jcml0X3RyZXNob2xkID4gTnVtYmVyIG9mIHRpY2tldHMgLT4gQUxBUk0KIyBtYXhfd2Fybl90cmVzaG9sZCA8IE51bWJlciBvZiB0aWNrZXRzIC0+IEFMQVJNCgogICBtaW5fd2Fybl90cmVzaG9sZCA9PiA1LAogICBtYXhfd2Fybl90cmVzaG9sZCA9PiAxMCwKICAgbWluX2NyaXRfdHJlc2hvbGQgPT4gMiwKICAgbWF4X2NyaXRfdHJlc2hvbGQgPT4gMjAsCgojIEluZm9ybWF0aW9uIHVzZWQgYnkgTmFnaW9zCiMgTmFtZSBvZiBjaGVjayBzaG93biBpbiBOYWdpb3MgU3RhdHVzIEluZm9ybWF0aW9uCiAgIGNoZWNrbmFtZSA9PiAnT1RSUyBDaGVja2VyJywKCiMgVGV4dCBzaG93biBpbiBTdGF0dXMgSW5mb3JtYXRpb24gaWYgZXZlcnl0aGluZyBpcyBvawogICBPS19UWFQgICAgPT4gJ2Vuam95ICAgdGlja2V0czonLAoKIyBUZXh0IHNob3duIGluIFN0YXR1cyBJbmZvcm1hdGlvbiBpZiB3YXJuaW5nIHRocmVzaGhvbGQgcmVhY2hlZAogICBXQVJOX1RYVCAgPT4gJ251bWJlciBvZiB0aWNrZXRzOicsCgojIFRleHQgc2hvd24gaW4gU3RhdHVzIEluZm9ybWF0aW9uIGlmIGNyaXRpY2FsIHRocmVzaGhvbGQgcmVhY2hlZAogICBDUklUX1RYVCAgPT4gJ2NyaXRpY2FsIG51bWJlciBvZiB0aWNrZXRzOicsCgopOwoK
# --
# Kernel/System/PostMaster/Filter/SystemMonitoring.pm - Basic System Monitoring Interface
# Copyright (C) 2001-2013 OTRS AG, http://otrs.org/
# --
# $Id: SystemMonitoring.pm,v 1.19 2013/05/28 12:10:59 rs Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

# important configuration items SystemMonitoring::SetIncidentState

package Kernel::System::PostMaster::Filter::SystemMonitoring;

use strict;
use warnings;

use Kernel::System::LinkObject;
use Kernel::System::DynamicField;
use Kernel::System::VariableCheck qw(:all);

use vars qw($VERSION);
$VERSION = qw($Revision: 1.19 $) [1];

#the base name for dynamic fields

use constant DynamicFieldTicketTextPrefix  => 'TicketFreeText';
use constant DynamicFieldArticleTextPrefix => 'ArticleFreeText';

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {};
    bless( $Self, $Type );

    $Self->{Debug} = $Param{Debug} || 0;

    # get needed objects
    for my $Object (
        qw(DBObject ConfigObject LogObject MainObject EncodeObject TicketObject TimeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    # create additional objects
    $Self->{LinkObject}         = Kernel::System::LinkObject->new( %{$Self} );
    $Self->{DynamicFieldObject} = Kernel::System::DynamicField->new( %{$Self} );

    # check if CI incident state should be set automatically
    # this requires the ITSMConfigurationManagement module to be installed
    if ( $Self->{ConfigObject}->Get('SystemMonitoring::SetIncidentState') ) {

        $Self->_IncidentStateNew();
    }

    # Default Settings
    $Self->{Config} = {
        StateRegExp       => '\s*State:\s+(\S+)',
        FromAddressRegExp => 'sysmon@example.com',
        NewTicketRegExp   => 'CRITICAL|DOWN',
        CloseTicketRegExp => 'OK|UP',
        CloseActionState  => 'closed successful',
        ClosePendingTime  => 60 * 60 * 24 * 2,                          # 2 days
        HostRegExp        => '\s*Address:\s+(\d+\.\d+\.\d+\.\d+)\s*',
        FreeTextHost      => '1',
        FreeTextService   => '2',
        FreeTextState     => '1',
        ServiceRegExp     => '\s*Service:\s+(.*)\s*',
        DefaultService    => 'Host',
        SenderType        => 'system',
        ArticleType       => 'note-report',
    };

    return $Self;
}

sub _GetDynamicFieldDefinition {
    my $Self       = shift;
    my $Config     = shift;
    my $Key        = shift;    #FreeTextHost the config key
    my $Default    = shift;    #1 the default value
    my $Base       = shift;    # DynamicFieldTicketTextPrefix
    my $Name       = shift;    #HostName
    my $ObjectType = shift;    #HostName

    my $ConfigFreeText = $Config->{$Key};

    if ( !$ConfigFreeText ) {
        $ConfigFreeText = $Default;
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Missing CI Config $Key, using value $Default!"
        );
    }

    if ( $ConfigFreeText =~ /^\d+$/ ) {
        if ( ( $ConfigFreeText < 1 ) || ( $ConfigFreeText > 16 ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message => "Bad value $ConfigFreeText for CI Config $Key, must be between 1 and 16!"
            );
            die "Bad value $ConfigFreeText for CI Config $Key!";
        }
    }
    else
    {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Bad value $ConfigFreeText for CI Config $Key, must be numeric!"
        );
        die "Bad value $ConfigFreeText for CI Config $Key!";
    }

    my $FieldNameHost = $Base . $ConfigFreeText;

# define all dynamic fields for System Monitoring, these need to be changed as well if the config changes
    return (
        {
            Name       => $FieldNameHost,
            Label      => 'SystemMonitoring ' . $Name,
            FieldType  => 'Text',
            ObjectType => $ObjectType,
            Config     => {
                TranslatableValues => 1,
            },
        }
    );
}

sub GetDynamicFieldsDefinition {
    my $class  = shift;
    my $Self   = shift;
    my %Param  = @_;
    my $Config = $Param{Config};

    push @{ $Param{NewFields} },
        _GetDynamicFieldDefinition(
        $Self, $Config, "FreeTextHost", 1, DynamicFieldTicketTextPrefix,
        "HostName", "Ticket"
        );
    push @{ $Param{NewFields} },
        _GetDynamicFieldDefinition(
        $Self, $Config, "FreeTextService", 2,
        DynamicFieldTicketTextPrefix, "ServiceName", "Ticket"
        );
    push @{ $Param{NewFields} },
        _GetDynamicFieldDefinition(
        $Self, $Config, "FreeTextState", 1,
        DynamicFieldArticleTextPrefix, "StateName", "Article"
        );

    return 1;
}

sub _IncidentStateIncident {
    my $Self = shift || die "missing self";

    # set the CI incident state to 'Incident'
    $Self->_SetIncidentState(
        Name          => $Self->{Host},
        IncidentState => 'Incident',
    );

}

sub _IncidentStateOperational {
    my $Self = shift || die "missing self";

    # set the CI incident state to 'Operational'
    $Self->_SetIncidentState(
        Name          => $Self->{Host},
        IncidentState => 'Operational',
    );
}

# these are optional modules from the ITSM Kernel::System::GeneralCatalog and Kernel::System::ITSMConfigItem

sub _IncidentStateNew {
    my $Self = shift || die "missing self";

    # require the general catalog module
    if ( $Self->{MainObject}->Require('Kernel::System::GeneralCatalog') ) {

        # create general catalog object
        $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );
    }

    # require the config item module
    if ( $Self->{MainObject}->Require('Kernel::System::ITSMConfigItem') ) {

        # create config item object
        $Self->{ConfigItemObject} = Kernel::System::ITSMConfigItem->new( %{$Self} );
    }
}

sub _MailParse {
    my $Self = shift || die "missing self";
    my %Param = @_;

    my $Subject = $Param{GetParam}->{Subject} || die "No Param Subject";

    # Try to get State, Host and Service from email subject
    my @SubjectLines = split /\n/, $Subject;
    for my $Line (@SubjectLines) {
        for (qw(State Host Service)) {
            if ( $Line =~ /$Self->{Config}->{ $_ . 'RegExp' }/ ) {
                $Self->{$_} = $1;
            }
        }
    }

    #  Dont Try to get State, Host and Service from email body, we want it from the subject alone

    # split the body into separate lines
    my $Body = $Param{GetParam}->{Body} || die "Message has no Body";

    my @BodyLines = split /\n/, $Body;

    # to remember if an element was found before
    my %AlreadyMatched;

    LINE:
    for my $Line (@BodyLines) {

        # Try to get State, Host and Service from email body
        ELEMENT:
        for my $Element (qw(State Host Service)) {

            next ELEMENT if $AlreadyMatched{$Element};

            my $Regex = $Self->{Config}->{ $Element . 'RegExp' };

            if ( $Line =~ /$Regex/ ) {

                # get the found element value
                $Self->{$Element} = $1;

                # remember that we found this element already
                $AlreadyMatched{$Element} = 1;
            }
        }
    }
}

sub _LogMessage {
    my $Self        = shift;
    my $MessageText = shift;

    # logging
    # define log message
    $Self->{Service} ||= "No Service";
    $Self->{State}   ||= "No State";
    $Self->{Host}    ||= "No Host";

    my $LogMessage = $MessageText . " - "
        . "Host: $Self->{Host}, "
        . "State: $Self->{State}, "
        . "Service: $Self->{Service}";

    $Self->{LogObject}->Log(
        Priority => 'notice',
        Message  => 'SystemMonitoring Mail: ' . $LogMessage,
    );
}

sub _TicketSearch {
    my $Self = shift || die "missing self";

    # Is there a ticket for this Host/Service pair?
    my %Query = (
        Result    => 'ARRAY',
        Limit     => 1,
        UserID    => 1,
        StateType => 'Open',
    );

    for my $Type (qw(Host Service)) {
        my $FreeTextField = $Self->{Config}->{ 'FreeText' . $Type };
        my $KeyName       = "DynamicField_" . DynamicFieldTicketTextPrefix . $FreeTextField;
        my $KeyValue      = $Self->{$Type};

        $Query{$KeyName}->{Equals} = $KeyValue;
    }

    # Check if dynamic fields really exists.
    # If dynamic fields don't exists, TicketSearch will return all tickets
    # and then the new article/ticket could take wrong place.
    # The lesser of the three evils is to create a new ticket
    # instead of defacing existing tickets or dropping it.
    # This behaviour will come true if the dynamic fields
    # are named like TicketFreeTextHost. Its also bad.
    my $Errors = 0;
    for my $Type (qw(Host Service)) {
        my $FreeTextField = $Self->{Config}->{ 'FreeText' . $Type };

        my $DynamicField = $Self->{DynamicFieldObject}->DynamicFieldGet(
            'Name' => DynamicFieldTicketTextPrefix . $FreeTextField,
        );

        if ( !IsHashRefWithData($DynamicField) || $FreeTextField !~ m{\d+}xms ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "DynamicField "
                    . DynamicFieldTicketTextPrefix
                    . $FreeTextField
                    . " does not exists or missnamed."
                    . " The configuration is based on freetext fields, so the number of the freetext field is expected"
                    . " (wrong value for key FreeText" . $Type . " is set).",
            );
            $Errors = 1;
        }
    }

    my $ArticleFreeTextField = $Self->{Config}->{'FreeTextState'};
    my $DynamicFieldArticle  = $Self->{DynamicFieldObject}->DynamicFieldGet(
        'Name' => DynamicFieldArticleTextPrefix . $ArticleFreeTextField,
    );

    if ( !IsHashRefWithData($DynamicFieldArticle) || $ArticleFreeTextField !~ m{\d+}xms ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "DynamicField "
                . DynamicFieldArticleTextPrefix
                . $ArticleFreeTextField
                . " does not exists or missnamed."
                . " The configuration is based on freetext fields, so the number of the freetext field is expected"
                . " (wrong value for key FreeTextState is set).",
        );
        $Errors = 1;
    }

    my @TicketIDs = $Self->{TicketObject}->TicketSearch(%Query);

    # get the first and only ticket id
    my $TicketID;
    if ( !$Errors && @TicketIDs ) {
        $TicketID = shift @TicketIDs;
    }

    return $TicketID;

}

# the sub takes the param as a hashref not as a copy, because it is updated

sub _TicketUpdate {
    my $Self     = shift || die "missing self";
    my $TicketID = shift || die "missing ticketid";
    my $Param    = shift || die "missing param hashref";

    # get ticket number
    my $TicketNumber = $Self->{TicketObject}->TicketNumberLookup(
        TicketID => $TicketID,
        UserID   => 1,
    );

    # build subject
    $Param->{GetParam}->{Subject} = $Self->{TicketObject}->TicketSubjectBuild(
        TicketNumber => $TicketNumber,
        Subject      => $Param->{GetParam}->{Subject},
    );

    # set sender type and article type
    $Param->{GetParam}->{'X-OTRS-FollowUp-SenderType'}  = $Self->{Config}->{SenderType};
    $Param->{GetParam}->{'X-OTRS-FollowUp-ArticleType'} = $Self->{Config}->{ArticleType};

    # Set Article Free Field for State
    my $ArticleFreeTextNumber = $Self->{Config}->{'FreeTextState'};
    $Param->{GetParam}->{ 'X-OTRS-FollowUp-ArticleKey' . $ArticleFreeTextNumber } = 'State';
    $Param->{GetParam}->{ 'X-OTRS-FollowUp-ArticleValue' . $ArticleFreeTextNumber }
        = $Self->{State};

    if ( $Self->{State} =~ /$Self->{Config}->{CloseTicketRegExp}/ ) {

        # Close Ticket Condition -> Take Close Action
        if ( $Self->{Config}->{CloseActionState} ne 'OLD' ) {
            $Param->{GetParam}->{'X-OTRS-FollowUp-State'} = $Self->{Config}->{CloseActionState};

            my $TimeStamp = $Self->{TimeObject}->SystemTime2TimeStamp(
                SystemTime => $Self->{TimeObject}->SystemTime()
                    + $Self->{Config}->{ClosePendingTime},
            );
            $Param->{GetParam}->{'X-OTRS-State-PendingTime'} = $TimeStamp;
        }

        # set log message
        $Self->_LogMessage('Recovered');

        # if the CI incident state should be set
        if ( $Self->{ConfigObject}->Get('SystemMonitoring::SetIncidentState') ) {
            $Self->_IncidentStateOperational();
        }
    }
    else {

        # Attach note to existing ticket
        $Self->_LogMessage('New Notice');
    }

    # link ticket with CI, this is only possible if the ticket already exists,
    # e.g. in a subsequent email request, because we need a ticket id
    if ( $Self->{ConfigObject}->Get('SystemMonitoring::LinkTicketWithCI') ) {

        # link ticket with CI
        $Self->_LinkTicketWithCI(
            Name     => $Self->{Host},
            TicketID => $TicketID,
        );
    }
}

# the sub takes the param as a hashref not as a copy, because it is updated

sub _TicketCreate
{
    my $Self  = shift || die "missing self";
    my $Param = shift || die "missing param hashref";

    # Create Ticket Condition -> Create new Ticket and record Host and Service
    for (qw(Host Service)) {

        # get the freetext number from config
        my $TicketFreeTextNumber = $Self->{Config}->{ 'FreeText' . $_ };

        # see the Kernel::System::PostMaster::NewTicket  where this is read
        $Param->{GetParam}->{ 'X-OTRS-TicketKey' . $TicketFreeTextNumber }   = $_;
        $Param->{GetParam}->{ 'X-OTRS-TicketValue' . $TicketFreeTextNumber } = $Self->{$_};
    }

    # Set Article Free Field for State
    my $ArticleFreeTextNumber = $Self->{Config}->{'FreeTextState'};
    $Param->{GetParam}->{ 'X-OTRS-ArticleKey' . $ArticleFreeTextNumber }   = 'State';
    $Param->{GetParam}->{ 'X-OTRS-ArticleValue' . $ArticleFreeTextNumber } = $Self->{State};

    # set sender type and article type
    $Param->{GetParam}->{'X-OTRS-SenderType'}  = $Self->{Config}->{SenderType};
    $Param->{GetParam}->{'X-OTRS-ArticleType'} = $Self->{Config}->{ArticleType};

    # set log message
    $Self->_LogMessage('New Ticket');

    # if the CI incident state should be set
    if ( $Self->{ConfigObject}->Get('SystemMonitoring::SetIncidentState') ) {
        $Self->_IncidentStateIncident();
    }
}

# the sub takes the param as a hashref not as a copy, because it is updated

sub _TicketDrop {
    my $Self  = shift || die "missing self";
    my $Param = shift || die "missing param hashref";

    # No existing ticket and no open condition -> drop silently
    $Param->{GetParam}->{'X-OTRS-Ignore'} = 'yes';
    $Self->_LogMessage('Mail Dropped, no matching ticket found, no open on this state ');

}

sub Run {

    my ( $Self, %Param ) = @_;

    # get config options, use defaults unless value specified
    if ( $Param{JobConfig} && ref $Param{JobConfig} eq 'HASH' ) {
        KEY:
        for my $Key ( keys( %{ $Param{JobConfig} } ) ) {
            next KEY if !$Self->{Config}->{$Key};
            $Self->{Config}->{$Key} = $Param{JobConfig}->{$Key};
        }
    }

    # check if sender is of interest
    return 1 if !$Param{GetParam}->{From};
    return 1 if $Param{GetParam}->{From} !~ /$Self->{Config}->{FromAddressRegExp}/i;

    $Self->_MailParse(%Param);

    # we need State and Host to proceed
    if ( !$Self->{State} || !$Self->{Host} ) {

        $Self->{LogObject}->Log(
            Priority => 'notice',
            Message  => 'SystemMonitoring Mail: '
                . 'SystemMonitoring: Could not find host address '
                . 'and/or state in mail => Ignoring',
        );
        return 1;
    }

    # Check for Service
    $Self->{Service} ||= $Self->{Config}->{DefaultService};

    my $TicketID = $Self->_TicketSearch();

    # OK, found ticket to deal with
    if ($TicketID) {
        $Self->_TicketUpdate( $TicketID, \%Param );
    }
    elsif ( $Self->{State} =~ /$Self->{Config}->{NewTicketRegExp}/ ) {
        $Self->_TicketCreate( \%Param );
    }
    else {
        $Self->_TicketDrop( \%Param );
    }

    return 1;
}

sub _SetIncidentState {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(Name IncidentState )) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # check configitem object
    return if !$Self->{ConfigItemObject};

    # search configitem
    my $ConfigItemIDs = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
        Name => $Param{Name},
    );

    # if no config item with this name was found
    if ( !$ConfigItemIDs || ref $ConfigItemIDs ne 'ARRAY' || !@{$ConfigItemIDs} ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not find any CI with the name '$Param{Name}'. ",
        );
        return;
    }

    # if more than one config item with this name was found
    if ( scalar @{$ConfigItemIDs} > 1 ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can not set incident state for CI with the name '$Param{Name}'. "
                . "More than one CI with this name was found!",
        );
        return;
    }

    # we only found one config item
    my $ConfigItemID = shift @{$ConfigItemIDs};

    # get config item
    my $ConfigItem = $Self->{ConfigItemObject}->ConfigItemGet(
        ConfigItemID => $ConfigItemID,
    );

    # get latest version data of config item
    my $Version = $Self->{ConfigItemObject}->VersionGet(
        ConfigItemID => $ConfigItemID,
    );

    return if !$Version;
    return if ref $Version ne 'HASH';

    # get incident state list
    my $InciStateList = $Self->{GeneralCatalogObject}->ItemList(
        Class => 'ITSM::Core::IncidentState',
    );

    return if !$InciStateList;
    return if ref $InciStateList ne 'HASH';

    # reverse the incident state list
    my %ReverseInciStateList = reverse %{$InciStateList};

    # check if incident state is valid
    if ( !$ReverseInciStateList{ $Param{IncidentState} } ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Invalid incident state '$Param{IncidentState}'!",
        );
        return;
    }

    # add a new version with the new incident state
    my $VersionID = $Self->{ConfigItemObject}->VersionAdd(
        %{$Version},
        InciStateID => $ReverseInciStateList{ $Param{IncidentState} },
        UserID      => 1,
    );

    return $VersionID;
}

sub _LinkTicketWithCI {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Argument (qw(Name TicketID )) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # check configitem object
    return if !$Self->{ConfigItemObject};

    # search configitem
    my $ConfigItemIDs = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
        Name => $Param{Name},
    );

    # if no config item with this name was found
    if ( !$ConfigItemIDs || ref $ConfigItemIDs ne 'ARRAY' || !@{$ConfigItemIDs} ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not find any CI with the name '$Param{Name}'. ",
        );
        return;
    }

    # if more than one config item with this name was found
    if ( scalar @{$ConfigItemIDs} > 1 ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can not set incident state for CI with the name '$Param{Name}'. "
                . "More than one CI with this name was found!",
        );
        return;
    }

    # we only found one config item
    my $ConfigItemID = shift @{$ConfigItemIDs};

    # link the ticket with the CI
    my $LinkResult = $Self->{LinkObject}->LinkAdd(
        SourceObject => 'Ticket',
        SourceKey    => $Param{TicketID},
        TargetObject => 'ITSMConfigItem',
        TargetKey    => $ConfigItemID,
        Type         => 'RelevantTo',
        State        => 'Valid',
        UserID       => 1,
    );

    return $LinkResult;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.

=cut

=head1 VERSION

$Revision: 1.19 $ $Date: 2013/05/28 12:10:59 $

=cut

# --
# Kernel/System/Ticket/Event/NagiosAcknowledge.pm - acknowlege nagios tickets
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: NagiosAcknowledge.pm,v 1.13 2012/11/23 15:28:00 cg Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::System::Ticket::Event::NagiosAcknowledge;

use strict;
use warnings;
use LWP::UserAgent;
use URI::Escape qw();

use vars qw($VERSION);
$VERSION = qw($Revision: 1.13 $) [1];

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {};
    bless( $Self, $Type );

    # get needed objects
    for (
        qw(ConfigObject TicketObject LogObject UserObject CustomerUserObject SendmailObject TimeObject EncodeObject UserObject)
        )
    {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    # get correct FreeFields
    $Self->{Fhost}    = $Self->{ConfigObject}->Get('Nagios::Acknowledge::FreeField::Host');
    $Self->{Fservice} = $Self->{ConfigObject}->Get('Nagios::Acknowledge::FreeField::Service');

    return $Self;
}

sub Run {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for (qw(Data Event Config)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }

    if ( !$Param{Data}->{TicketID} ) {
        $Self->{LogObject}->Log( Priority => 'error', Message => "Need Data->{TicketID}!" );
        return;
    }

    # check if acknowledge is active
    my $Type = $Self->{ConfigObject}->Get('Nagios::Acknowledge::Type');
    return 1 if !$Type;

    # check if it's a Nagios related ticket
    my %Ticket = $Self->{TicketObject}->TicketGet(
        TicketID      => $Param{Data}->{TicketID},
        DynamicFields => 1,
    );
    if ( !$Ticket{ $Self->{Fhost} } ) {
        $Self->{LogObject}->Log( Priority => 'debug', Message => "No Nagios Ticket!" );
        return 1;
    }

    # check if it's an acknowledge
    return 1 if $Ticket{Lock} ne 'lock';

    # agent lookup
    my %User = $Self->{UserObject}->GetUserData(
        UserID => $Param{UserID},
        Cached => 1,                # not required -> 0|1 (default 0)
    );

    my $Return;
    if ( $Type eq 'pipe' ) {
        $Return = $Self->_Pipe(
            Ticket => \%Ticket,
            User   => \%User,
        );
    }
    elsif ( $Type eq 'http' ) {
        $Return = $Self->_HTTP(
            Ticket => \%Ticket,
            User   => \%User,
        );
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Unknown Nagios acknowledge type ($Type)!",
        );
        return 1;
    }

    if ($Return) {
        $Self->{TicketObject}->HistoryAdd(
            TicketID     => $Param{Data}->{TicketID},
            HistoryType  => 'Misc',
            Name         => "Sent Acknowledge to Nagios ($Type).",
            CreateUserID => $Param{UserID},
        );
        return 1;
    }
    else {
        $Self->{TicketObject}->HistoryAdd(
            TicketID     => $Param{Data}->{TicketID},
            HistoryType  => 'Misc',
            Name         => "Was not able to send Acknowledge to Nagios ($Type)!",
            CreateUserID => $Param{UserID},
        );
        return;
    }
}

sub _Pipe {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for (qw(Ticket User)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }
    my %Ticket = %{ $Param{Ticket} };
    my %User   = %{ $Param{User} };

    # send acknowledge to nagios
    my $CMD = $Self->{ConfigObject}->Get('Nagios::Acknowledge::NamedPipe::CMD');
    my $Data;
    if ( $Ticket{ $Self->{Fservice} } !~ /^host$/i ) {
        $Data = $Self->{ConfigObject}->Get('Nagios::Acknowledge::NamedPipe::Service');
    }
    else {
        $Data = $Self->{ConfigObject}->Get('Nagios::Acknowledge::NamedPipe::Host');
    }

    # replace ticket tags
    for my $Key ( keys %Ticket ) {
        next if !defined $Ticket{$Key};

        # strip not allowed characters
        $Ticket{$Key} =~ s/'//g;
        $Ticket{$Key} =~ s/;//g;
        $Data         =~ s/<$Key>/$Ticket{$Key}/g;
    }

    # replace config tags
    $Data =~ s{<CONFIG_(.+?)>}{$Self->{ConfigObject}->Get($1)}egx;

    # replace login
    $Data =~ s/<LOGIN>/$User{UserLogin}/g;

    # replace host
    $Data =~ s/<HOST_NAME>/$Ticket{$Self->{Fhost}}/g;

    # replace time stamp
    $Data =~ s/<SERVICE_NAME>/$Ticket{$Self->{Fservice}}/g;

    # replace time stamp
    my $Time = time();
    $Data =~ s/<UNIXTIME>/$Time/g;

    # replace OUTPUTSTRING
    $CMD =~ s/<OUTPUTSTRING>/$Data/g;

    #print STDOUT "$CMD\n";
    system($CMD );

    return 1;
}

sub _HTTP {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for (qw(Ticket User)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "Need $_!" );
            return;
        }
    }
    my %Ticket = %{ $Param{Ticket} };
    my %User   = %{ $Param{User} };

    my $URL  = $Self->{ConfigObject}->Get('Nagios::Acknowledge::HTTP::URL');
    my $User = $Self->{ConfigObject}->Get('Nagios::Acknowledge::HTTP::User');
    my $Pw   = $Self->{ConfigObject}->Get('Nagios::Acknowledge::HTTP::Password');

    if ( $Ticket{ $Self->{Fservice} } !~ /^host$/i ) {
        $URL =~ s/<CMD_TYP>/34/g;
    }
    else {
        $URL =~ s/<CMD_TYP>/33/g;
    }

    # replace host
    $URL =~ s/<HOST_NAME>/$Ticket{$Self->{Fhost}}/g;

    # replace time stamp
    $URL =~ s/<SERVICE_NAME>/$Ticket{$Self->{Fservice}}/g;

    # replace ticket tags

    for my $Key ( keys %Ticket ) {
        next if !defined $Ticket{$Key};

        # URLencode values
        $Ticket{$Key} = URI::Escape::uri_escape_utf8( $Ticket{$Key} );
        $URL =~ s/<$Key>/$Ticket{$Key}/g;
    }

    # replace config tags
    $URL =~ s{<CONFIG_(.+?)>}{$Self->{ConfigObject}->Get($1)}egx;

    my $UserAgent = LWP::UserAgent->new();
    $UserAgent->timeout(15);

    my $Request = HTTP::Request->new( GET => $URL );
    $Request->authorization_basic( $User, $Pw );
    my $Response = $UserAgent->request($Request);
    if ( !$Response->is_success() ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't request $URL: " . $Response->status_line(),
        );
        return;
    }

    #    return $Response->content();

    return 1;
}
1;

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
UmV0dXJuLVBhdGg6IDxuYWdpb3NAZXhhbXBsZS5jb20+ClRvOiBvdHJzQGV4YW1wbGUuY29tClN1YmplY3Q6ICoqIFBST0JMRU0gYWxlcnQgMSAtIGRlbHBoaW4gaG9zdCBpcyBET1dOICoqCk1lc3NhZ2UtSWQ6IDwyMDA3MDMxNzIzMTU0Ni4wREZENTVEQzAwRkBoNTM3OTUuZXhhbXBsZS5jb20+CkRhdGU6IFN1biwgMTggTWFyIDIwMDcgMDA6MTU6NDYgKzAxMDAgKENFVCkKRnJvbTogbmFnaW9zQGV4YW1wbGUuY29tCk1pbWUtVmVyc2lvbjogMS4wCgoqKioqKiBOYWdpb3MgICoqKioqCgpOb3RpZmljYXRpb24gVHlwZTogUFJPQkxFTQpIb3N0OiBkZWxwaGluClN0YXRlOiBET1dOIGZvciAwZCAwaCAwbSAwcwpBZGRyZXNzOiAxMjcuMS4xLjEKSW5mbzoKCkNSSVRJQ0FMIC0gVGltZSB0byBsaXZlIGV4Y2VlZGVkICgxMjcuMS4xLjEpCgpEYXRlL1RpbWU6IFN1biBNYXIgMTggMDA6MTg6MzAgQ0VUIDIwMDcKCkFDSyBieTogCkNvbW1lbnQ6CiAKCgo=
UmV0dXJuLVBhdGg6IDxuYWdpb3NAZXhhbXBsZS5jb20+ClRvOiBvdHJzQGV4YW1wbGUuY29tClN1YmplY3Q6ICoqIFJFQ09WRVJZIGFsZXJ0IDIgLSBkZWxwaGluIGhvc3QgaXMgVVAgKioKTWVzc2FnZS1JZDogPDIwMDcwMzE3MjMxOTQ2LjBERkQ1NURDMDBGQGg1Mzc5NS5leGFtcGxlLmNvbT4KRGF0ZTogU3VuLCAxOCBNYXIgMjAwNyAwMDoxOTo0NiArMDEwMCAoQ0VUKQpGcm9tOiBuYWdpb3NAZXhhbXBsZS5jb20KTWltZS1WZXJzaW9uOiAxLjAKCioqKioqIE5hZ2lvcyAgKioqKioKCk5vdGlmaWNhdGlvbiBUeXBlOiBSRUNPVkVSWQpIb3N0OiBkZWxwaGluClN0YXRlOiBVUCBmb3IgMGQgMGggMG0gMHMKQWRkcmVzczogMTcyLjEuMS4xCkluZm86CgpQSU5HIE9LIC0gUGFja2V0IGxvc3MgPSAwJSwgUlRBID0gMTUuMDkgbXMKCkRhdGUvVGltZTogU3VuIE1hciAxOCAwMDoxOTo0NiBDRVQgMjAwNwoKQUNLIGJ5OiAKQ29tbWVudDogCg==
# --
# SystemMonitoring.pm - code to excecute during package installation
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: SystemMonitoring.pm,v 1.6 2012/02/02 15:59:27 mh Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package var::packagesetup::SystemMonitoring;

use strict;
use warnings;

use Kernel::Config;
use Kernel::System::SysConfig;
use Kernel::System::Type;
use Kernel::System::Valid;
use Kernel::System::DynamicField;

use vars qw(@ISA $VERSION);
use YAML;

$VERSION = qw($Revision: 1.6 $) [1];

=head1 NAME

SystemMonitoring.pm - code to excecute during package installation

=head1 SYNOPSIS

All functions

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Encode;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::Time;
    use Kernel::System::DB;
    use Kernel::System::XML;
    use var::packagesetup::SystemMonitoring;

    my $ConfigObject = Kernel::Config->new();
    my $EncodeObject = Kernel::System::Encode->new(
        ConfigObject => $ConfigObject,
    );
    my $LogObject    = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
    );
    my $TimeObject = Kernel::System::Time->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $XMLObject = Kernel::System::XML->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
        MainObject   => $MainObject,
    );
    my $CodeObject = var::packagesetup::SystemMonitoring->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
        TimeObject   => $TimeObject,
        DBObject     => $DBObject,
        XMLObject    => $XMLObject,
    );

=cut

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {};
    bless( $Self, $Type );

    # check needed objects
    for my $Object (
        qw(ConfigObject EncodeObject LogObject MainObject TimeObject DBObject XMLObject)
        )
    {
        $Self->{$Object} = $Param{$Object} ||
            $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Missing parameter for $Object!"
            );
    }

    # create needed sysconfig object
    $Self->{SysConfigObject} = Kernel::System::SysConfig->new( %{$Self} );

    # rebuild ZZZ* files
    $Self->{SysConfigObject}->WriteDefault();

    # define the ZZZ files
    my @ZZZFiles = (
        'ZZZAAuto.pm',
        'ZZZAuto.pm',
    );

    # reload the ZZZ files (mod_perl workaround)
    for my $ZZZFile (@ZZZFiles) {

        PREFIX:
        for my $Prefix (@INC) {
            my $File = $Prefix . '/Kernel/Config/Files/' . $ZZZFile;
            next PREFIX if !-f $File;

            do $File;
            last PREFIX;
        }
    }

    # create needed objects? again?
    $Self->{ConfigObject} = Kernel::Config->new();

    $Self->{TypeObject}         = Kernel::System::Type->new( %{$Self} );
    $Self->{ValidObject}        = Kernel::System::Valid->new( %{$Self} );
    $Self->{DynamicFieldObject} = Kernel::System::DynamicField->new( %{$Self} );

    return $Self;
}

=item CodeInstall()

run the code install part

    my $Result = $CodeObject->CodeInstall();

=cut

sub CodeInstall {
    my ( $Self, %Param ) = @_;

    $Self->_CreateDynamicFields();

    return 1;
}

=item CodeReinstall()

run the code reinstall part

    my $Result = $CodeObject->CodeReinstall();

=cut

sub CodeReinstall {
    my ( $Self, %Param ) = @_;

    return 1;
}

=item CodeUpgrade()

run the code upgrade part

    my $Result = $CodeObject->CodeUpgrade();

=cut

sub CodeUpgrade {
    my ( $Self, %Param ) = @_;

    return 1;
}

=item CodeUpgradeFromLowerThan_2_2_92()

This function is only executed if the installed module version is smaller than 2.2.92.

my $Result = $CodeObject->CodeUpgradeFromLowerThan_2_2_92();

=cut

sub CodeUpgradeFromLowerThan_2_2_92 {
    my ( $Self, %Param ) = @_;

    # get the definition for all dynamic fields for SystemMonitoring
    my @DynamicFields = $Self->_GetDynamicFieldsDefinition();

    # clean up the migrated freetext and freetime fields
    # e.g. delete the possible values for fields that use the general catalog
    DYNAMICFIELD:
    for my $DynamicFieldNew (@DynamicFields) {

        # get existing dynamic field data
        my $DynamicFieldOld = $Self->{DynamicFieldObject}->DynamicFieldGet(
            Name => $DynamicFieldNew->{Name},
        );

        if ( not exists( $DynamicFieldOld->{ID} ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "The old Field does not exist $DynamicFieldNew->{Name}, skipping."
            );
            next;
        }

        # update the dynamic field
        my $Success = $Self->{DynamicFieldObject}->DynamicFieldUpdate(
            ID         => $DynamicFieldOld->{ID},
            FieldOrder => $DynamicFieldOld->{FieldOrder},
            Name       => $DynamicFieldNew->{Name},
            Label      => $DynamicFieldNew->{Label},
            FieldType  => $DynamicFieldNew->{FieldType},
            ObjectType => $DynamicFieldNew->{ObjectType},
            Config     => $DynamicFieldNew->{Config},
            ValidID    => 1,
            Reorder    => 0,
            UserID     => 1,
        );
    }

    return 1;
}

=item CodeUninstall()

run the code uninstall part

    my $Result = $CodeObject->CodeUninstall();

=cut

sub CodeUninstall {
    my ( $Self, %Param ) = @_;

    return 1;
}

=item _CreateDynamicFields()

creates all dynamic fields that are necessary for SystemMonitoring

    my $Result = $CodeObject->_CreateDynamicFields();

=cut

sub _CreateDynamicFields {
    my ( $Self, %Param ) = @_;

    my $ValidID = $Self->{ValidObject}->ValidLookup(
        Valid => 'valid',
    );

    # get all current dynamic fields
    my $DynamicFieldList = $Self->{DynamicFieldObject}->DynamicFieldListGet(
        Valid => 0,
    );

    # get the list of order numbers (is already sorted).
    my @DynamicfieldOrderList;
    for my $Dynamicfield ( @{$DynamicFieldList} ) {
        push @DynamicfieldOrderList, $Dynamicfield->{FieldOrder};
    }

    # get the last element from the order list and add 1
    my $NextOrderNumber = 1;
    if (@DynamicfieldOrderList) {
        $NextOrderNumber = $DynamicfieldOrderList[-1] + 1;
    }

    # get the definition for all dynamic fields for
    my @DynamicFields = $Self->_GetDynamicFieldsDefinition();

    # create dynamic fields
    DYNAMICFIELD:

    for my $DynamicField (@DynamicFields) {

        # create a new field
        my $OldDynamicField = $Self->{DynamicFieldObject}->DynamicFieldGet(
            Name => $DynamicField->{Name},
        );

        if ( defined($OldDynamicField) ) {
            if ( exists( $OldDynamicField->{Label} ) ) {
                if (
                    ( $OldDynamicField->{Label} eq $DynamicField->{Label} )
                    )
                {
                    $Self->{LogObject}->Log(
                        Priority => 'info',
                        Message  => "Field already exists Label:$DynamicField->{Label}, skipping."
                    );
                    next;    # skip the record, it has been created already
                }

            }
        }

        #

        my $FieldID = $Self->{DynamicFieldObject}->DynamicFieldAdd(
            Name       => $DynamicField->{Name},
            Label      => $DynamicField->{Label},
            FieldOrder => $NextOrderNumber,
            FieldType  => $DynamicField->{FieldType},
            ObjectType => $DynamicField->{ObjectType},
            Config     => $DynamicField->{Config},
            ValidID    => $ValidID,
            UserID     => 1,
        );
        next DYNAMICFIELD if !$FieldID;

        # increase the order number
        $NextOrderNumber++;

    }

    return 1;
}

=item _GetDynamicFieldsDefinition()

returns the definition for System Monitoring related dynamic fields

    my $Result = $CodeObject->_GetDynamicFieldsDefinition();

=cut

sub _GetDynamicFieldsDefinition {
    my ( $Self, %Param ) = @_;

    my @AllNewFields = ();    # the fields that are filled out

    # run all PreFilterModules (modify email params)
    foreach my $Key ('PostMaster::PreFilterModule')
    {
        if ( ref $Self->{ConfigObject}->Get($Key) eq 'HASH' ) {
            my %Jobs = %{ $Self->{ConfigObject}->Get($Key) };
            for my $Job ( sort keys %Jobs ) {
                return if !$Self->{MainObject}->Require( $Jobs{$Job}->{Module} );

                next unless $Jobs{$Job}->{Module}->can("GetDynamicFieldsDefinition");

                my @NewFields;

                eval {

                    my $Run = $Jobs{$Job}->{Module}->GetDynamicFieldsDefinition(
                        $Self,
                        Param     => \%Param,
                        Config    => $Jobs{$Job},    # the job config
                        NewFields => \@NewFields
                    );
                    if ( !$Run ) {
                        $Self->{LogObject}->Log(
                            Priority => 'error',
                            Message =>
                                "Execute GetDynamicFieldsDefinition() of $Key $Jobs{$Job}->{Module} not successful!",
                        );
                    }
                };
                if ($@) {                            # error in eval
                    $Self->{LogObject}->Log(
                        Priority => 'error',
                        Message =>
                            "Execute GetDynamicFieldsDefinition() of $Key $Jobs{$Job}->{Module} not successful with error $@!",
                    );
                }
                else {
                    push @AllNewFields, (@NewFields);
                }
            }
        }
    }
    return @AllNewFields;
}

1;

=back

=head1 TERMS AND CONDITIONS

This Software is part of the OTRS project (L<http://otrs.org/>).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/gpl-2.0.txt>.

=cut

=head1 VERSION

$Revision: 1.6 $ $Date: 2012/02/02 15:59:27 $

=cut

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