mirror of
https://github.com/Icinga/icingaweb2.git
synced 2025-10-31 03:14:31 +01:00
698 lines
22 KiB
PHP
698 lines
22 KiB
PHP
<?php
|
|
// {{{ICINGA_LICENSE_HEADER}}}
|
|
// {{{ICINGA_LICENSE_HEADER}}}
|
|
|
|
namespace Tests\Icinga\Protocol\Commandpipe;
|
|
|
|
use Zend_Config;
|
|
use Icinga\Test\BaseTestCase;
|
|
use Icinga\Protocol\Commandpipe\Comment;
|
|
use Icinga\Protocol\Commandpipe\CommandPipe;
|
|
use Icinga\Protocol\Commandpipe\PropertyModifier as MONFLAG;
|
|
use Icinga\Protocol\Ldap\Exception;
|
|
use Icinga\Module\Monitoring\Command\AcknowledgeCommand;
|
|
use Icinga\Module\Monitoring\Command\AddCommentCommand;
|
|
use Icinga\Module\Monitoring\Command\ScheduleDowntimeCommand;
|
|
use Icinga\Module\Monitoring\Command\CustomNotificationCommand;
|
|
use Icinga\Module\Monitoring\Command\DelayNotificationCommand;
|
|
use Icinga\Module\Monitoring\Command\ScheduleCheckCommand;
|
|
use Icinga\Module\Monitoring\Command\SubmitPassiveCheckresultCommand;
|
|
|
|
if (!defined('EXTCMD_TEST_BIN')) {
|
|
define('EXTCMD_TEST_BIN', './bin/extcmd_test');
|
|
}
|
|
|
|
/**
|
|
* Several tests for the command pipe component
|
|
*
|
|
* Uses the helper script extcmd_test, which is basically the extracted command
|
|
* parser functions from the icinga core
|
|
*/
|
|
class CommandPipeTest extends BaseTestCase
|
|
{
|
|
public function setUp()
|
|
{
|
|
parent::setUp();
|
|
if (! file_exists(EXTCMD_TEST_BIN)) {
|
|
$this->markTestSkipped('Cannot find "' . EXTCMD_TEST_BIN . '"');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the path of the test pipe used in these tests
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getPipeName()
|
|
{
|
|
return sys_get_temp_dir() . '/icinga_test_pipe';
|
|
}
|
|
|
|
/**
|
|
* Return a @see Icinga\Protocal\CommandPipe\CommandPipe instance set up for the local test pipe
|
|
*
|
|
* @return CommandPipe
|
|
*/
|
|
private function getLocalTestPipe()
|
|
{
|
|
$tmpPipe = $this->getPipeName();
|
|
$this->cleanup();
|
|
touch($tmpPipe);
|
|
|
|
$cfg = new Zend_Config(
|
|
array(
|
|
'path' => $tmpPipe,
|
|
'name' => 'test'
|
|
)
|
|
);
|
|
|
|
return new CommandPipe($cfg);
|
|
}
|
|
|
|
/**
|
|
* Return a @see Icinga\Protocal\CommandPipe\CommandPipe instance set up
|
|
* for the local test pipe, but with ssh as the transport layer
|
|
*
|
|
* @return CommandPipe
|
|
*/
|
|
private function getSSHTestPipe()
|
|
{
|
|
$tmpPipe = $this->getPipeName();
|
|
$this->cleanup();
|
|
touch($tmpPipe);
|
|
|
|
$cfg = new Zend_Config(
|
|
array(
|
|
'path' => $tmpPipe,
|
|
'user' => 'vagrant',
|
|
'password' => 'vagrant',
|
|
'host' => 'localhost',
|
|
'port' => 22,
|
|
'name' => 'test'
|
|
)
|
|
);
|
|
|
|
return new CommandPipe($cfg);
|
|
}
|
|
|
|
/**
|
|
* Remove the testpipe if it exists
|
|
*/
|
|
private function cleanup() {
|
|
if (file_exists($this->getPipeName())) {
|
|
unlink($this->getPipeName());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Query the extcmd_test script with $command or the command pipe and test whether the result is $exceptedString and
|
|
* has a return code of 0.
|
|
*
|
|
* Note:
|
|
* - if no string is given, only the return code is tested
|
|
* - if no command is given, the content of the test commandpipe is used
|
|
*
|
|
* This helps testing whether commandpipe serialization works correctly
|
|
*
|
|
* @param bool $expectedString The string that is expected to be returned from the extcmd_test binary
|
|
* (optional, leave it to just test for the return code)
|
|
* @param bool $command The commandstring to send (optional, leave it for using the command pipe content)
|
|
*/
|
|
private function assertCommandSucceeded($expectedString = false, $command = false) {
|
|
$resultCode = null;
|
|
$resultArr = array();
|
|
$receivedCmd = exec(EXTCMD_TEST_BIN . ' ' . escapeshellarg(
|
|
$command ? $command : file_get_contents($this->getPipeName())),
|
|
$resultArr,
|
|
$resultCode
|
|
);
|
|
$this->assertEquals(0, $resultCode, 'Submit of external command returned error : ' . $receivedCmd);
|
|
if ($expectedString) {
|
|
$this->assertEquals(
|
|
$expectedString,
|
|
$receivedCmd,
|
|
'Asserting that the command icinga received matches the command we send'
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test whether a single host acknowledgment is serialized and send correctly
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testAcknowledgeSingleHost()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$ack = new AcknowledgeCommand(new Comment('I can', 'sends teh ack'));
|
|
$pipe->sendCommand(
|
|
$ack,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'hostA'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('ACKNOWLEDGE_HOST_PROBLEM;hostA;0;0;0;I can;sends teh ack');
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether multiple host and service acknowledgments are serialized and send correctly
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testAcknowledgeMultipleObjects()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$ack = new AcknowledgeCommand(new Comment('I can', 'sends teh ack'));
|
|
$pipe->getTransport()->setOpenMode('a');
|
|
$pipe->sendCommand(
|
|
$ack,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'hostA'
|
|
),(object) array(
|
|
'host_name' => 'hostB'
|
|
),(object) array(
|
|
'host_name' => 'hostC'
|
|
),(object) array(
|
|
'host_name' => 'hostC',
|
|
'service_description' => 'svc'
|
|
)
|
|
)
|
|
);
|
|
|
|
$result = explode("\n", file_get_contents($this->getPipeName()));
|
|
$this->assertCount(5, $result, 'Asserting the correct number of commands being written to the command pipe');
|
|
|
|
$this->assertCommandSucceeded('ACKNOWLEDGE_HOST_PROBLEM;hostA;0;0;0;I can;sends teh ack', $result[0]);
|
|
$this->assertCommandSucceeded('ACKNOWLEDGE_HOST_PROBLEM;hostB;0;0;0;I can;sends teh ack', $result[1]);
|
|
$this->assertCommandSucceeded('ACKNOWLEDGE_HOST_PROBLEM;hostC;0;0;0;I can;sends teh ack', $result[2]);
|
|
$this->assertCommandSucceeded('ACKNOWLEDGE_SVC_PROBLEM;hostC;svc;0;0;0;I can;sends teh ack', $result[3]);
|
|
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether a single host comment is correctly serialized and send to the command pipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testAddHostComment()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->sendCommand(
|
|
new AddCommentCommand(
|
|
new Comment(
|
|
'Autor',
|
|
'Comment'
|
|
)
|
|
),
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'hostA'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('ADD_HOST_COMMENT;hostA;0;Autor;Comment');
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether removing all hostcomments is correctly serialized and send to the command pipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testRemoveAllHostComment()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->removeComment(
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'test'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('DEL_ALL_HOST_COMMENTS;test');
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether removing a single host comment is correctly serialized and send to the command pipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testRemoveSpecificComment()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->removeComment(
|
|
array(
|
|
(object) array(
|
|
'comment_id' => 34,
|
|
'host_name' => 'test'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('DEL_HOST_COMMENT;34');
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether a multiple reschedules for services and hosts are correctly serialized and send to the commandpipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testScheduleChecks()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->getTransport()->setOpenMode('a'); // append so we have multiple results
|
|
$command = new ScheduleCheckCommand(5000);
|
|
$pipe->sendCommand(
|
|
$command,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'test'
|
|
),
|
|
(object) array(
|
|
'host_name' => 'test',
|
|
'service_description' => 'svc1'
|
|
)
|
|
)
|
|
);
|
|
$command->setForced(true);
|
|
$pipe->sendCommand(
|
|
$command,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'test'
|
|
),
|
|
(object) array(
|
|
'host_name' => 'test',
|
|
'service_description' => 'svc1'
|
|
)
|
|
)
|
|
);
|
|
$command->excludeHost();
|
|
$pipe->sendCommand(
|
|
$command,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'test'
|
|
)
|
|
)
|
|
);
|
|
|
|
$result = explode("\n", file_get_contents($this->getPipeName()));
|
|
$this->assertCount(6, $result, 'Asserting a correct number of commands being written to the commandpipe');
|
|
|
|
$this->assertCommandSucceeded('SCHEDULE_HOST_CHECK;test;5000', $result[0]);
|
|
$this->assertCommandSucceeded('SCHEDULE_SVC_CHECK;test;svc1;5000', $result[1]);
|
|
$this->assertCommandSucceeded('SCHEDULE_FORCED_HOST_CHECK;test;5000', $result[2]);
|
|
$this->assertCommandSucceeded('SCHEDULE_FORCED_SVC_CHECK;test;svc1;5000', $result[3]);
|
|
$this->assertCommandSucceeded('SCHEDULE_FORCED_HOST_SVC_CHECKS;test;5000', $result[4]);
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether modifying monitoringflags of a host and service is correctly serialized and send to the command pipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testObjectStateModifications()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->getTransport()->setOpenMode('a');
|
|
$pipe->setMonitoringProperties(
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost'
|
|
),
|
|
(object) array(
|
|
'host_name' => 'host',
|
|
'service_description' => 'svc'
|
|
)
|
|
), new MONFLAG(
|
|
array(
|
|
MONFLAG::ACTIVE => MONFLAG::STATE_DISABLE,
|
|
MONFLAG::PASSIVE => MONFLAG::STATE_ENABLE,
|
|
MONFLAG::NOTIFICATIONS => MONFLAG::STATE_DISABLE,
|
|
MONFLAG::EVENTHANDLER => MONFLAG::STATE_ENABLE,
|
|
MONFLAG::FLAPPING => MONFLAG::STATE_DISABLE,
|
|
MONFLAG::FRESHNESS => MONFLAG::STATE_ENABLE,
|
|
)
|
|
)
|
|
);
|
|
|
|
$result = explode("\n", file_get_contents($this->getPipeName()));
|
|
array_pop($result); // remove empty last line
|
|
$this->assertCount(12, $result, 'Asserting a correct number of commands being written to the commandpipe');
|
|
foreach ($result as $command) {
|
|
$this->assertCommandSucceeded(false, $command);
|
|
}
|
|
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether enabling and disabling global notifications are send correctly to the pipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testGlobalNotificationTrigger()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->enableGlobalNotifications();
|
|
$this->assertCommandSucceeded('ENABLE_NOTIFICATIONS;');
|
|
$pipe->disableGlobalNotifications();
|
|
$this->assertCommandSucceeded('DISABLE_NOTIFICATIONS;');
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether host and servicedowntimes are correctly scheduled
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testScheduleDowntime()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$downtime = new ScheduleDowntimeCommand(25, 26, new Comment('me', 'test'));
|
|
$pipe->sendCommand(
|
|
$downtime,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('SCHEDULE_HOST_DOWNTIME;Testhost;25;26;1;0;0;me;test');
|
|
|
|
$pipe->sendCommand(
|
|
$downtime,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost',
|
|
'service_description' => 'svc'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('SCHEDULE_SVC_DOWNTIME;Testhost;svc;25;26;1;0;0;me;test');
|
|
|
|
$downtime->excludeHost();
|
|
$pipe->sendCommand(
|
|
$downtime,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('SCHEDULE_HOST_SVC_DOWNTIME;Testhost;25;26;1;0;0;me;test');
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether propagated host downtimes are correctly scheduled
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testSchedulePropagatedDowntime()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$downtime = new ScheduleDowntimeCommand(25, 26, new Comment('me', 'test'));
|
|
$downtime->includeChildren();
|
|
$pipe->sendCommand(
|
|
$downtime,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('SCHEDULE_AND_PROPAGATE_HOST_DOWNTIME;Testhost;25;26;1;0;0;me;test');
|
|
|
|
$downtime->includeChildren(true, true);
|
|
$pipe->sendCommand(
|
|
$downtime,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded(
|
|
'SCHEDULE_AND_PROPAGATE_TRIGGERED_HOST_DOWNTIME;Testhost;25;26;1;0;0;me;test'
|
|
);
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether the removal of downtimes is correctly serialized and send to the commandpipe for hosts and services
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testRemoveDowntime()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$pipe->getTransport()->setOpenMode('a');
|
|
$pipe->removeDowntime(
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Testhost'
|
|
),
|
|
(object) array(
|
|
'host_name' => 'host',
|
|
'service_description' => 'svc'
|
|
),
|
|
(object) array(
|
|
'host_name' => 'host',
|
|
'service_description' => 'svc',
|
|
'downtime_id' => 123
|
|
)
|
|
)
|
|
);
|
|
$result = explode("\n", file_get_contents($this->getPipeName()));
|
|
array_pop($result); // remove empty last line
|
|
$this->assertCount(3, $result, 'Asserting a correct number of commands being written to the commandpipe');
|
|
$this->assertCommandSucceeded('DEL_DOWNTIME_BY_HOST_NAME;Testhost', $result[0]);
|
|
$this->assertCommandSucceeded('DEL_DOWNTIME_BY_HOST_NAME;host;svc', $result[1]);
|
|
$this->assertCommandSucceeded('DEL_SVC_DOWNTIME;123', $result[2]);
|
|
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether custom servicenotifications are correctly send to the commandpipe without options
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testSendCustomServiceNotification()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$notification = new CustomNotificationCommand(new Comment('Author', 'Comment'));
|
|
$pipe->sendCommand(
|
|
$notification,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Host',
|
|
'service_description' => 'Service'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('SEND_CUSTOM_SVC_NOTIFICATION;Host;Service;0;Author;Comment');
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether custom hostnotifications are correctly send to the commandpipe with a varlist of options
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testSendCustomHostNotificationWithOptions()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$notification = new CustomNotificationCommand(new Comment('Author', 'Comment'), true, true);
|
|
$pipe->sendCommand(
|
|
$notification,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Host',
|
|
'service_description' => 'Service'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('SEND_CUSTOM_SVC_NOTIFICATION;Host;Service;3;Author;Comment');
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether commands to delay notifications are being sent to the commandpipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testDelayNotification()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$delay = new DelayNotificationCommand(300);
|
|
$pipe->sendCommand(
|
|
$delay,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Host',
|
|
'service_description' => 'Service'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('DELAY_SVC_NOTIFICATION;Host;Service;300');
|
|
|
|
$pipe->sendCommand(
|
|
$delay,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Host'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('DELAY_HOST_NOTIFICATION;Host;300');
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test whether commands to submit passive check results are being sent to the commandpipe
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testSubmitPassiveCheckresult()
|
|
{
|
|
$pipe = $this->getLocalTestPipe();
|
|
try {
|
|
$result = new SubmitPassiveCheckresultCommand(0, 'foo', 'bar');
|
|
$pipe->sendCommand(
|
|
$result,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Host',
|
|
'service_description' => 'Service'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('PROCESS_SERVICE_CHECK_RESULT;Host;Service;0;foo|bar');
|
|
|
|
$result->setOutput('foobar');
|
|
$result->setPerformanceData('');
|
|
$pipe->sendCommand(
|
|
$result,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'Host'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('PROCESS_HOST_CHECK_RESULT;Host;0;foobar');
|
|
} catch (Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Test sending of commands via SSH (currently disabled)
|
|
*
|
|
* @throws Exception
|
|
*/
|
|
public function testSSHCommands()
|
|
{
|
|
$this->markTestSkipped('This test assumes running in a vagrant VM with key-auth');
|
|
|
|
$pipe = $this->getSSHTestPipe();
|
|
try {
|
|
$ack = new AcknowledgeCommand(new Comment('I can', 'sends teh ack'));
|
|
$pipe->sendCommand(
|
|
$ack,
|
|
array(
|
|
(object) array(
|
|
'host_name' => 'hostA'
|
|
)
|
|
)
|
|
);
|
|
$this->assertCommandSucceeded('ACKNOWLEDGE_HOST_PROBLEM;hostA;0;0;0;I can;sends teh ack');
|
|
} catch(Exception $e) {
|
|
$this->cleanup();
|
|
throw $e;
|
|
}
|
|
$this->cleanup();
|
|
}
|
|
}
|