public function worker($request)
{
$serverId = $request->serverId;
$logger = \Scalr::getContainer()->logger(__CLASS__);
$this->log("INFO", "Processing messages for %s server", $serverId);
try {
$dbserver = DBServer::LoadByID($serverId);
if ($dbserver->farmId) {
if ($dbserver->GetFarmObject()->Status == FARM_STATUS::TERMINATED) {
throw new ServerNotFoundException("Farm related to this server has been terminated.");
}
}
if (!$dbserver->isScalarized) {
// Do not process messages from the servers that has disabled/not-installed agent
$this->db->Execute("\n UPDATE messages\n SET status = ?\n WHERE server_id = ? AND status = ?\n ", array(MESSAGE_STATUS::UNSUPPORTED, $dbserver->serverId, MESSAGE_STATUS::PENDING));
$this->getLogger()->debug("Server %s has no agent. Aborting", $dbserver->serverId);
return false;
}
} catch (ServerNotFoundException $e) {
//By some reason server does not exist
$this->db->Execute("\n DELETE m FROM messages m\n WHERE m.server_id = ? AND m.`type` = ? AND m.`status` = ?\n ", [$serverId, "in", MESSAGE_STATUS::PENDING]);
$this->getLogger()->debug("Server %s is not found. Aborting", $dbserver->serverId);
return false;
}
//Warming up static DI cache
\Scalr::getContainer()->warmup();
// Reconfigure observers
\Scalr::ReconfigureObservers();
$rs = $this->db->Execute("\n SELECT m.* FROM messages m\n WHERE m.server_id = ? AND m.type = ? AND m.status = ?\n ORDER BY m.dtadded ASC\n ", [$serverId, "in", MESSAGE_STATUS::PENDING]);
while ($row = $rs->FetchRow()) {
try {
if ($row["message_format"] == 'xml') {
$message = $this->serializer->unserialize($row["message"]);
} else {
$message = $this->jsonSerializer->unserialize($row["message"]);
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_MESSAGE_FORMAT, 'json');
}
$this->getLogger()->debug("Processing message %s for server %s", $message->messageId, $dbserver->serverId);
$message->messageIpAddress = $row['ipaddress'];
$event = null;
$startTime = microtime(true);
// Update scalarizr package version
if (array_key_exists(Scalr_Messaging_MsgMeta::SZR_VERSION, $message->meta)) {
$dbserver->setScalarizrVersion($message->meta[Scalr_Messaging_MsgMeta::SZR_VERSION]);
}
if (array_key_exists(Scalr_Messaging_MsgMeta::SZR_UPD_CLIENT_VERSION, $message->meta)) {
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_UPD_CLIENT_VERSION, $message->meta[Scalr_Messaging_MsgMeta::SZR_UPD_CLIENT_VERSION]);
}
if ($dbserver->GetProperty(SERVER_PROPERTIES::SYSTEM_IGNORE_INBOUND_MESSAGES)) {
$this->getLogger()->debug("Ignore inbound message for server %s", $dbserver->serverId);
continue;
}
if ($message instanceof \Scalr_Messaging_Msg) {
$this->log('INFO', "Handling '%s' for '%s' server", $message->getName(), $serverId);
}
$doNotProcessMessage = false;
$update = [];
try {
if ($message instanceof Scalr_Messaging_Msg_OperationResult) {
if ($message->status == 'ok' || $message->status == 'completed') {
if ($message->name == 'Grow MySQL/Percona data volume' || $message->name == 'mysql.grow-volume') {
$volumeConfig = $message->data ? $message->data : $message->result;
$oldVolumeId = $dbserver->GetFarmRoleObject()->GetSetting(Scalr_Db_Msr::VOLUME_ID);
$engine = $dbserver->GetFarmRoleObject()->GetSetting(Scalr_Db_Msr::DATA_STORAGE_ENGINE);
try {
// clear information about last request
$dbserver->GetFarmRoleObject()->SetSetting(Entity\FarmRoleSetting::STORAGE_GROW_OPERATION_ID, null);
$dbserver->GetFarmRoleObject()->SetSetting(Entity\FarmRoleSetting::STORAGE_GROW_SERVER_ID, null);
$dbserver->GetFarmRoleObject()->SetSetting(Entity\FarmRoleSetting::STORAGE_GROW_LAST_ERROR, null);
$storageVolume = Scalr_Storage_Volume::init();
try {
$storageVolume->loadById($volumeConfig->id);
$storageVolume->setConfig($volumeConfig);
$storageVolume->save();
} catch (Exception $e) {
if (strpos($e->getMessage(), 'not found')) {
$storageVolume->loadBy(array('id' => $volumeConfig->id, 'client_id' => $dbserver->clientId, 'env_id' => $dbserver->envId, 'name' => "'{$volumeConfig->tags->service}' data volume", 'type' => $engine, 'platform' => $dbserver->platform, 'size' => $volumeConfig->size, 'fstype' => $volumeConfig->fstype, 'purpose' => $volumeConfig->tags->service, 'farm_roleid' => $dbserver->farmRoleId, 'server_index' => $dbserver->index));
$storageVolume->setConfig($volumeConfig);
$storageVolume->save(true);
} else {
throw $e;
}
}
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::VOLUME_ID, $volumeConfig->id, Entity\FarmRoleSetting::TYPE_LCL);
if ($engine == MYSQL_STORAGE_ENGINE::EBS) {
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_SIZE, $volumeConfig->size, Entity\FarmRoleSetting::TYPE_CFG);
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_TYPE, $volumeConfig->volumeType, Entity\FarmRoleSetting::TYPE_CFG);
if ($volumeConfig->volumeType == CreateVolumeRequestData::VOLUME_TYPE_IO1) {
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_IOPS, $volumeConfig->iops, Entity\FarmRoleSetting::TYPE_CFG);
}
} elseif ($engine == MYSQL_STORAGE_ENGINE::RAID_EBS) {
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_DISK_SIZE, $volumeConfig->size, Entity\FarmRoleSetting::TYPE_CFG);
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_EBS_DISK_TYPE, $volumeConfig->volumeType, Entity\FarmRoleSetting::TYPE_CFG);
if ($volumeConfig->volumeType == CreateVolumeRequestData::VOLUME_TYPE_IO1) {
$dbserver->GetFarmRoleObject()->SetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_EBS_DISK_IOPS, $volumeConfig->iops, Entity\FarmRoleSetting::TYPE_CFG);
}
}
// Remove old
$storageVolume->delete($oldVolumeId);
} catch (Exception $e) {
\Scalr::getContainer()->logger(__CLASS__)->error(new FarmLogMessage($dbserver->farmId, "Cannot save storage volume: {$e->getMessage()}", !empty($dbserver->serverId) ? $dbserver->serverId : null));
}
}
} elseif ($message->status == 'error' || $message->status == 'failed') {
if ($message->name == 'Initialization' || $message->name == 'system.init') {
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_IS_INIT_FAILED, 1);
if (is_object($message->error)) {
$errorText = $message->error->message;
} elseif ($message->error) {
$errorText = $message->error;
}
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_IS_INIT_ERROR_MSG, $errorText);
$event = new HostInitFailedEvent($dbserver, $errorText);
} else {
if ($message->name == 'Grow MySQL/Percona data volume' || $message->name == 'mysql.grow-volume') {
$dbserver->GetFarmRoleObject()->SetSetting(Entity\FarmRoleSetting::STORAGE_GROW_LAST_ERROR, is_object($message->error) ? $message->error->message : $message->error);
$dbserver->GetFarmRoleObject()->SetSetting(Entity\FarmRoleSetting::STORAGE_GROW_OPERATION_ID, null);
$dbserver->GetFarmRoleObject()->SetSetting(Entity\FarmRoleSetting::STORAGE_GROW_SERVER_ID, null);
}
}
}
} elseif ($message instanceof Scalr_Messaging_Msg_InitFailed) {
$errorText = $message->reason;
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_IS_INIT_ERROR_MSG, $errorText);
$event = new HostInitFailedEvent($dbserver, $errorText);
} elseif ($message instanceof \Scalr_Messaging_Msg_RuntimeError) {
//$logger->fatal(new FarmLogMessage($dbserver, "Scalarizr failed to launch on server '{$dbserver->getNameByConvention()}' with runtime error: {$message->message}"));
$logger->fatal(new FarmLogMessage($dbserver, sprintf("Scalarizr failed to launch on server '%s' with runtime error: %s", $dbserver->getNameByConvention(), !empty($message->message) ? $message->message : null)));
} elseif ($message instanceof Scalr_Messaging_Msg_UpdateControlPorts) {
$apiPort = $message->api;
$ctrlPort = $message->messaging;
// Check API port;
$currentApiPort = $dbserver->GetProperty(SERVER_PROPERTIES::SZR_API_PORT);
if (!$currentApiPort) {
$currentApiPort = 8010;
}
if ($apiPort && $apiPort != $currentApiPort) {
$logger->warn(new FarmLogMessage($dbserver, "Scalarizr API port was changed from {$currentApiPort} to {$apiPort}"));
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_API_PORT, $apiPort);
}
// Check Control port
$currentCtrlPort = $dbserver->GetProperty(SERVER_PROPERTIES::SZR_CTRL_PORT);
if (!$currentCtrlPort) {
$currentCtrlPort = 8013;
}
if ($ctrlPort && $ctrlPort != $currentCtrlPort) {
$logger->warn(new FarmLogMessage($dbserver, "Scalarizr Control port was changed from {$currentCtrlPort} to {$ctrlPort}"));
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_CTRL_PORT, $ctrlPort);
}
} elseif ($message instanceof Scalr_Messaging_Msg_Win_HostDown) {
$event = $this->onHostDown($message, $dbserver);
if ($event === false) {
$doNotProcessMessage = true;
}
} elseif ($message instanceof Scalr_Messaging_Msg_Win_PrepareBundleResult) {
try {
$bundleTask = BundleTask::LoadById($message->bundleTaskId);
} catch (Exception $e) {
}
if ($bundleTask) {
if ($bundleTask->status == SERVER_SNAPSHOT_CREATION_STATUS::PREPARING) {
if ($message->status == 'ok') {
$metaData = array('szr_version' => $message->meta[Scalr_Messaging_MsgMeta::SZR_VERSION], 'os' => $message->os, 'software' => $message->software);
$bundleTask->setMetaData($metaData);
$bundleTask->Save();
PlatformFactory::NewPlatform($bundleTask->platform)->CreateServerSnapshot($bundleTask);
} else {
$bundleTask->SnapshotCreationFailed("PrepareBundle procedure failed: {$message->lastError}");
}
}
}
} elseif ($message instanceof Scalr_Messaging_Msg_Hello) {
$event = $this->onHello($message, $dbserver);
} elseif ($message instanceof Scalr_Messaging_Msg_FireEvent) {
//Validate event
$isEventExist = $this->db->GetOne("\n SELECT id FROM event_definitions\n WHERE name = ? AND ((env_id = ? AND account_id = ?) OR (env_id IS NULL AND account_id = ?) OR (env_id IS NULL AND account_id IS NULL))\n LIMIT 1\n ", array($message->eventName, $dbserver->envId, $dbserver->clientId, $dbserver->clientId));
if ($isEventExist) {
$event = new CustomEvent($dbserver, $message->eventName, (array) $message->params);
}
} elseif ($message instanceof Scalr_Messaging_Msg_HostUpdate) {
try {
$dbFarmRole = $dbserver->GetFarmRoleObject();
} catch (Exception $e) {
}
if ($dbFarmRole instanceof DBFarmRole) {
foreach (Scalr_Role_Behavior::getListForFarmRole($dbFarmRole) as $behavior) {
$behavior->handleMessage($message, $dbserver);
}
}
} elseif ($message instanceof Scalr_Messaging_Msg_MongoDb) {
/********* MONGODB *********/
try {
$dbFarmRole = $dbserver->GetFarmRoleObject();
} catch (Exception $e) {
}
if ($dbFarmRole instanceof DBFarmRole) {
foreach (Scalr_Role_Behavior::getListForFarmRole($dbFarmRole) as $behavior) {
$behavior->handleMessage($message, $dbserver);
}
}
} elseif ($message instanceof Scalr_Messaging_Msg_DbMsr) {
/********* DBMSR *********/
try {
$dbFarmRole = $dbserver->GetFarmRoleObject();
} catch (Exception $e) {
}
if ($dbFarmRole instanceof DBFarmRole) {
foreach (Scalr_Role_Behavior::getListForFarmRole($dbFarmRole) as $behavior) {
$behavior->handleMessage($message, $dbserver);
}
}
} elseif ($message instanceof Scalr_Messaging_Msg_HostInit) {
$event = $this->onHostInit($message, $dbserver);
try {
$dbserver->updateTimelog('ts_hi', $message->secondsSinceBoot, $message->secondsSinceStart);
} catch (Exception $e) {
}
if (!$event) {
$this->getLogger()->debug("Could not create HostInitEvent for %s. Aborting...", $dbserver->serverId);
continue;
}
} elseif ($message instanceof Scalr_Messaging_Msg_HostUp) {
$event = $this->onHostUp($message, $dbserver);
try {
$dbserver->updateTimelog('ts_hu');
} catch (Exception $e) {
}
} elseif ($message instanceof Scalr_Messaging_Msg_HostDown) {
$event = $this->onHostDown($message, $dbserver);
if ($event === false) {
$doNotProcessMessage = true;
}
} elseif ($message instanceof Scalr_Messaging_Msg_RebootStart) {
$event = new RebootBeginEvent($dbserver);
} elseif ($message instanceof Scalr_Messaging_Msg_RebootFinish) {
if ($dbserver->status == \SERVER_STATUS::RESUMING) {
try {
// UPDATE IPs
$p = PlatformFactory::NewPlatform($dbserver->platform);
$ipaddresses = $p->GetServerIPAddresses($dbserver);
if ($ipaddresses['remoteIp'] && !$dbserver->remoteIp || $ipaddresses['localIp'] && !$dbserver->localIp) {
$dbserver->remoteIp = $update['remoteIp'] = $ipaddresses['remoteIp'];
if (!$dbserver->localIp) {
$update['localIp'] = $ipaddresses['localIp'] ? $ipaddresses['localIp'] : $message->localIp;
}
}
// Update type after resume on EC2
if ($dbserver->platform == \SERVER_PLATFORMS::EC2 || $dbserver->platform == \SERVER_PLATFORMS::GCE) {
$cacheKey = sprintf('%s:%s', $dbserver->envId, $dbserver->cloudLocation);
$type = $p->instancesListCache[$cacheKey][$dbserver->GetCloudServerID()]['type'];
if ($type != $dbserver->getType()) {
$dbserver->update(['type' => $type, 'instanceTypeName' => $type]);
}
}
} catch (Exception $e) {
if (stristr($e->getMessage(), "AWS Error. Request DescribeInstances failed. Cannot establish connection to AWS server")) {
$doNotProcessMessage = true;
} else {
throw $e;
}
}
// For Openstack we need to re-accociate IPs
try {
if ($dbserver->isOpenstack()) {
OpenstackHelper::setServerFloatingIp($dbserver);
}
} catch (Exception $e) {
//ignore
}
// Set cloudstack Static IP if needed
if (PlatformFactory::isCloudstack($dbserver->platform) && !$dbserver->remoteIp) {
$remoteIp = CloudstackHelper::getSharedIP($dbserver);
if ($remoteIp) {
$dbserver->remoteIp = $update['remoteIp'] = $remoteIp;
}
}
if ($doNotProcessMessage === false) {
if (!empty($update)) {
$dbserver->update($update);
unset($update);
}
$event = new \ResumeCompleteEvent($dbserver);
}
} elseif ($dbserver->status == \SERVER_STATUS::SUSPENDED) {
//We need to wait for Poller to update status to RESUMING before processing this message
$doNotProcessMessage = true;
} elseif ($dbserver->status == \SERVER_STATUS::RUNNING) {
if (!$dbserver->localIp && $message->localIp) {
$dbserver->update(['localIp' => $message->localIp]);
}
$event = new RebootCompleteEvent($dbserver);
}
} elseif ($message instanceof Scalr_Messaging_Msg_BeforeHostUp) {
$event = new BeforeHostUpEvent($dbserver);
try {
$dbserver->updateTimelog('ts_bhu');
} catch (Exception $e) {
}
} elseif ($message instanceof Scalr_Messaging_Msg_BlockDeviceAttached) {
if ($dbserver->platform == SERVER_PLATFORMS::EC2) {
$aws = $dbserver->GetEnvironmentObject()->aws($dbserver->GetProperty(EC2_SERVER_PROPERTIES::REGION));
$instanceId = $dbserver->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID);
//The main goal of using filters there is to considerably decrease the size of the response.
$volumes = $aws->ec2->volume->describe(null, array(array('name' => VolumeFilterNameType::attachmentInstanceId(), 'value' => (string) $instanceId), array('name' => VolumeFilterNameType::attachmentDevice(), 'value' => (string) $message->deviceName), array('name' => VolumeFilterNameType::status(), 'value' => AMAZON_EBS_STATE::IN_USE)));
foreach ($volumes as $volume) {
/* @var $volume \Scalr\Service\Aws\Ec2\DataType\VolumeData */
if ($volume->status == AMAZON_EBS_STATE::IN_USE && count($volume->attachmentSet) && $volume->attachmentSet[0]->instanceId == $instanceId && $volume->attachmentSet[0]->device == $message->deviceName) {
$message->volumeId = $volume->volumeId;
}
}
//Releases memory
unset($volumes);
$dbserver->GetEnvironmentObject()->getContainer()->release('aws');
unset($aws);
}
$event = new EBSVolumeAttachedEvent($dbserver, $message->deviceName, $message->volumeId);
} elseif ($message instanceof Scalr_Messaging_Msg_BlockDeviceMounted) {
// Single volume
$ebsinfo = $this->db->GetRow("\n SELECT * FROM ec2_ebs WHERE volume_id = ? LIMIT 1\n ", array($message->volumeId));
if ($ebsinfo) {
$this->db->Execute("\n UPDATE ec2_ebs\n SET mount_status = ?, isfsexist = '1'\n WHERE id = ?\n ", array(EC2_EBS_MOUNT_STATUS::MOUNTED, $ebsinfo['id']));
}
$event = new EBSVolumeMountedEvent($dbserver, $message->mountpoint, $message->volumeId, $message->deviceName);
} elseif ($message instanceof Scalr_Messaging_Msg_RebundleResult) {
if ($message->status == Scalr_Messaging_Msg_RebundleResult::STATUS_OK) {
$metaData = array('szr_version' => $message->meta[Scalr_Messaging_MsgMeta::SZR_VERSION], 'dist' => $message->dist, 'os' => $message->os, 'software' => $message->software);
$tags = [];
if ($dbserver->platform == SERVER_PLATFORMS::EC2) {
if ($message->aws) {
if ($message->aws->rootDeviceType == 'ebs') {
$tags[] = ROLE_TAGS::EC2_EBS;
}
if ($message->aws->virtualizationType == 'hvm') {
$tags[] = ROLE_TAGS::EC2_HVM;
}
} else {
$aws = $dbserver->GetEnvironmentObject()->aws($dbserver);
try {
$info = $aws->ec2->image->describe($dbserver->GetProperty(EC2_SERVER_PROPERTIES::AMIID))->get(0);
if ($info->rootDeviceType == 'ebs') {
$tags[] = ROLE_TAGS::EC2_EBS;
} else {
try {
$bundleTask = BundleTask::LoadById($message->bundleTaskId);
if ($bundleTask->bundleType == SERVER_SNAPSHOT_CREATION_TYPE::EC2_EBS) {
$tags[] = ROLE_TAGS::EC2_EBS;
}
} catch (Exception $e) {
}
}
if ($info->virtualizationType == 'hvm') {
$tags[] = ROLE_TAGS::EC2_HVM;
}
unset($info);
} catch (Exception $e) {
$metaData['tagsError'] = $e->getMessage();
try {
$bundleTask = BundleTask::LoadById($message->bundleTaskId);
if ($bundleTask->bundleType == SERVER_SNAPSHOT_CREATION_TYPE::EC2_EBS) {
$tags[] = ROLE_TAGS::EC2_EBS;
}
} catch (Exception $e) {
}
}
//Releases memory
$dbserver->GetEnvironmentObject()->getContainer()->release('aws');
unset($aws);
}
}
$metaData['tags'] = !empty($tags) ? $tags : null;
$event = new RebundleCompleteEvent($dbserver, $message->snapshotId, $message->bundleTaskId, $metaData);
} else {
if ($message->status == Scalr_Messaging_Msg_RebundleResult::STATUS_FAILED) {
$event = new RebundleFailedEvent($dbserver, $message->bundleTaskId, $message->lastError);
}
}
} elseif ($message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundleResult) {
if ($message->status == "ok") {
$event = new MysqlBackupCompleteEvent($dbserver, MYSQL_BACKUP_TYPE::BUNDLE, array('snapshotConfig' => $message->snapshotConfig, 'logFile' => $message->logFile, 'logPos' => $message->logPos, 'dataBundleSize' => $message->dataBundleSize, 'snapshotId' => $message->snapshotId));
} else {
$event = new MysqlBackupFailEvent($dbserver, MYSQL_BACKUP_TYPE::BUNDLE);
$event->lastError = $message->lastError;
}
} elseif ($message instanceof Scalr_Messaging_Msg_Mysql_CreateBackupResult) {
if ($message->status == "ok") {
$event = new MysqlBackupCompleteEvent($dbserver, MYSQL_BACKUP_TYPE::DUMP, array());
$event->backupParts = $message->backupParts;
} else {
$event = new MysqlBackupFailEvent($dbserver, MYSQL_BACKUP_TYPE::DUMP);
$event->lastError = $message->lastError;
}
} elseif ($message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMasterResult) {
$event = $this->onMysql_PromoteToMasterResult($message, $dbserver);
} elseif ($message instanceof Scalr_Messaging_Msg_Mysql_CreatePmaUserResult) {
$farmRole = DBFarmRole::LoadByID($message->farmRoleId);
if ($message->status == "ok") {
$farmRole->SetSetting(Entity\FarmRoleSetting::MYSQL_PMA_USER, $message->pmaUser, Entity\FarmRoleSetting::TYPE_LCL);
$farmRole->SetSetting(Entity\FarmRoleSetting::MYSQL_PMA_PASS, $message->pmaPassword, Entity\FarmRoleSetting::TYPE_LCL);
} else {
$farmRole->SetSetting(Entity\FarmRoleSetting::MYSQL_PMA_REQUEST_TIME, "", Entity\FarmRoleSetting::TYPE_LCL);
$farmRole->SetSetting(Entity\FarmRoleSetting::MYSQL_PMA_REQUEST_ERROR, $message->lastError, Entity\FarmRoleSetting::TYPE_LCL);
}
} elseif ($message instanceof Scalr_Messaging_Msg_RabbitMq_SetupControlPanelResult) {
$farmRole = $dbserver->GetFarmRoleObject();
if ($message->status == "ok") {
$mgmtHost = $dbserver->getSzrHost();
if ($message->port) {
$mgmtURL = "http://{$mgmtHost}:{$message->port}/mgmt";
} elseif ($message->cpanelUrl) {
$info = parse_url($message->cpanelUrl);
$mgmtURL = "http://{$mgmtHost}:{$info['port']}/mgmt";
}
$farmRole->SetSetting(Scalr_Role_Behavior_RabbitMQ::ROLE_CP_SERVER_ID, $dbserver->serverId, Entity\FarmRoleSetting::TYPE_LCL);
$farmRole->SetSetting(Scalr_Role_Behavior_RabbitMQ::ROLE_CP_URL, $mgmtURL, Entity\FarmRoleSetting::TYPE_LCL);
$farmRole->SetSetting(Scalr_Role_Behavior_RabbitMQ::ROLE_CP_REQUEST_TIME, "", Entity\FarmRoleSetting::TYPE_LCL);
} else {
$farmRole->SetSetting(Scalr_Role_Behavior_RabbitMQ::ROLE_CP_SERVER_ID, "", Entity\FarmRoleSetting::TYPE_LCL);
$farmRole->SetSetting(Scalr_Role_Behavior_RabbitMQ::ROLE_CP_REQUEST_TIME, "", Entity\FarmRoleSetting::TYPE_LCL);
$farmRole->SetSetting(Scalr_Role_Behavior_RabbitMQ::ROLE_CP_ERROR_MSG, $message->lastError, Entity\FarmRoleSetting::TYPE_LCL);
}
} elseif ($message instanceof Scalr_Messaging_Msg_AmiScriptsMigrationResult) {
try {
//Open security group:
if ($dbserver->platform == SERVER_PLATFORMS::EC2) {
$info = PlatformFactory::NewPlatform($dbserver->platform)->GetServerExtendedInformation($dbserver);
$sg = empty($info['Security groups']) ? [] : explode(", ", $info['Security groups']);
foreach ($sg as $sgroup) {
if ($sgroup != 'default') {
// For Scalarizr
$group_rules = array(array('rule' => 'tcp:8013:8013:0.0.0.0/0'), array('rule' => 'udp:8014:8014:0.0.0.0/0'));
$aws = $dbserver->GetEnvironmentObject()->aws($dbserver);
$ipPermissions = new \Scalr\Service\Aws\Ec2\DataType\IpPermissionList();
foreach ($group_rules as $rule) {
$group_rule = explode(":", $rule["rule"]);
$ipPermissions->append(new \Scalr\Service\Aws\Ec2\DataType\IpPermissionData($group_rule[0], $group_rule[1], $group_rule[2], new \Scalr\Service\Aws\Ec2\DataType\IpRangeData($group_rule[3])));
}
$aws->ec2->securityGroup->authorizeIngress($ipPermissions, null, $sgroup);
$dbserver->GetEnvironmentObject()->getContainer()->release('aws');
unset($aws);
unset($ipPermissions);
break;
}
}
}
} catch (Exception $e) {
$logger->fatal($e->getMessage());
}
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT, 8014);
$dbserver->SetProperty(SERVER_PROPERTIES::SZR_VESION, "0.7.217");
if ($message->mysql) {
$event = $this->onHostUp($message, $dbserver, true);
}
}
$handle_status = MESSAGE_STATUS::HANDLED;
} catch (Exception $e) {
$handle_status = MESSAGE_STATUS::FAILED;
$logger->error(sprintf("Cannot handle message '%s' (message_id: %s) " . "from server '%s' (server_id: %s). %s", $message->getName(), $message->messageId, $dbserver->remoteIp ? $dbserver->remoteIp : '*no-ip*', $dbserver->serverId, $e->getMessage() . "({$e->getFile()}:{$e->getLine()})"));
}
if ($doNotProcessMessage === false) {
$totalTime = microtime(true) - $startTime;
$this->db->Execute("\n UPDATE messages\n SET status = ?, processing_time = ?, dtlasthandleattempt = UTC_TIMESTAMP()\n WHERE messageid = ?\n ", array($handle_status, $totalTime, $message->messageId));
} else {
$logger->info(sprintf("Handle message '%s' (message_id: %s) " . "from server '%s' (server_id: %s) is postponed due to status transition", $message->getName(), $message->messageId, $dbserver->remoteIp ? $dbserver->remoteIp : '*no-ip*', $dbserver->serverId));
}
if ($event instanceof \AbstractServerEvent) {
\Scalr::FireEvent($dbserver->farmId, $event);
}
} catch (Exception $e) {
$logger->error($e->getMessage());
}
}
return $request;
}