Returns DBFarm Object
| public GetFarmObject ( ) : DBFarm | ||
| Résultat | DBFarm | |
/**
* Constructor
*
* @param string $platform Platform
* @param DBFarmRole $DBFarmRole optional Farm Role object
* @param int $index optional Server index within the Farm Role scope
* @param string $role_id optional Identifier of the Role
*/
public function __construct($platform, DBFarmRole $DBFarmRole = null, $index = null, $role_id = null)
{
$this->platform = $platform;
$this->dbFarmRole = $DBFarmRole;
$this->index = $index;
$this->roleId = $role_id === null ? $this->dbFarmRole->RoleID : $role_id;
if ($DBFarmRole) {
$this->envId = $DBFarmRole->GetFarmObject()->EnvID;
}
//Refletcion
$Reflect = new ReflectionClass(DBServer::$platformPropsClasses[$this->platform]);
foreach ($Reflect->getConstants() as $k => $v) {
$this->platformProps[] = $v;
}
if ($DBFarmRole) {
if (PlatformFactory::isOpenstack($this->platform)) {
$this->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION => $DBFarmRole->CloudLocation));
} elseif (PlatformFactory::isCloudstack($this->platform)) {
$this->SetProperties(array(CLOUDSTACK_SERVER_PROPERTIES::CLOUD_LOCATION => $DBFarmRole->CloudLocation));
} else {
switch ($this->platform) {
case SERVER_PLATFORMS::GCE:
$this->SetProperties(array(GCE_SERVER_PROPERTIES::CLOUD_LOCATION => $DBFarmRole->CloudLocation));
break;
case SERVER_PLATFORMS::EC2:
$this->SetProperties(array(EC2_SERVER_PROPERTIES::REGION => $DBFarmRole->CloudLocation));
break;
}
}
}
$this->SetProperties(array(SERVER_PROPERTIES::SZR_VESION => '0.20.0'));
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$DBFarm = $dbFarmRole->GetFarmObject();
if (count($servers) == 0) {
return 0;
}
$roleBWRaw = array();
$retval = array();
foreach ($servers as $DBServer) {
$type = $farmRoleMetric->getSetting(self::SETTING_BW_TYPE) == 'inbound' ? 'receive' : 'transmit';
$netStat = (array) $DBServer->scalarizr->system->netStat();
foreach ($netStat as $interface => $usage) {
if ($interface != 'lo') {
break;
}
}
if ($usage) {
array_push($roleBWRaw, round($usage->{$type}->bytes / 1024 / 1024, 2));
}
}
$roleBW = round(array_sum($roleBWRaw) / count($roleBWRaw), 2);
if ($farmRoleMetric->getSetting(self::SETTING_BW_LAST_VALUE_RAW) !== null && $farmRoleMetric->getSetting(self::SETTING_BW_LAST_VALUE_RAW) !== '') {
$time = time() - $farmRoleMetric->dtLastPolled;
$bandwidthUsage = ($roleBW - (double) $farmRoleMetric->getSetting(self::SETTING_BW_LAST_VALUE_RAW)) * 8;
$bandwidthChannelUsage = $bandwidthUsage / $time;
// in Mbits/sec
$retval = round($bandwidthChannelUsage, 2);
} else {
$retval = 0;
}
$farmRoleMetric->setSetting(self::SETTING_BW_LAST_VALUE_RAW, $roleBW);
return array($retval);
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$DBFarm = $dbFarmRole->GetFarmObject();
if (count($servers) == 0) {
return 0;
}
$_roleBW = array();
$retval = array();
foreach ($servers as $DBServer) {
$port = $DBServer->GetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT);
$type = $farmRoleMetric->getSetting(self::SETTING_BW_TYPE);
if (!$type) {
$type = 'outbound';
}
$this->snmpClient->connect($DBServer->remoteIp, $port ? $port : 161, $DBFarm->Hash, null, null, false);
preg_match_all("/[0-9]+/si", $this->snmpClient->get($this->snmpOids[$type]), $matches);
$bw_out = (double) $matches[0][0];
$bw = round($bw_out / 1024 / 1024, 2);
$_roleBW[] = $bw;
}
$roleBW = round(array_sum($_roleBW) / count($_roleBW), 2);
if ($farmRoleMetric->getSetting(self::SETTING_BW_LAST_VALUE_RAW) !== null && $farmRoleMetric->getSetting(self::SETTING_BW_LAST_VALUE_RAW) !== '') {
$time = time() - $farmRoleMetric->dtLastPolled;
$bandwidth_usage = ($roleBW - (double) $farmRoleMetric->getSetting(self::SETTING_BW_LAST_VALUE_RAW)) * 8;
$bandwidth_channel_usage = $bandwidth_usage / $time;
// in Mbits/sec
$retval = round($bandwidth_channel_usage, 2);
} else {
$retval = 0;
}
$farmRoleMetric->setSetting(self::SETTING_BW_LAST_VALUE_RAW, $roleBW);
return array($retval);
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
$roleLA = 0;
if (count($servers) == 0) {
return false;
}
$retval = array();
foreach ($servers as $DBServer) {
if ($dbFarmRole->GetSetting(Entity\FarmRoleSetting::SCALING_EXCLUDE_DBMSR_MASTER) == 1) {
$isMaster = $DBServer->GetProperty(SERVER_PROPERTIES::DB_MYSQL_MASTER) == 1 || $DBServer->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER) == 1;
if ($isMaster) {
continue;
}
}
try {
$period = $farmRoleMetric->getSetting(self::SETTING_LA_PERIOD);
$index = 0;
if ($period == 15) {
$index = 2;
} elseif ($period == 5) {
$index = 1;
}
$la = $DBServer->scalarizr->system->loadAverage();
if ($la[$index] !== null && $la[$index] !== false) {
$la = (double) number_format($la[$index], 2);
}
$retval[] = $la;
} catch (Exception $e) {
\Scalr::getContainer()->logger(__CLASS__)->warn(new FarmLogMessage($DBServer->farmId, sprintf("Unable to read LoadAverage value from server %s: %s", $DBServer->getNameByConvention(), $e->getMessage()), $DBServer->serverId));
}
}
return count($retval) > 0 ? $retval : false;
}
public function makeDecision(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric, $isInvert = false)
{
//
// Get data from BW sensor
//
$dbFarm = $dbFarmRole->GetFarmObject();
$env = $dbFarm->GetEnvironmentObject();
$tz = $env->getPlatformConfigValue(ENVIRONMENT_SETTINGS::TIMEZONE);
if ($tz) {
$default_tz = @date_default_timezone_get();
@date_default_timezone_set($tz);
}
$currentDate = array((int) date("Hi"), date("D"));
if ($default_tz) {
@date_default_timezone_set($default_tz);
}
$scaling_period = $this->db->GetRow("SELECT * FROM farm_role_scaling_times WHERE\r\n\t\t\t\t'{$currentDate[0]}' >= start_time AND\r\n\t\t\t\t'{$currentDate[0]}' <= end_time-10 AND\r\n\t\t\t\tINSTR(days_of_week, '{$currentDate[1]}') != 0 AND\r\n\t\t\t\tfarm_roleid = '{$dbFarmRole->ID}'\r\n\t\t\t");
if ($scaling_period) {
$this->logger->info("TimeScalingAlgo({$dbFarmRole->FarmID}, {$dbFarmRole->AMIID}) Found scaling period. Total {$scaling_period['instances_count']} instances should be running.");
$num_instances = $scaling_period['instances_count'];
//$dbFarmRole->SetSetting(self::PROPERTY_NEED_INSTANCES_IN_CURRENT_PERIOD, $num_instances);
if ($dbFarmRole->GetRunningInstancesCount() + $dbFarmRole->GetPendingInstancesCount() < $num_instances) {
return Scalr_Scaling_Decision::UPSCALE;
} else {
return Scalr_Scaling_Decision::NOOP;
}
} else {
//$dbFarmRole->SetSetting(self::PROPERTY_NEED_INSTANCES_IN_CURRENT_PERIOD, "");
if ($dbFarmRole->GetRunningInstancesCount() > $dbFarmRole->GetSetting(DBFarmRole::SETTING_SCALING_MIN_INSTANCES)) {
return Scalr_Scaling_Decision::DOWNSCALE;
} else {
return Scalr_Scaling_Decision::NOOP;
}
}
}
public function makeDecision(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric, $isInvert = false)
{
// Get data from BW sensor
$dbFarm = $dbFarmRole->GetFarmObject();
$tz = $dbFarm->GetSetting(Entity\FarmSetting::TIMEZONE);
$date = new DateTime();
if ($tz) {
$date->setTimezone(new DateTimeZone($tz));
}
$currentDate = array((int) $date->format("Hi"), $date->format("D"));
$scaling_period = $this->db->GetRow("\n SELECT * FROM farm_role_scaling_times\n WHERE '{$currentDate[0]}' >= start_time\n AND '{$currentDate[0]}' <= end_time\n AND INSTR(days_of_week, '{$currentDate[1]}') != 0\n AND farm_roleid = '{$dbFarmRole->ID}'\n LIMIT 1\n ");
if ($scaling_period) {
$this->logger->info("TimeScalingAlgo({$dbFarmRole->FarmID}, {$dbFarmRole->ID}) Found scaling period. Total {$scaling_period['instances_count']} instances should be running.");
$this->instancesNumber = $scaling_period['instances_count'];
$this->lastValue = "(" . implode(' / ', $currentDate) . ") {$scaling_period['start_time']} - {$scaling_period['end_time']} = {$scaling_period['instances_count']}";
if ($dbFarmRole->GetRunningInstancesCount() + $dbFarmRole->GetPendingInstancesCount() < $this->instancesNumber) {
return Scalr_Scaling_Decision::UPSCALE;
} elseif ($dbFarmRole->GetRunningInstancesCount() + $dbFarmRole->GetPendingInstancesCount() > $this->instancesNumber) {
return Scalr_Scaling_Decision::DOWNSCALE;
} else {
return Scalr_Scaling_Decision::NOOP;
}
} else {
if ($dbFarmRole->GetRunningInstancesCount() > $dbFarmRole->GetSetting(Entity\FarmRoleSetting::SCALING_MIN_INSTANCES)) {
$this->lastValue = "No period defined. Using Min instances setting.";
return Scalr_Scaling_Decision::DOWNSCALE;
} else {
return Scalr_Scaling_Decision::NOOP;
}
}
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
$roleLA = 0;
if (count($servers) == 0) {
return false;
}
$retval = array();
foreach ($servers as $DBServer) {
if ($dbFarmRole->GetSetting(DBFarmRole::SETTING_SCALING_EXCLUDE_DBMSR_MASTER) == 1) {
$isMaster = $DBServer->GetProperty(SERVER_PROPERTIES::DB_MYSQL_MASTER) == 1 || $DBServer->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER) == 1;
if ($isMaster) {
continue;
}
}
$port = $DBServer->GetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT);
$period = $farmRoleMetric->getSetting(self::SETTING_LA_PERIOD);
if (!$period) {
$period = '15';
}
$this->snmpClient->connect($DBServer->remoteIp, $port ? $port : 161, $dbFarm->Hash, null, null, false);
$res = $this->snmpClient->get($this->snmpOids[$period]);
$la = (double) $res;
$retval[] = $la;
}
return $retval;
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$dbFarm = $dbFarmRole->GetFarmObject();
$AmazonSQS = AmazonSQS::GetInstance($dbFarm->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::ACCESS_KEY), $dbFarm->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::SECRET_KEY));
try {
$res = $AmazonSQS->GetQueueAttributes($farmRoleMetric->getSetting(self::SETTING_QUEUE_NAME));
$retval = $res['ApproximateNumberOfMessages'];
} catch (Exception $e) {
throw new Exception(sprintf("SQSScalingSensor failed during SQS request: %s", $e->getMessage()));
}
return array($retval);
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
$retval = array();
if (count($servers) == 0) {
return false;
}
foreach ($servers as $DBServer) {
$port = $DBServer->GetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT);
// Think about global cache
$this->snmpClient->connect($DBServer->remoteIp, $port ? $port : 161, $dbFarm->Hash, 7, null, true);
$res = $this->snmpClient->getFullTree(".1.3.6.1.4.1.36632.5");
$result = array();
foreach ($res as $oid => $value) {
preg_match("/^(.*?)\\.36632\\.5\\.1\\.([0-9]+)\\.([0-9]+)\$/", $oid, $matches);
switch ($matches[2]) {
case "1":
//index
$result['index'][$matches[3]] = $value;
break;
case "2":
//metric_id
$result['metric_id'][$matches[3]] = $value;
break;
case "3":
//metric_name
$result['metric_name'][$matches[3]] = $value;
break;
case "4":
//metric_value
$result['metric_value'][$matches[3]] = $value;
break;
case "5":
//error
$result['error'][$matches[3]] = $value;
break;
}
}
foreach ($result['metric_id'] as $index => $metric_id) {
if ($metric_id == $farmRoleMetric->metricId) {
if ($result['error'][$index]) {
throw new Exception(sprintf(_("%s metric error on '%s' (%s): %s"), $result['metric_name'][$index], $DBServer->serverId, $DBServer->remoteIp, $result['error'][$index]));
}
$retval[] = $result['metric_value'][$index];
break;
}
}
}
return $retval;
}
private function getDbAccessDetails(DBFarmRole $dbFarmRole)
{
$retval = array('username' => 'scalr', 'password' => '', 'dns' => false);
if ($dbFarmRole->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::POSTGRESQL)) {
$retval['password'] = $dbFarmRole->GetSetting(Scalr_Db_Msr_Postgresql::ROOT_PASSWORD);
$behavior = ROLE_BEHAVIORS::POSTGRESQL;
} elseif ($dbFarmRole->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::REDIS)) {
if ($dbFarmRole->GetSetting(Scalr_Db_Msr_Redis::USE_PASSWORD) == 1) {
$ports = @json_decode($dbFarmRole->GetSetting(Scalr_Db_Msr_Redis::PORTS_ARRAY));
$passwords = @json_decode($dbFarmRole->GetSetting(Scalr_Db_Msr_Redis::PASSWD_ARRAY));
if (!$ports && !$passwords) {
$retval['password'] = $dbFarmRole->GetSetting(Scalr_Db_Msr_Redis::MASTER_PASSWORD);
} else {
foreach ($ports as $i => $port) {
$retval['password'] .= "Port {$port}: {$passwords[$i]}<br>";
}
}
} else {
$retval['password'] = '******';
}
$behavior = ROLE_BEHAVIORS::REDIS;
} elseif ($dbFarmRole->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::MYSQL2)) {
$retval['password'] = $dbFarmRole->GetSetting(Scalr_Db_Msr_Mysql2::ROOT_PASSWORD);
$behavior = ROLE_BEHAVIORS::MYSQL2;
} elseif ($dbFarmRole->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::PERCONA)) {
$retval['password'] = $dbFarmRole->GetSetting(Scalr_Db_Msr_Percona::ROOT_PASSWORD);
$behavior = ROLE_BEHAVIORS::PERCONA;
} elseif ($dbFarmRole->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::MARIADB)) {
$retval['password'] = $dbFarmRole->GetSetting(Scalr_Db_Msr_Mariadb::ROOT_PASSWORD);
$behavior = ROLE_BEHAVIORS::MARIADB;
}
if (\Scalr::config('scalr.dns.static.enabled')) {
$retval['dns'] = array('master' => array('private' => "int.master.{$behavior}.{$dbFarmRole->GetFarmObject()->Hash}." . \Scalr::config('scalr.dns.static.domain_name'), 'public' => "ext.master.{$behavior}.{$dbFarmRole->GetFarmObject()->Hash}." . \Scalr::config('scalr.dns.static.domain_name')), 'slave' => array('private' => "int.slave.{$behavior}.{$dbFarmRole->GetFarmObject()->Hash}." . \Scalr::config('scalr.dns.static.domain_name'), 'public' => "ext.slave.{$behavior}.{$dbFarmRole->GetFarmObject()->Hash}." . \Scalr::config('scalr.dns.static.domain_name')));
}
return $retval;
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
$roleLA = 0;
if (count($servers) == 0) {
return false;
}
$retval = array();
foreach ($servers as $DBServer) {
if ($dbFarmRole->GetSetting(DBFarmRole::SETTING_SCALING_EXCLUDE_DBMSR_MASTER) == 1) {
$isMaster = $DBServer->GetProperty(SERVER_PROPERTIES::DB_MYSQL_MASTER) == 1 || $DBServer->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER) == 1;
if ($isMaster) {
continue;
}
}
try {
if ($DBServer->IsSupported('0.13.0')) {
$period = $farmRoleMetric->getSetting(self::SETTING_LA_PERIOD);
$index = 0;
if ($period == 15) {
$index = 2;
} elseif ($period == 5) {
$index = 1;
}
$la = $DBServer->scalarizr->system->loadAverage();
if ($la[$index] !== null && $la[$index] !== false) {
$la = (double) number_format($la[$index], 2);
}
} else {
$port = $DBServer->GetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT);
$period = $farmRoleMetric->getSetting(self::SETTING_LA_PERIOD);
if (!$period) {
$period = '15';
}
$this->snmpClient->connect($DBServer->remoteIp, $port ? $port : 161, $dbFarm->Hash, null, null, false);
$res = $this->snmpClient->get($this->snmpOids[$period]);
$la = (double) $res;
}
$retval[] = $la;
} catch (Exception $e) {
Logger::getLogger(__CLASS__)->warn(new FarmLogMessage($DBServer->farmId, sprintf("Unable to read LoadAverage value from server %s: %s", $DBServer->remoteIp, $e->getMessage())));
}
}
return count($retval) > 0 ? $retval : false;
}
public static function farmUpdateRoleSettings(DBFarmRole $DBFarmRole, $oldSettings, $newSettings)
{
$db = \Scalr::getDb();
if (!$newSettings[DBFarmRole::SETTING_AWS_USE_EBS] && $oldSettings[DBFarmRole::SETTING_AWS_USE_EBS]) {
$db->Execute("DELETE FROM ec2_ebs WHERE farm_roleid = ? AND ismanual='0'", array($DBFarmRole->ID));
//TODO: Remove Volume?
}
$DBFarm = $DBFarmRole->GetFarmObject();
if ($newSettings[DBFarmRole::SETTING_AWS_USE_EBS] && !$oldSettings[DBFarmRole::SETTING_AWS_USE_EBS]) {
$servers = $DBFarmRole->GetServersByFilter(array('status' => array(SERVER_STATUS::INIT, SERVER_STATUS::RUNNING)));
foreach ($servers as $DBServer) {
if (!$db->GetRow("SELECT id FROM ec2_ebs WHERE server_id=? AND ismanual='0' LIMIT 1", array($DBServer->serverId))) {
if (in_array($DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_TYPE), array('standard', 'io1'))) {
$type = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_TYPE);
} else {
$type = 'standard';
}
$DBEBSVolume = new DBEBSVolume();
$DBEBSVolume->attachmentStatus = EC2_EBS_ATTACH_STATUS::CREATING;
$DBEBSVolume->isManual = false;
$DBEBSVolume->ec2AvailZone = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_AVAIL_ZONE);
$DBEBSVolume->ec2Region = $DBFarmRole->CloudLocation;
$DBEBSVolume->farmId = $DBFarmRole->FarmID;
$DBEBSVolume->farmRoleId = $DBFarmRole->ID;
$DBEBSVolume->serverId = $DBServer->serverId;
$DBEBSVolume->serverIndex = $DBServer->index;
$DBEBSVolume->type = $type;
$DBEBSVolume->iops = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_IOPS);
$DBEBSVolume->size = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_SIZE);
$DBEBSVolume->snapId = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_SNAPID);
$DBEBSVolume->mount = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_MOUNT);
$DBEBSVolume->mountPoint = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_MOUNTPOINT);
$DBEBSVolume->mountStatus = $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_MOUNT) ? EC2_EBS_MOUNT_STATUS::AWAITING_ATTACHMENT : EC2_EBS_MOUNT_STATUS::NOT_MOUNTED;
$DBEBSVolume->clientId = $DBFarm->ClientID;
$DBEBSVolume->envId = $DBFarm->EnvID;
$DBEBSVolume->Save();
}
}
if ($newSettings[DBFarmRole::SETTING_AWS_EBS_MOUNTPOINT] != $oldSettings[DBFarmRole::SETTING_AWS_EBS_MOUNTPOINT]) {
$db->Execute("UPDATE ec2_ebs SET mountpoint=? WHERE farm_roleid=? AND ismanual='0'", array($DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_EBS_MOUNTPOINT), $DBFarmRole->ID));
}
}
}
public static function farmUpdateRoleSettings(DBFarmRole $DBFarmRole, $oldSettings, $newSettings)
{
$db = Core::GetDBInstance();
$DBFarm = $DBFarmRole->GetFarmObject();
if (!$oldSettings[DBFarmRole::SETTING_AWS_USE_ELASIC_IPS] && $newSettings[DBFarmRole::SETTING_AWS_USE_ELASIC_IPS]) {
$servers = $DBFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
if (count($servers) == 0) {
return;
}
$AmazonEC2Client = Scalr_Service_Cloud_Aws::newEc2($DBFarmRole->CloudLocation, $DBFarm->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::PRIVATE_KEY), $DBFarm->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::CERTIFICATE));
foreach ($servers as $DBServer) {
$address = $AmazonEC2Client->AllocateAddress();
$db->Execute("INSERT INTO elastic_ips SET env_id=?, farmid=?, farm_roleid=?, ipaddress=?, state='0', instance_id='', clientid=?, instance_index=?", array($DBServer->envId, $DBServer->farmId, $DBServer->farmRoleId, $address->publicIp, $DBServer->clientId, $DBServer->index));
Logger::getLogger(__CLASS__)->info(sprintf(_("Allocated new IP: %s"), $address->publicIp));
// Waiting...
Logger::getLogger(__CLASS__)->debug(_("Waiting 5 seconds..."));
sleep(5);
$assign_retries = 1;
while (true) {
try {
// Associate elastic ip address with instance
$AmazonEC2Client->AssociateAddress($DBServer->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID), $address->publicIp);
} catch (Exception $e) {
if (!stristr($e->getMessage(), "does not belong to you") || $assign_retries == 3) {
throw new Exception($e->getMessage());
} else {
// Waiting...
Logger::getLogger(__CLASS__)->debug(_("Waiting 2 seconds..."));
sleep(2);
$assign_retries++;
continue;
}
}
break;
}
Logger::getLogger(__CLASS__)->info(sprintf(_("IP: %s assigned to instance '%s'"), $address->publicIp, $DBServer->serverId));
// Update leastic IPs table
$db->Execute("UPDATE elastic_ips SET state='1', server_id=? WHERE ipaddress=?", array($DBServer->serverId, $address->publicIp));
Scalr::FireEvent($DBFarmRole->FarmID, new IPAddressChangedEvent($DBServer, $address->publicIp));
}
}
}
/**
*
* @param string $platform (From SERVER_PLATFORMS class)
* @param integer $farmid
* @param integer $farm_roleid
* @param integer $index
* @return void
*/
public function __construct($platform, DBFarmRole $DBFarmRole, $index = null, $role_id = null)
{
$this->platform = $platform;
$this->dbFarmRole = $DBFarmRole;
$this->index = $index;
$this->roleId = $role_id === null ? $this->dbFarmRole->RoleID : $role_id;
if ($DBFarmRole) {
$this->envId = $DBFarmRole->GetFarmObject()->EnvID;
}
//Refletcion
$Reflect = new ReflectionClass(DBServer::$platformPropsClasses[$this->platform]);
foreach ($Reflect->getConstants() as $k => $v) {
$this->platformProps[] = $v;
}
if ($DBFarmRole) {
switch ($this->platform) {
case SERVER_PLATFORMS::NIMBULA:
break;
case SERVER_PLATFORMS::EUCALYPTUS:
$this->SetProperties(array(EUCA_SERVER_PROPERTIES::REGION => $DBFarmRole->CloudLocation));
break;
case SERVER_PLATFORMS::OPENSTACK:
$this->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION => $DBFarmRole->CloudLocation));
break;
case SERVER_PLATFORMS::RACKSPACE:
$this->SetProperties(array(RACKSPACE_SERVER_PROPERTIES::DATACENTER => $DBFarmRole->CloudLocation));
break;
case SERVER_PLATFORMS::CLOUDSTACK:
$this->SetProperties(array(CLOUDSTACK_SERVER_PROPERTIES::CLOUD_LOCATION => $DBFarmRole->CloudLocation));
break;
case SERVER_PLATFORMS::EC2:
$this->SetProperties(array(EC2_SERVER_PROPERTIES::AVAIL_ZONE => $DBFarmRole->GetSetting(DBFarmRole::SETTING_AWS_AVAIL_ZONE), EC2_SERVER_PROPERTIES::REGION => $DBFarmRole->CloudLocation));
break;
case SERVER_PLATFORMS::RDS:
$this->SetProperties(array(RDS_SERVER_PROPERTIES::AVAIL_ZONE => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_AVAIL_ZONE), RDS_SERVER_PROPERTIES::REGION => $DBFarmRole->CloudLocation, RDS_SERVER_PROPERTIES::INSTANCE_CLASS => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_INSTANCE_CLASS), RDS_SERVER_PROPERTIES::STORAGE => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_STORAGE), RDS_SERVER_PROPERTIES::INSTANCE_ENGINE => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_INSTANCE_ENGINE), RDS_SERVER_PROPERTIES::MASTER_USER => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_MASTER_USER), RDS_SERVER_PROPERTIES::MASTER_PASS => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_MASTER_PASS), RDS_SERVER_PROPERTIES::MULTI_AZ => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_MULTI_AZ), RDS_SERVER_PROPERTIES::PORT => $DBFarmRole->GetSetting(DBFarmRole::SETTING_RDS_PORT)));
break;
}
$this->SetProperties(array(SERVER_PROPERTIES::SZR_VESION => $DBFarmRole->GetRoleObject()->szrVersion));
} else {
$this->SetProperties(array(SERVER_PROPERTIES::SZR_VESION => '0.5.0'));
}
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
if (count($servers) == 0) {
return false;
}
$retval = array();
foreach ($servers as $DBServer) {
if ($dbFarmRole->GetSetting(DBFarmRole::SETTING_SCALING_EXCLUDE_DBMSR_MASTER) == 1) {
$isMaster = $DBServer->GetProperty(SERVER_PROPERTIES::DB_MYSQL_MASTER) == 1 || $DBServer->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER) == 1;
if ($isMaster) {
continue;
}
}
if ($DBServer->IsSupported('0.13.0')) {
$szrClient = Scalr_Net_Scalarizr_Client::getClient($DBServer, Scalr_Net_Scalarizr_Client::NAMESPACE_SYSTEM, $DBServer->getPort(DBServer::PORT_API));
$ramUsage = $szrClient->memInfo();
$ram = (double) $ramUsage->total_free;
if ($farmRoleMetric->getSetting(self::SETTING_USE_CACHED)) {
$ram = $ram + (double) $ramUsage->cached;
}
} else {
$port = $DBServer->GetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT);
$this->snmpClient->connect($DBServer->remoteIp, $port ? $port : 161, $dbFarm->Hash, null, null, false);
$res = $this->snmpClient->get($this->snmpOids['memswap']);
preg_match_all("/[0-9]+/si", $res, $matches);
$ram = (double) $matches[0][0];
if ($farmRoleMetric->getSetting(self::SETTING_USE_CACHED)) {
$res = $this->snmpClient->get($this->snmpOids['cachedram']);
preg_match_all("/[0-9]+/si", $res, $matches);
$cram = (double) $matches[0][0];
$ram = $ram + $cram;
}
}
$retval[] = round($ram / 1024, 2);
}
return $retval;
}
public function makeDecision(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric, $isInvert = false)
{
// Get data from BW sensor
$dbFarm = $dbFarmRole->GetFarmObject();
$tz = $dbFarm->GetSetting(Entity\FarmSetting::TIMEZONE);
$date = new DateTime();
if ($tz) {
$date->setTimezone(new DateTimeZone($tz));
}
$currentDate = array((int) $date->format("Hi"), $date->format("D"), $date->format("H"), $date->format("i"));
$scalingPeriod = $this->db->GetRow("\n SELECT * FROM farm_role_scaling_times \n WHERE ? BETWEEN start_time AND end_time\n AND INSTR(days_of_week, ?) != 0 \n AND farm_roleid = ? \n LIMIT 1\n ", [$currentDate[0], $currentDate[1], $dbFarmRole->ID]);
$minInstances = $dbFarmRole->GetSetting(Entity\FarmRoleSetting::SCALING_MIN_INSTANCES);
if ($scalingPeriod) {
$this->logger->info("TimeScalingAlgo({$dbFarmRole->FarmID}, {$dbFarmRole->ID}) Found scaling period. Total {$scalingPeriod['instances_count']} instances should be running.");
$this->instancesNumber = $scalingPeriod['instances_count'];
$farmRoleRunningInstances = $dbFarmRole->GetRunningInstancesCount();
$farmRolePendingInstances = $dbFarmRole->GetPendingInstancesCount();
$roleTotalInstances = $farmRoleRunningInstances + $farmRolePendingInstances;
if ($roleTotalInstances == $this->instancesNumber) {
return Scalr_Scaling_Decision::NOOP;
} else {
$this->lastValue = sprintf("Current time '%s' matching rule '%s'. %s out of %s servers is currently running (pending)", "{$currentDate[1]}, {$currentDate[2]}:{$currentDate[3]}", "{$scalingPeriod['days_of_week']}: {$scalingPeriod['start_time']} - {$scalingPeriod['end_time']}", $roleTotalInstances, $this->instancesNumber);
if ($roleTotalInstances < $this->instancesNumber) {
return Scalr_Scaling_Decision::UPSCALE;
} elseif ($roleTotalInstances > $this->instancesNumber) {
return Scalr_Scaling_Decision::DOWNSCALE;
}
}
} else {
$this->instancesNumber = $minInstances;
if ($roleTotalInstances > $minInstances) {
$this->lastValue = sprintf("Current time '%s' has no matching rule. Maintaining minimum servers count (%s). %s out of %s servers is currently running (pending)", "{$currentDate[1]}, {$currentDate[2]} {$currentDate[3]}", $minInstances, $roleTotalInstances, $minInstances);
return Scalr_Scaling_Decision::DOWNSCALE;
} else {
return Scalr_Scaling_Decision::NOOP;
}
}
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
$retval = array();
if (count($servers) == 0) {
return array();
}
foreach ($servers as $dbServer) {
$metrics = $dbServer->scalarizr->system->scalingMetrics();
foreach ($metrics as $metric) {
if ($metric->id == $farmRoleMetric->metricId) {
if ($metric->error) {
\Scalr::getContainer()->logger(__CLASS__)->warn(new FarmLogMessage($dbServer->farmId, sprintf("Unable to read '%s' value from server %s: %s", $metric->name, $dbServer->getNameByConvention(), $metric->error), $dbServer->serverId));
} else {
$retval[] = $metric->value;
}
break;
}
}
}
return $retval;
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
if (count($servers) == 0) {
return false;
}
$retval = array();
foreach ($servers as $DBServer) {
if ($dbFarmRole->GetSetting(Entity\FarmRoleSetting::SCALING_EXCLUDE_DBMSR_MASTER) == 1) {
$isMaster = $DBServer->GetProperty(SERVER_PROPERTIES::DB_MYSQL_MASTER) == 1 || $DBServer->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER) == 1;
if ($isMaster) {
continue;
}
}
$ramUsage = $DBServer->scalarizr->system->memInfo();
$ram = (double) $ramUsage->total_free;
if ($farmRoleMetric->getSetting(self::SETTING_USE_CACHED)) {
$ram = $ram + (double) $ramUsage->cached;
}
$retval[] = round($ram / 1024, 2);
}
return $retval;
}
public function getValue(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric)
{
$servers = $dbFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$dbFarm = $dbFarmRole->GetFarmObject();
if (count($servers) == 0) {
return false;
}
$retval = array();
foreach ($servers as $DBServer) {
$port = $DBServer->GetProperty(SERVER_PROPERTIES::SZR_SNMP_PORT);
$this->snmpClient->connect($DBServer->remoteIp, $port ? $port : 161, $dbFarm->Hash, null, null, false);
$res = $this->snmpClient->get($this->snmpOids['memswap']);
preg_match_all("/[0-9]+/si", $res, $matches);
$ram = (double) $matches[0][0];
if ($farmRoleMetric->getSetting(self::SETTING_USE_CACHED)) {
$res = $this->snmpClient->get($this->snmpOids['cachedram']);
preg_match_all("/[0-9]+/si", $res, $matches);
$cram = (double) $matches[0][0];
$ram = $ram + $cram;
}
$retval[] = round($ram / 1024, 2);
}
return $retval;
}
protected function getFreshVolumeConfig()
{
$volumeConfig = new stdClass();
$volumeConfig->type = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_ENGINE);
$fsType = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_FSTYPE);
if ($fsType) {
$volumeConfig->fstype = $fsType;
}
$type = $volumeConfig->type;
// For any Block storage APIs
if (in_array($volumeConfig->type, array(MYSQL_STORAGE_ENGINE::RAID_EBS, MYSQL_STORAGE_ENGINE::RAID_GCE_PERSISTENT))) {
$volumeConfig->type = 'raid';
$volumeConfig->vg = $this->databaseType;
$volumeConfig->level = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_LEVEL);
$volumeConfig->disks = array();
for ($i = 1; $i <= $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_DISKS_COUNT); $i++) {
$dsk = new stdClass();
$dsk->size = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_DISK_SIZE);
if ($type == MYSQL_STORAGE_ENGINE::RAID_EBS) {
$dsk->type = MYSQL_STORAGE_ENGINE::EBS;
} else {
if ($type == MYSQL_STORAGE_ENGINE::RAID_GCE_PERSISTENT) {
$dsk->type = MYSQL_STORAGE_ENGINE::GCE_PERSISTENT;
}
}
$dsk->volumeType = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_EBS_DISK_TYPE);
if ($dsk->volumeType == 'io1') {
$dsk->iops = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_EBS_DISK_IOPS);
}
$volumeConfig->disks[] = $dsk;
}
$volumeConfig->snapPv = new stdClass();
$volumeConfig->snapPv->type = $dsk->type;
$volumeConfig->snapPv->size = 1;
} else {
if ($volumeConfig->type == MYSQL_STORAGE_ENGINE::CINDER) {
$volumeConfig->size = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_CINDER_SIZE);
} else {
if ($volumeConfig->type == MYSQL_STORAGE_ENGINE::GCE_PERSISTENT) {
$volumeConfig->size = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_GCED_SIZE);
} else {
if ($volumeConfig->type == MYSQL_STORAGE_ENGINE::EPH) {
if ($this->dbFarmRole->Platform == SERVER_PLATFORMS::RACKSPACE) {
$storageProvider = 'cf';
$volumeConfig->disk = new stdClass();
$volumeConfig->disk->type = 'loop';
$volumeConfig->disk->size = '75%root';
} elseif ($this->dbFarmRole->isOpenstack()) {
$storageProvider = 'swift';
$volumeConfig->disk = new stdClass();
$volumeConfig->disk->type = 'loop';
$volumeConfig->disk->size = '75%root';
} elseif ($this->dbFarmRole->Platform == SERVER_PLATFORMS::GCE) {
$storageProvider = 'gcs';
$volumeConfig->disk = array('type' => 'gce_ephemeral', 'name' => 'ephemeral-disk-0');
$volumeConfig->size = "80%";
} elseif ($this->dbFarmRole->Platform == SERVER_PLATFORMS::EC2) {
$storageProvider = 's3';
$disk = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK);
if ($disk) {
$volumeConfig->disk = $disk;
} else {
$disks = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISKS);
if ($disks) {
$diskType = 'ec2_ephemeral';
$v = json_decode($disks);
foreach ($v as $name => $size) {
$volumeConfig->disks[] = array('type' => $diskType, 'name' => $name);
}
}
}
$volumeConfig->size = "80%";
}
$volumeConfig->snap_backend = sprintf("%s://scalr-%s-%s/data-bundles/%s/%s", $storageProvider, $this->dbFarmRole->GetFarmObject()->EnvID, $this->dbFarmRole->CloudLocation, $this->dbFarmRole->FarmID, $this->databaseType);
$volumeConfig->vg = $this->databaseType;
} else {
$volumeConfig->size = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_SIZE);
$volumeConfig->volumeType = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_TYPE);
if ($volumeConfig->volumeType == 'io1') {
$volumeConfig->iops = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_IOPS);
}
}
}
}
}
return $volumeConfig;
}
public static function farmUpdateRoleSettings(DBFarmRole $dbFarmRole, $oldSettings, $newSettings)
{
$db = \Scalr::getDb();
$dbFarm = $dbFarmRole->GetFarmObject();
$dbFarmRole->SetSetting(DBFarmRole::SETIING_CLOUDSTACK_STATIC_NAT_MAP, null, DBFarmRole::TYPE_LCL);
$platform = PlatformFactory::NewPlatform($dbFarmRole->Platform);
$cs = Scalr_Service_Cloud_Cloudstack::newCloudstack($platform->getConfigVariable(Modules_Platforms_Cloudstack::API_URL, $dbFarm->GetEnvironmentObject()), $platform->getConfigVariable(Modules_Platforms_Cloudstack::API_KEY, $dbFarm->GetEnvironmentObject()), $platform->getConfigVariable(Modules_Platforms_Cloudstack::SECRET_KEY, $dbFarm->GetEnvironmentObject()), $dbFarmRole->Platform);
// Disassociate IP addresses if checkbox was unchecked
if (!$newSettings[DBFarmRole::SETIING_CLOUDSTACK_USE_STATIC_NAT] && $oldSettings[DBFarmRole::SETIING_CLOUDSTACK_USE_STATIC_NAT]) {
$eips = $db->Execute("\n SELECT * FROM elastic_ips WHERE farm_roleid = ?\n ", array($dbFarmRole->ID));
while ($eip = $eips->FetchRow()) {
try {
$cs->disassociateIpAddress($eip['allocation_id']);
} catch (Exception $e) {
}
}
$db->Execute("DELETE FROM elastic_ips WHERE farm_roleid = ?", array($dbFarmRole->ID));
}
//TODO: Handle situation when tab was not opened, but max instances setting was changed.
if ($newSettings[DBFarmRole::SETIING_CLOUDSTACK_STATIC_NAT_MAP] && $newSettings[DBFarmRole::SETIING_CLOUDSTACK_USE_STATIC_NAT]) {
$map = explode(";", $newSettings[DBFarmRole::SETIING_CLOUDSTACK_STATIC_NAT_MAP]);
foreach ($map as $ipconfig) {
list($serverIndex, $ipAddress) = explode("=", $ipconfig);
if (!$serverIndex) {
continue;
}
$dbServer = false;
try {
$dbServer = DBServer::LoadByFarmRoleIDAndIndex($dbFarmRole->ID, $serverIndex);
if ($dbServer->remoteIp == $ipAddress) {
continue;
}
// Remove old association
$db->Execute("\n DELETE FROM elastic_ips WHERE farm_roleid = ? AND instance_index=?\n ", array($dbFarmRole->ID, $serverIndex));
} catch (Exception $e) {
}
// Allocate new IP if needed
if (!$ipAddress || $ipAddress == '0.0.0.0') {
if ($dbServer) {
$ipAddress = self::setStaticNatForServer($dbServer);
} else {
continue;
}
} else {
//Remove old IP association
$db->Execute("\n DELETE FROM elastic_ips WHERE ipaddress=?\n ", array($ipAddress));
$info = $cs->listPublicIpAddresses(null, null, null, null, null, $ipAddress);
$info = $info->publicipaddress[0];
// Associate IP with server in our db
$db->Execute("INSERT INTO elastic_ips SET\n env_id=?,\n farmid=?,\n farm_roleid=?,\n ipaddress=?,\n state='0',\n instance_id='',\n clientid=?,\n instance_index=?,\n allocation_id=?\n ", array($dbFarm->EnvID, $dbFarmRole->FarmID, $dbFarmRole->ID, $ipAddress, $dbFarm->ClientID, $serverIndex, $info->id));
}
$ipInfo = $db->GetRow("SELECT allocation_id FROM elastic_ips WHERE ipaddress = ? LIMIT 1", $ipAddress);
// Associate IP on AWS with running server
if ($dbServer) {
try {
$db->Execute("UPDATE elastic_ips SET state='1', server_id = ? WHERE ipaddress = ?", array($dbServer->serverId, $ipAddress));
$update = false;
if ($dbServer->remoteIp != $ipAddress) {
if ($dbServer && $dbServer->status == SERVER_STATUS::RUNNING) {
$fireEvent = self::associateIpAddress($dbServer, $ipAddress, $ipInfo['allocation_id']);
}
}
if ($fireEvent) {
$event = new IPAddressChangedEvent($dbServer, $ipAddress, $dbServer->localIp);
Scalr::FireEvent($dbServer->farmId, $event);
}
} catch (Exception $e) {
}
}
}
}
}
public static function farmUpdateRoleSettings(DBFarmRole $DBFarmRole, $oldSettings, $newSettings)
{
try {
$DBFarm = $DBFarmRole->GetFarmObject();
$Client = Client::Load($DBFarm->ClientID);
$AmazonELB = Scalr_Service_Cloud_Aws::newElb($DBFarmRole->CloudLocation, $DBFarm->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::ACCESS_KEY), $DBFarm->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::SECRET_KEY));
// Load balancer settings
if ($newSettings[DBFarmRole::SETTING_BALANCING_USE_ELB] == 1) {
// Listeners
$DBFarmRole->ClearSettings("lb.role.listener");
$ELBListenersList = new ELBListenersList();
$li = 0;
foreach ($newSettings as $sk => $sv) {
if (stristr($sk, "lb.role.listener")) {
$li++;
$listener_chunks = explode("#", $sv);
$ELBListenersList->AddListener($listener_chunks[0], $listener_chunks[1], $listener_chunks[2], $listener_chunks[3]);
$DBFarmRole->SetSetting("lb.role.listener.{$li}", $sv);
}
}
$avail_zones = array();
$avail_zones_setting_hash = "";
foreach ($newSettings as $skey => $sval) {
if (preg_match("/^lb.avail_zone.(.*)?\$/", $skey, $macthes)) {
if ($macthes[1] != 'hash' && $macthes[1] != '.hash') {
if ($sval == 1) {
array_push($avail_zones, $macthes[1]);
}
$avail_zones_setting_hash .= "[{$macthes[1]}:{$sval}]";
}
}
}
if (!$DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME)) {
$elb_name = sprintf("scalr-%s-%s", $DBFarm->Hash, rand(100, 999));
//CREATE NEW ELB
$elb_dns_name = $AmazonELB->CreateLoadBalancer($elb_name, $avail_zones, $ELBListenersList);
if ($elb_dns_name) {
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME, $elb_dns_name);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_NAME, $elb_name);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_AZ_HASH, $avail_zones_setting_hash);
$register_servers = true;
}
}
if ($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME)) {
$ELBHealthCheckType = new ELBHealthCheckType($newSettings[DBFarmRole::SETTING_BALANCING_HC_TARGET], $newSettings[DBFarmRole::SETTING_BALANCING_HC_HTH], $newSettings[DBFarmRole::SETTING_BALANCING_HC_INTERVAL], $newSettings[DBFarmRole::SETTING_BALANCING_HC_TIMEOUT], $newSettings[DBFarmRole::SETTING_BALANCING_HC_UTH]);
$hash = md5(serialize($ELBHealthCheckType));
if ($elb_name || $hash != $DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH)) {
//UPDATE CURRENT ELB
$AmazonELB->ConfigureHealthCheck($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME), $ELBHealthCheckType);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH, $hash);
}
// Configure AVAIL zones for the LB
if (!$elb_name && $avail_zones_setting_hash != $DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_AZ_HASH)) {
$info = $AmazonELB->DescribeLoadBalancers(array($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME)));
$elb = $info->DescribeLoadBalancersResult->LoadBalancerDescriptions->member;
$c = (array) $elb->AvailabilityZones;
if (!is_array($c['member'])) {
$c_zones = array($c['member']);
} else {
$c_zones = $c['member'];
}
$add_avail_zones = array();
$rem_avail_zones = array();
foreach ($newSettings as $skey => $sval) {
if (preg_match("/^lb.avail_zone.(.*)?\$/", $skey, $m)) {
if ($sval == 1 && !in_array($m[1], $c_zones)) {
array_push($add_avail_zones, $m[1]);
}
if ($sval == 0 && in_array($m[1], $c_zones)) {
array_push($rem_avail_zones, $m[1]);
}
}
}
if (count($add_avail_zones) > 0) {
$AmazonELB->EnableAvailabilityZonesForLoadBalancer($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME), $add_avail_zones);
}
if (count($rem_avail_zones) > 0) {
$AmazonELB->DisableAvailabilityZonesForLoadBalancer($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME), $rem_avail_zones);
}
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_AZ_HASH, $avail_zones_setting_hash);
}
}
if ($register_servers) {
$servers = $DBFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$instances = array();
foreach ($servers as $DBServer) {
$instances[] = $DBServer->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID);
}
if (count($instances) > 0) {
$AmazonELB->RegisterInstancesWithLoadBalancer($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME), $instances);
}
}
} else {
if ($oldSettings[DBFarmRole::SETTING_BALANCING_HOSTNAME]) {
try {
$AmazonELB->DeleteLoadBalancer($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME));
} catch (Exception $e) {
}
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_NAME, "");
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME, "");
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_USE_ELB, "0");
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH, "");
$DBFarmRole->ClearSettings("lb.avail_zone");
$DBFarmRole->ClearSettings("lb.healthcheck");
$DBFarmRole->ClearSettings("lb.role.listener");
}
}
} catch (Exception $e) {
throw new Exception("Error with ELB on Role '{$DBFarmRole->GetRoleObject()->name}': {$e->getMessage()}");
}
}
public static function farmUpdateRoleSettings(DBFarmRole $DBFarmRole, $oldSettings, $newSettings)
{
//Conver OLD ELB settings into NEW ELB SETTINGS
if ($newSettings[DBFarmRole::SETTING_BALANCING_USE_ELB] == 1 && !$newSettings[DBFarmRole::SETTING_AWS_ELB_ENABLED]) {
$newSettings[DBFarmRole::SETTING_AWS_ELB_ENABLED] = 1;
$newSettings[DBFarmRole::SETTING_AWS_ELB_ID] = $newSettings[DBFarmRole::SETTING_BALANCING_NAME];
$DBFarmRole->SetSetting(DBFarmRole::SETTING_AWS_ELB_ENABLED, 1, DBFarmRole::TYPE_CFG);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_AWS_ELB_ID, $newSettings[DBFarmRole::SETTING_BALANCING_NAME], DBFarmRole::TYPE_LCL);
}
//NEW ELB:
try {
$DBFarm = $DBFarmRole->GetFarmObject();
$elb = $DBFarm->GetEnvironmentObject()->aws($DBFarmRole)->elb;
/*
* aws.elb.enabled
* aws.elb.id":"scalr-97f8a108ce4100-775",
* aws.elb.remove
*/
if ($newSettings[DBFarmRole::SETTING_AWS_ELB_ENABLED]) {
if ($oldSettings[DBFarmRole::SETTING_AWS_ELB_ID] == $newSettings[DBFarmRole::SETTING_AWS_ELB_ID]) {
return true;
}
// Setup new service
// ADD ELB to role_cloud_services
$service = new FarmRoleService($DBFarmRole, $newSettings[DBFarmRole::SETTING_AWS_ELB_ID]);
$service->setType(FarmRoleService::SERVICE_AWS_ELB);
$service->save();
// Add running instances to ELB
$servers = $DBFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$newInstances = array();
foreach ($servers as $DBServer) {
$newInstances[] = $DBServer->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID);
}
try {
if (count($newInstances) > 0) {
$elb->loadBalancer->registerInstances($newSettings[DBFarmRole::SETTING_AWS_ELB_ID], $newInstances);
}
} catch (Exception $e) {
}
try {
//Check and deregister old instances instances
$list = $elb->loadBalancer->describeInstanceHealth($newSettings[DBFarmRole::SETTING_AWS_ELB_ID], array());
/* @var $instance \Scalr\Service\Aws\Elb\DataType\InstanceStateData */
$instances = array();
foreach ($list as $instance) {
if (!in_array($instance->instanceId, $newInstances)) {
array_push($instances, $instance->instanceId);
}
}
if (count($instances) > 0) {
$elb->loadBalancer->deregisterInstances($newSettings[DBFarmRole::SETTING_AWS_ELB_ID], $instances);
}
} catch (Exception $e) {
}
} else {
$clearSettings = true;
}
if ($newSettings['aws.elb.remove']) {
if ($newSettings[DBFarmRole::SETTING_AWS_ELB_ID]) {
$elb->loadBalancer->delete($newSettings[DBFarmRole::SETTING_AWS_ELB_ID]);
}
$clearSettings = true;
}
if ($clearSettings) {
$DBFarmRole->ClearSettings("aws.elb.");
$service = new FarmRoleService($DBFarmRole, $newSettings[DBFarmRole::SETTING_AWS_ELB_ID]);
$service->remove();
}
// Check and remove OLD ELB settings
if ($newSettings['aws.elb.enabled'] && $DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME)) {
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_NAME, null, DBFarmRole::TYPE_LCL);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME, null, DBFarmRole::TYPE_LCL);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_USE_ELB, null, DBFarmRole::TYPE_LCL);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH, null, DBFarmRole::TYPE_LCL);
$DBFarmRole->ClearSettings("lb.avail_zone");
$DBFarmRole->ClearSettings("lb.healthcheck");
$DBFarmRole->ClearSettings("lb.role.listener");
}
} catch (Exception $e) {
throw new Exception("Error with ELB on Role '{$DBFarmRole->GetRoleObject()->name}': {$e->getMessage()}");
}
//OLD ELB
/*
try {
// Load balancer settings
if ($newSettings[DBFarmRole::SETTING_BALANCING_USE_ELB] == 1) {
// Listeners
$DBFarmRole->ClearSettings("lb.role.listener");
$listenersList = new ListenerList();
$li = 0;
foreach ($newSettings as $sk => $sv) {
if (stristr($sk, "lb.role.listener")) {
$li++;
$listener_chunks = explode("#", $sv);
$listenersList->append(new ListenerData(
trim($listener_chunks[1]), trim($listener_chunks[2]),
trim($listener_chunks[0]), null,
trim($listener_chunks[3])
));
$DBFarmRole->SetSetting("lb.role.listener.{$li}", str_replace(" ", "", $sv));
}
}
$avail_zones = array();
$avail_zones_setting_hash = "";
foreach ($newSettings as $skey => $sval) {
if (preg_match("/^lb.avail_zone.(.*)?$/", $skey, $macthes)) {
if ($macthes[1] != 'hash' && $macthes[1] != '.hash') {
if ($sval == 1) {
array_push($avail_zones, $macthes[1]);
}
$avail_zones_setting_hash .= "[{$macthes[1]}:{$sval}]";
}
}
}
if (!$DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME)) {
$elb_name = sprintf("scalr-%s-%s", $DBFarm->Hash, rand(100,999));
//Creates a new ELB
$elb_dns_name = $elb->loadBalancer->create($elb_name, $listenersList, $avail_zones);
if (!empty($elb_dns_name)) {
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME, $elb_dns_name);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_NAME, $elb_name);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_AZ_HASH, $avail_zones_setting_hash);
$register_servers = true;
}
}
if ($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME)) {
$healthCheckType = new HealthCheckData();
$healthCheckType->target = $newSettings[DBFarmRole::SETTING_BALANCING_HC_TARGET];
$healthCheckType->healthyThreshold = $newSettings[DBFarmRole::SETTING_BALANCING_HC_HTH];
$healthCheckType->interval = $newSettings[DBFarmRole::SETTING_BALANCING_HC_INTERVAL];
$healthCheckType->timeout = $newSettings[DBFarmRole::SETTING_BALANCING_HC_TIMEOUT];
$healthCheckType->unhealthyThreshold = $newSettings[DBFarmRole::SETTING_BALANCING_HC_UTH];
$hash = md5(serialize(array(
$healthCheckType->target,
$healthCheckType->healthyThreshold,
$healthCheckType->interval,
$healthCheckType->timeout,
$healthCheckType->unhealthyThreshold,
)));
if ($elb_name || ($hash != $DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH))) {
//Updates current Elb
$elb->loadBalancer->configureHealthCheck(
$DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME), $healthCheckType
);
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH, $hash);
}
// Configure AVAIL zones for the LB
if (!$elb_name && $avail_zones_setting_hash != $DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_AZ_HASH)) {
$lb = $elb->loadBalancer->describe($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME))->get(0);
$add_avail_zones = array();
$rem_avail_zones = array();
foreach ($newSettings as $skey => $sval) {
if (preg_match("/^lb.avail_zone.(.*)?$/", $skey, $m)) {
if ($sval == 1 && !in_array($m[1], $lb->availabilityZones)) {
array_push($add_avail_zones, $m[1]);
}
if ($sval == 0 && in_array($m[1], $lb->availabilityZones)) {
array_push($rem_avail_zones, $m[1]);
}
}
}
if (count($add_avail_zones) > 0) {
$lb->enableAvailabilityZones($add_avail_zones);
}
if (count($rem_avail_zones) > 0) {
$lb->disableAvailabilityZones($rem_avail_zones);
}
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_AZ_HASH, $avail_zones_setting_hash);
}
}
if ($register_servers) {
$servers = $DBFarmRole->GetServersByFilter(array('status' => SERVER_STATUS::RUNNING));
$instances = array();
foreach ($servers as $DBServer) {
$instances[] = $DBServer->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID);
}
if (count($instances) > 0) {
$elb->loadBalancer->registerInstances($elb_name, $instances);
}
}
} else {
if ($oldSettings[DBFarmRole::SETTING_BALANCING_HOSTNAME]) {
try {
$elb->loadBalancer->delete($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME));
} catch (Exception $e) {
}
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_NAME, "");
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HOSTNAME, "");
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_USE_ELB, "0");
$DBFarmRole->SetSetting(DBFarmRole::SETTING_BALANCING_HC_HASH, "");
$DBFarmRole->ClearSettings("lb.avail_zone");
$DBFarmRole->ClearSettings("lb.healthcheck");
$DBFarmRole->ClearSettings("lb.role.listener");
}
}
} catch (Exception $e) {
throw new Exception("Error with ELB on Role '{$DBFarmRole->GetRoleObject()->name}': {$e->getMessage()}");
}
*/
}
public function setVolumeConfig($volumeConfig, DBFarmRole $dbFarmRole, DBServer $dbServer)
{
try {
$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' => $dbFarmRole->GetFarmObject()->ClientID, 'env_id' => $dbFarmRole->GetFarmObject()->EnvID, 'name' => sprintf("'%s' data volume", $this->behavior), 'type' => $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE), 'platform' => $dbFarmRole->Platform, 'size' => $volumeConfig->size, 'fstype' => $volumeConfig->fstype, 'purpose' => $this->behavior, 'farm_roleid' => $dbFarmRole->ID, 'server_index' => $dbServer->index));
$storageVolume->setConfig($volumeConfig);
$storageVolume->save(true);
} else {
throw $e;
}
}
$dbFarmRole->SetSetting(static::ROLE_VOLUME_ID, $storageVolume->id, DBFarmRole::TYPE_LCL);
} catch (Exception $e) {
$this->logger->error(new FarmLogMessage($dbFarmRole->FarmID, "Cannot save storage volume: {$e->getMessage()}"));
}
}
private function getInitialSecurityGroupsList(DBFarmRole $dbFarmRole)
{
$additionalSecurityGroups = $dbFarmRole->GetSetting(DBFarmRole::SETTING_AWS_SG_LIST);
$append = $dbFarmRole->GetSetting(DBFarmRole::SETTING_AWS_SG_LIST_APPEND);
if ($append === null || $append == 1 || $append == 0 && $additionalSecurityGroups === null) {
$retval = array('default', \Scalr::config('scalr.aws.security_group_name'));
if (!$dbFarmRole->GetFarmObject()->GetSetting(DBFarm::SETTING_EC2_VPC_ID)) {
$retval = array_merge($retval, array("scalr-farm.{$dbFarmRole->FarmID}", "scalr-role.{$dbFarmRole->ID}"));
}
} else {
$retval = array();
}
if ($additionalSecurityGroups !== null) {
$additionalSecurityGroups = explode(",", $additionalSecurityGroups);
foreach ($additionalSecurityGroups as $sg) {
$sg = trim($sg);
if ($sg) {
array_push($retval, $sg);
}
}
}
return $retval;
}
public function getVolumeConfig(DBFarmRole $dbFarmRole, DBServer $dbServer)
{
try {
$volume = Scalr_Storage_Volume::init()->loadByFarmRoleServer($dbFarmRole->ID, $dbServer->index, $this->behavior);
$volumeConfig = $volume->getConfig();
} catch (Exception $e) {
}
if (!$volumeConfig) {
$volumeConfig = new stdClass();
$volumeConfig->type = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE);
switch ($volumeConfig->type) {
case MYSQL_STORAGE_ENGINE::EPH:
if ($dbFarmRole->Platform == SERVER_PLATFORMS::RACKSPACE) {
$storageProvider = 'cf';
$volumeConfig->disk = new stdClass();
$volumeConfig->disk->type = 'loop';
$volumeConfig->disk->size = '75%root';
} elseif ($dbFarmRole->isOpenstack()) {
$storageProvider = 'swift';
$volumeConfig->disk = new stdClass();
$volumeConfig->disk->type = 'loop';
$volumeConfig->disk->size = '75%root';
} elseif ($dbFarmRole->Platform == SERVER_PLATFORMS::GCE) {
$storageProvider = 'gcs';
$volumeConfig->disk = array('type' => 'gce_ephemeral', 'name' => 'ephemeral-disk-0');
$volumeConfig->size = "80%";
} elseif ($dbFarmRole->Platform == SERVER_PLATFORMS::EC2) {
/*
* NOT SUPPORTED
$storageProvider = 's3';
$volumeConfig->disk = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK);
$volumeConfig->size = "80%";
*/
}
$volumeConfig->snap_backend = sprintf("%s://scalr-%s-%s/data-bundles/%s/%s", $storageProvider, $dbFarmRole->GetFarmObject()->EnvID, $dbFarmRole->CloudLocation, $dbFarmRole->FarmID, $this->behavior);
$volumeConfig->vg = $this->behavior;
break;
default:
$volumeConfig->size = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_EBS_SIZE);
break;
}
}
return $volumeConfig;
}
public static function farmUpdateRoleSettings(DBFarmRole $DBFarmRole, $oldSettings, $newSettings)
{
$db = \Scalr::getDb();
$DBFarm = $DBFarmRole->GetFarmObject();
$DBFarmRole->SetSetting(DBFarmRole::SETTING_AWS_ELASIC_IPS_MAP, null, DBFarmRole::TYPE_LCL);
$isVPC = $DBFarm->GetSetting(DBFarm::SETTING_EC2_VPC_ID);
$aws = $DBFarm->GetEnvironmentObject()->aws($DBFarmRole->CloudLocation);
// Disassociate IP addresses if checkbox was unchecked
if (!$newSettings[DBFarmRole::SETTING_AWS_USE_ELASIC_IPS] && $oldSettings[DBFarmRole::SETTING_AWS_USE_ELASIC_IPS]) {
$eips = $db->Execute("\n SELECT * FROM elastic_ips WHERE farm_roleid = ?\n ", array($DBFarmRole->ID));
while ($eip = $eips->FetchRow()) {
try {
$aws->ec2->address->disassociate($eip['ipaddress']);
} catch (Exception $e) {
}
}
$db->Execute("\n DELETE FROM elastic_ips\n WHERE farm_roleid = ?\n ", array($DBFarmRole->ID));
}
//TODO: Handle situation when tab was not opened, but max instances setting was changed.
if ($newSettings[DBFarmRole::SETTING_AWS_ELASIC_IPS_MAP] && $newSettings[DBFarmRole::SETTING_AWS_USE_ELASIC_IPS]) {
$map = explode(";", $newSettings[DBFarmRole::SETTING_AWS_ELASIC_IPS_MAP]);
foreach ($map as $ipconfig) {
list($serverIndex, $ipAddress) = explode("=", $ipconfig);
if (!$serverIndex) {
continue;
}
try {
$dbServer = DBServer::LoadByFarmRoleIDAndIndex($DBFarmRole->ID, $serverIndex);
} catch (Exception $e) {
}
// Allocate new IP if needed
if (!$ipAddress || $ipAddress == '0.0.0.0') {
if ($dbServer) {
$domain = $isVPC ? 'vpc' : null;
$address = $aws->ec2->address->allocate($domain);
$ipAddress = $address->publicIp;
$allocationId = $address->allocationId;
} else {
continue;
}
}
// Remove old association
$db->Execute("\n DELETE FROM elastic_ips\n WHERE farm_roleid = ? AND instance_index=?\n ", array($DBFarmRole->ID, $serverIndex));
if ($ipAddress) {
//Remove old IP association
$db->Execute("\n DELETE FROM elastic_ips\n WHERE ipaddress=?\n ", array($ipAddress));
if (!$allocationId && $isVPC) {
$allocationId = $aws->ec2->address->describe($ipAddress)->get(0)->allocationId;
}
// Associate IP with server in our db
$db->Execute("\n INSERT INTO elastic_ips\n SET env_id=?,\n farmid=?,\n farm_roleid=?,\n ipaddress=?,\n state='0',\n instance_id='',\n clientid=?,\n instance_index=?,\n allocation_id=?\n ", array($DBFarm->EnvID, $DBFarmRole->FarmID, $DBFarmRole->ID, $ipAddress, $DBFarm->ClientID, $serverIndex, $allocationId));
// Associate IP on AWS with running server
try {
$dbServer = DBServer::LoadByFarmRoleIDAndIndex($DBFarmRole->ID, $serverIndex);
$db->Execute("\n UPDATE elastic_ips\n SET state='1',\n server_id = ?\n WHERE ipaddress = ?\n ", array($dbServer->serverId, $ipAddress));
$update = false;
if ($dbServer->remoteIp != $ipAddress) {
if ($dbServer && $dbServer->status == SERVER_STATUS::RUNNING) {
$fireEvent = self::associateIpAddress($dbServer, $ipAddress, $isVPC ? $allocationId : null);
}
}
if ($fireEvent) {
$event = new IPAddressChangedEvent($dbServer, $ipAddress, $dbServer->localIp);
Scalr::FireEvent($dbServer->farmId, $event);
}
} catch (Exception $e) {
}
} else {
Logger::getLogger(LOG_CATEGORY::FARM)->fatal(sprintf(_("Cannot allocate elastic ip address for instance %s on farm %s (2)"), $dbServer->serverId, $DBFarm->Name));
}
}
}
}
public function setVolumeConfig($volumeConfig, DBFarmRole $dbFarmRole, DBServer $dbServer, $configServerIndex = null)
{
if ($configServerIndex === null) {
$name = sprintf("'%s' data volume", $this->behavior);
} else {
$name = sprintf("'%s' config server #%s volume", $this->behavior, $configServerIndex);
}
try {
$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' => $dbFarmRole->GetFarmObject()->ClientID, 'env_id' => $dbFarmRole->GetFarmObject()->EnvID, 'name' => $name, 'type' => $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE), 'platform' => $dbFarmRole->Platform, 'size' => $volumeConfig->size, 'fstype' => $volumeConfig->fstype, 'purpose' => $this->behavior, 'farm_roleid' => $dbFarmRole->ID, 'server_index' => $dbServer->index));
$storageVolume->setConfig($volumeConfig);
$storageVolume->save(true);
} else {
throw $e;
}
}
if ($configServerIndex === null) {
$this->db->Execute("INSERT INTO services_mongodb_volumes_map SET\n farm_roleid = ?,\n replica_set_index = ?,\n shard_index = ?,\n volume_id = ? ON DUPLICATE KEY UPDATE volume_id = ?\n ", array($dbFarmRole->ID, $dbServer->GetProperty(self::SERVER_REPLICA_SET_INDEX), $dbServer->GetProperty(self::SERVER_SHARD_INDEX), $volumeConfig->id, $volumeConfig->id));
} else {
$this->db->Execute("INSERT INTO services_mongodb_config_servers SET\n farm_role_id = ?,\n config_server_index = ?,\n replica_set_index = ?,\n shard_index = ?,\n volume_id = ? ON DUPLICATE KEY UPDATE volume_id = ?, replica_set_index = ?, shard_index = ?\n ", array($dbFarmRole->ID, $configServerIndex, $dbServer->GetProperty(self::SERVER_REPLICA_SET_INDEX), $dbServer->GetProperty(self::SERVER_SHARD_INDEX), $volumeConfig->id, $volumeConfig->id, $dbServer->GetProperty(self::SERVER_REPLICA_SET_INDEX), $dbServer->GetProperty(self::SERVER_SHARD_INDEX)));
}
} catch (Exception $e) {
$this->logger->error(new FarmLogMessage($dbFarmRole->FarmID, "Cannot save storage volume: {$e->getMessage()}"));
}
}
protected function buildStorageSettings()
{
if ($this->dbFarmRole->GetSetting(Scalr_Db_Msr::VOLUME_ID) && $this->replicationMaster) {
try {
$volume = Scalr_Storage_Volume::init()->loadById($this->dbFarmRole->GetSetting(Scalr_Db_Msr::VOLUME_ID));
$this->volumeConfig = $volume->getConfig();
} catch (Exception $e) {
}
}
/***
* For Rackspace we ALWAYS need snapsjot_config for mysql
* ***/
if ($this->dbFarmRole->GetSetting(Scalr_Db_Msr::SNAPSHOT_ID)) {
try {
$snapshotConfig = Scalr_Model::init(Scalr_Model::STORAGE_SNAPSHOT)->loadById($this->dbFarmRole->GetSetting(Scalr_Db_Msr::SNAPSHOT_ID));
$this->snapshotConfig = $snapshotConfig->getConfig();
} catch (Exception $e) {
$this->logger->error(new FarmLogMessage($this->dbServer->farmId, "Cannot get snaphotConfig for hostInit message: {$e->getMessage()}"));
}
}
//TODO:
/** If new role and there is no volume, we need to create a new one **/
if ($this->replicationMaster && !$this->volumeConfig) {
$this->volumeConfig = new stdClass();
$this->volumeConfig->type = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_ENGINE);
// For any Block storage APIs
if ($this->volumeConfig->type == MYSQL_STORAGE_ENGINE::RAID_EBS) {
$this->volumeConfig->type = 'raid';
$this->volumeConfig->vg = $this->databaseType;
$this->volumeConfig->level = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_LEVEL);
$this->volumeConfig->disks = array();
for ($i = 1; $i <= $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_DISKS_COUNT); $i++) {
$dsk = new stdClass();
$dsk->type = 'ebs';
$dsk->size = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_RAID_DISK_SIZE);
$this->volumeConfig->disks[] = $dsk;
}
$this->volumeConfig->snapPv = new stdClass();
$this->volumeConfig->snapPv->type = 'ebs';
$this->volumeConfig->snapPv->size = 1;
} else {
if ($this->volumeConfig->type != MYSQL_STORAGE_ENGINE::EPH && $this->volumeConfig->type != MYSQL_STORAGE_ENGINE::RAID_EBS) {
$this->volumeConfig->size = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EBS_SIZE);
} else {
if ($this->volumeConfig->type == MYSQL_STORAGE_ENGINE::EPH) {
if ($this->dbFarmRole->Platform == SERVER_PLATFORMS::RACKSPACE) {
$this->volumeConfig->snap_backend = sprintf("cf://scalr-%s-%s/data-bundles/%s/%s", $this->dbFarmRole->GetFarmObject()->EnvID, $this->dbFarmRole->CloudLocation, $this->dbFarmRole->FarmID, $this->databaseType);
$this->volumeConfig->vg = $this->databaseType;
$this->volumeConfig->disk = new stdClass();
$this->volumeConfig->disk->type = 'loop';
$this->volumeConfig->disk->size = '75%root';
} elseif ($this->dbFarmRole->Platform == SERVER_PLATFORMS::EC2) {
$this->volumeConfig->snap_backend = sprintf("s3://scalr-%s-%s/data-bundles/%s/%s", $this->dbFarmRole->GetFarmObject()->EnvID, $this->dbFarmRole->CloudLocation, $this->dbFarmRole->FarmID, $this->databaseType);
$this->volumeConfig->vg = $this->databaseType;
$this->volumeConfig->disk = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK);
$this->volumeConfig->size = "80%";
}
}
}
}
}
}
