Get Role setting by name
public GetSetting ( string $name ) : mixed | ||
$name | string | |
return | mixed |
public function makeDecision(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric, $isInvert = false) { if ($farmRoleMetric->lastValue > $farmRoleMetric->getSetting('max')) { $retval = Scalr_Scaling_Decision::UPSCALE; } elseif ($farmRoleMetric->lastValue < $farmRoleMetric->getSetting('min')) { $retval = Scalr_Scaling_Decision::DOWNSCALE; } if (!$retval) { return Scalr_Scaling_Decision::NOOP; } else { if ($isInvert) { if ($retval == Scalr_Scaling_Decision::UPSCALE) { $retval = Scalr_Scaling_Decision::DOWNSCALE; } else { $retval = Scalr_Scaling_Decision::UPSCALE; } } if ($retval == Scalr_Scaling_Decision::UPSCALE) { if ($dbFarmRole->GetRunningInstancesCount() + $dbFarmRole->GetPendingInstancesCount() >= $dbFarmRole->GetSetting(Entity\FarmRoleSetting::SCALING_MAX_INSTANCES)) { $retval = Scalr_Scaling_Decision::NOOP; } } if ($retval == Scalr_Scaling_Decision::DOWNSCALE) { if ($dbFarmRole->GetRunningInstancesCount() <= $dbFarmRole->GetSetting(Entity\FarmRoleSetting::SCALING_MIN_INSTANCES)) { $retval = Scalr_Scaling_Decision::NOOP; } } $isSzr = true; if ($retval == Scalr_Scaling_Decision::UPSCALE && ($dbFarmRole->GetPendingInstancesCount() > 5 && !$isSzr)) { return Scalr_Scaling_Decision::NOOP; } else { 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(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 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 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 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 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 function createDataBundle(DBFarmRole $dbFarmRole, array $params = array()) { if (!$params['dataBundleType']) { $params['dataBundleType'] = 'full'; } if ($params['compressor'] === null) { $params['compressor'] = 'gzip'; } //$params['useSlave'] if ($dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_BUNDLE_IS_RUNNING) == 1) { throw new Exception("Data bundle already in progress"); } $currentServer = $this->getServerForDataBundle($dbFarmRole, $params['useSlave']); if (!$currentServer) { throw new Exception("No suitable server for data bundle"); } $message = new Scalr_Messaging_Msg_DbMsr_CreateDataBundle(); $storageType = $dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_ENGINE); $storageGeneration = $storageType == 'lvm' ? 2 : 1; if ($dbFarmRole->isOpenstack()) { $driver = 'swift'; } else { switch ($dbFarmRole->Platform) { case SERVER_PLATFORMS::EC2: $driver = 's3'; break; case SERVER_PLATFORMS::GCE: $driver = 'gcs'; break; } } if ($storageGeneration == 2) { $behavior = $dbFarmRole->GetRoleObject()->getDbMsrBehavior(); if (!isset($message->{$behavior})) { $message->{$behavior} = new stdClass(); } $message->{$behavior}->backup = new stdClass(); $message->{$behavior}->backup->type = 'xtrabackup'; $message->{$behavior}->backup->compressor = $params['compressor']; $message->{$behavior}->backup->backupType = $params['dataBundleType']; $message->{$behavior}->backup->cloudfsTarget = sprintf("%s://scalr-%s-%s-%s/data-bundles/%s/%s/", $driver, SCALR_ID, $dbFarmRole->GetFarmObject()->EnvID, $dbFarmRole->CloudLocation, $dbFarmRole->FarmID, $behavior); if ($params['dataBundleType'] == 'incremental') { $previousManifest = $this->db->GetOne("SELECT manifest FROM storage_restore_configs WHERE farm_roleid = ? ORDER BY id DESC LIMIT 1", array($dbFarmRole->ID)); $message->{$behavior}->backup->prevCloudfsSource = $previousManifest; } } $message->storageType = $storageType; $currentServer->SendMessage($message); $dbFarmRole->SetSetting(Scalr_Db_Msr::getConstant("DATA_BUNDLE_IS_RUNNING"), 1, DBFarmRole::TYPE_LCL); $dbFarmRole->SetSetting(Scalr_Db_Msr::getConstant("DATA_BUNDLE_RUNNING_TS"), time(), DBFarmRole::TYPE_LCL); $dbFarmRole->SetSetting(Scalr_Db_Msr::getConstant("DATA_BUNDLE_SERVER_ID"), $currentServer->serverId, DBFarmRole::TYPE_LCL); }
private function getPmaDetails(DBFarmRole $dbFarmRole) { $retval = array('configured' => false); if ($dbFarmRole->GetSetting(DBFarmRole::SETTING_MYSQL_PMA_USER)) { $retval['configured'] = true; } else { $errmsg = $dbFarmRole->GetSetting(DBFarmRole::SETTING_MYSQL_PMA_REQUEST_ERROR); if (!$errmsg) { $time = $dbFarmRole->GetSetting(DBFarmRole::SETTING_MYSQL_PMA_REQUEST_TIME); if ($time) { if ($time + 3600 < time()) { $retval['accessError'] = _("Scalr didn't receive auth info from MySQL instance. Please check that MySQL running and Scalr has access to it."); } else { $retval['accessSetupInProgress'] = true; } } } else { $retval['accessError'] = $errmsg; } } return $retval; }
public function makeDecision(DBFarmRole $dbFarmRole, Scalr_Scaling_FarmRoleMetric $farmRoleMetric, $isInvert = false) { if ($farmRoleMetric->lastValue > $farmRoleMetric->getSetting('max')) { $retval = Scalr_Scaling_Decision::UPSCALE; } elseif ($farmRoleMetric->lastValue < $farmRoleMetric->getSetting('min')) { $retval = Scalr_Scaling_Decision::DOWNSCALE; } if (!$retval) { return Scalr_Scaling_Decision::NOOP; } else { if ($isInvert) { if ($retval == Scalr_Scaling_Decision::UPSCALE) { $retval = Scalr_Scaling_Decision::DOWNSCALE; } else { $retval = Scalr_Scaling_Decision::UPSCALE; } } if ($retval == Scalr_Scaling_Decision::UPSCALE) { if ($dbFarmRole->GetRunningInstancesCount() + $dbFarmRole->GetPendingInstancesCount() >= $dbFarmRole->GetSetting(DBFarmRole::SETTING_SCALING_MAX_INSTANCES)) { $retval = Scalr_Scaling_Decision::NOOP; } } if ($retval == Scalr_Scaling_Decision::DOWNSCALE) { if ($dbFarmRole->GetRunningInstancesCount() <= $dbFarmRole->GetSetting(DBFarmRole::SETTING_SCALING_MIN_INSTANCES)) { $retval = Scalr_Scaling_Decision::NOOP; } } $isSzr = $dbFarmRole->GetRoleObject()->isSupported("0.5"); if ($retval == Scalr_Scaling_Decision::UPSCALE && ($dbFarmRole->GetPendingInstancesCount() > 5 && !$isSzr)) { return Scalr_Scaling_Decision::NOOP; } else { //if ($isSzr && $dbFarmRole->GetPendingInstancesCount() > 10) //return Scalr_Scaling_Decision::NOOP; //else return $retval; } } }
public function onFarmSave(DBFarm $dbFarm, DBFarmRole $dbFarmRole) { $vpcId = $dbFarm->GetSetting(Entity\FarmSetting::EC2_VPC_ID); if (!$vpcId) { //REMOVE VPC RELATED SETTINGS return; } if ($dbFarmRole->GetSetting(self::ROLE_VPC_ROUTER_CONFIGURED) == 1) { // ALL OBJECTS ALREADY CONFIGURED return true; } $aws = $dbFarm->GetEnvironmentObject()->aws($dbFarmRole->CloudLocation); $niId = $dbFarmRole->GetSetting(self::ROLE_VPC_NID); // If there is no public IP allocate it and associate with NI $publicIp = $dbFarmRole->GetSetting(self::ROLE_VPC_IP); if ($niId && !$publicIp) { $filter = array(array('name' => AddressFilterNameType::networkInterfaceId(), 'value' => $niId)); $addresses = $aws->ec2->address->describe(null, null, $filter); $address = $addresses->get(0); $associate = false; if (!$address) { $address = $aws->ec2->address->allocate('vpc'); $associate = true; } $publicIp = $address->publicIp; if ($associate) { $associateAddressRequestData = new AssociateAddressRequestData(); $associateAddressRequestData->networkInterfaceId = $niId; $associateAddressRequestData->allocationId = $address->allocationId; $associateAddressRequestData->allowReassociation = true; //Associate PublicIP with NetworkInterface $aws->ec2->address->associate($associateAddressRequestData); } $dbFarmRole->SetSetting(self::ROLE_VPC_IP, $publicIp, Entity\FarmRoleSetting::TYPE_LCL); $dbFarmRole->SetSetting(self::ROLE_VPC_AID, $address->allocationId, Entity\FarmRoleSetting::TYPE_LCL); } $dbFarmRole->SetSetting(self::ROLE_VPC_ROUTER_CONFIGURED, 1, Entity\FarmRoleSetting::TYPE_LCL); }
/** * * @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 onFarmSave(DBFarm $dbFarm, DBFarmRole $dbFarmRole) { try { $account = Scalr_Account::init()->loadById($dbFarm->ClientID); if (!$account->isFeatureEnabled(Scalr_Limits::FEATURE_CHEF)) { $dbFarmRole->ClearSettings("chef."); return false; } $db = Core::GetDBInstance(); $runListId = $dbFarmRole->GetSetting(self::ROLE_CHEF_RUNLIST_ID); $attributes = $dbFarmRole->GetSetting(self::ROLE_CHEF_ATTRIBUTES); $checksum = $dbFarmRole->GetSetting(self::ROLE_CHEF_CHECKSUM); $chefRoleName = $dbFarmRole->GetSetting(self::ROLE_CHEF_ROLE_NAME); $chefServerId = $dbFarmRole->GetSetting(self::ROLE_CHEF_SERVER_ID); // Need to remove chef role if chef was disabled for current farmrole if (!$runListId && $chefRoleName) { $this->removeChefRole($chefServerId, $chefRoleName); $dbFarmRole->ClearSettings("chef."); return true; } if ($runListId) { $runListInfo = $this->db->GetRow("SELECT chef_server_id, runlist FROM services_chef_runlists WHERE id=?", array($runListId)); $newChefServerId = $runListInfo['chef_server_id']; if ($newChefServerId != $chefServerId && $chefServerId) { // Remove role from old server $this->removeChefRole($chefServerId, $chefRoleName); $createNew = true; } if (!$chefServerId) { $createNew = true; } $chefServerInfo = $this->db->GetRow("SELECT * FROM services_chef_servers WHERE id=?", array($runListInfo['chef_server_id'])); $chefServerInfo['auth_key'] = $this->getCrypto()->decrypt($chefServerInfo['auth_key'], $this->cryptoKey); $chefClient = Scalr_Service_Chef_Client::getChef($chefServerInfo['url'], $chefServerInfo['username'], trim($chefServerInfo['auth_key'])); $roleName = "scalr-{$dbFarmRole->ID}"; $setSettings = false; if ($createNew) { $chefClient->createRole($roleName, $roleName, json_decode($runListInfo['runlist']), json_decode($attributes), $runListInfo['chef_environment']); $setSettings = true; } else { if ($dbFarmRole->GetSetting(self::ROLE_CHEF_CHECKSUM) != md5("{$runListInfo['runlist']}.{$attributes}")) { $chefClient->updateRole($roleName, $roleName, json_decode($runListInfo['runlist']), json_decode($attributes), $runListInfo['chef_environment']); $setSettings = true; } } if ($setSettings) { $dbFarmRole->SetSetting(self::ROLE_CHEF_ROLE_NAME, $roleName); $dbFarmRole->SetSetting(self::ROLE_CHEF_SERVER_ID, $runListInfo['chef_server_id']); $dbFarmRole->SetSetting(self::ROLE_CHEF_CHECKSUM, md5("{$runListInfo['runlist']}.{$attributes}")); } } } catch (Exception $e) { throw new Exception("Chef settings error: {$e->getMessage()} ({$e->getTraceAsString()})"); } }
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(); if ($this->snapshotConfig) { if ($this->snapshotConfig->type == MYSQL_STORAGE_ENGINE::EPH) { if ($this->dbFarmRole->Platform == SERVER_PLATFORMS::EC2) { if (!isset($this->snapshotConfig->disk)) { $this->snapshotConfig->disk = new stdClass(); } $this->snapshotConfig->disk->device = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK); } } } } 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) { if (!$this->volumeConfig) { $this->volumeConfig = $this->getFreshVolumeConfig(); } else { if ($this->volumeConfig->type == MYSQL_STORAGE_ENGINE::EPH) { if ($this->dbFarmRole->Platform == SERVER_PLATFORMS::EC2 && !$this->volumeConfig->disks) { $this->volumeConfig->disk->device = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK); } } } } else { $this->volumeConfig = $this->getFreshVolumeConfig(); } }
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; }
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(); if ($this->snapshotConfig) { if ($this->snapshotConfig->type == MYSQL_STORAGE_ENGINE::EPH) { if ($this->dbFarmRole->Platform == SERVER_PLATFORMS::EC2) { if (!isset($this->snapshotConfig->disk)) { $this->snapshotConfig->disk = new stdClass(); } $this->snapshotConfig->disk->device = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK); } } } } catch (Exception $e) { $this->logger->error(new FarmLogMessage($this->dbServer->farmId, "Cannot get snaphotConfig for hostInit message: {$e->getMessage()}", !empty($this->dbServer->serverId) ? $this->dbServer->serverId : null)); } } if ($this->replicationMaster && $this->volumeConfig) { $this->volumeConfig->recreateIfMissing = (int) $this->dbFarmRole->GetSetting(Scalr_Role_DbMsrBehavior::ROLE_DATA_STORAGE_RECREATE_IF_MISSING); if ($this->volumeConfig->type == MYSQL_STORAGE_ENGINE::EPH) { if ($this->dbFarmRole->Platform == SERVER_PLATFORMS::EC2 && !$this->volumeConfig->disks) { $this->volumeConfig->disk->device = $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_EPH_DISK); } } } else { $this->volumeConfig = $this->getFreshVolumeConfig(); } }
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(); 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; }
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%"; } } } } } }
public function getVolumeConfig(DBFarmRole $dbFarmRole, DBServer $dbServer) { $volumeId = $this->getVolumeIdByServer($dbServer); if ($volumeId) { try { $volume = Scalr_Storage_Volume::init()->loadById($volumeId); $volumeConfig = $volume->getConfig(); } catch (Exception $e) { } } if (!$volumeConfig) { $volumeConfig = new stdClass(); $volumeConfig->type = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE); //$volumeConfig->fstype = 'xfs'; if (in_array($volumeConfig->type, array(MYSQL_STORAGE_ENGINE::EBS, MYSQL_STORAGE_ENGINE::CSVOL, MYSQL_STORAGE_ENGINE::CINDER, MYSQL_STORAGE_ENGINE::GCE_PERSISTENT))) { $volumeConfig->size = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_EBS_SIZE); if ($volumeConfig->type == MYSQL_STORAGE_ENGINE::EBS) { if ($dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_EBS_TYPE) == 'io1') { $volumeConfig->volumeType = 'io1'; $volumeConfig->iops = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_EBS_IOPS); } } } elseif ($volumeConfig->type == MYSQL_STORAGE_ENGINE::RAID_EBS) { $volumeConfig->type = 'raid'; $volumeConfig->vg = $this->behavior; $volumeConfig->level = $dbFarmRole->GetSetting(self::DATA_STORAGE_RAID_LEVEL); $volumeConfig->disks = array(); for ($i = 1; $i <= $dbFarmRole->GetSetting(self::DATA_STORAGE_RAID_DISKS_COUNT); $i++) { $dsk = new stdClass(); $dsk->type = 'ebs'; $dsk->size = $dbFarmRole->GetSetting(self::DATA_STORAGE_RAID_DISK_SIZE); $volumeConfig->disks[] = $dsk; } $volumeConfig->snapPv = new stdClass(); $volumeConfig->snapPv->type = 'ebs'; $volumeConfig->snapPv->size = 1; } elseif ($dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE) == MYSQL_STORAGE_ENGINE::EPH) { $volumeConfig->snap_backend = sprintf("cf://scalr-%s-%s/data-bundles/%s/%s", $dbServer->envId, $dbServer->GetCloudLocation(), $dbFarmRole->FarmID, $this->behavior); $volumeConfig->vg = $this->behavior; $volumeConfig->disk = new stdClass(); $volumeConfig->disk->type = 'loop'; $volumeConfig->disk->size = '75%root'; } } return $volumeConfig; }
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; }
/** * Gets instanceType * * @return string */ public function getInstanceType() { if ($this->instanceType === null) { $property = 'aws.instance_type'; if ($this->farmRole->Platform == \SERVER_PLATFORMS::EC2) { $property = 'aws.instance_type'; } else { if (PlatformFactory::isOpenstack($this->farmRole->Platform)) { $property = 'openstack.flavor-id'; } else { if (PlatformFactory::isCloudstack($this->farmRole->Platform)) { $property = 'cloudstack.service_offering_id'; } else { if ($this->farmRole->Platform == \SERVER_PLATFORMS::GCE) { $property = 'gce.machine-type'; } } } } $this->instanceType = $this->farmRole->GetSetting($property); } return $this->instanceType; }
/** * Gets instanceType * * @return string */ public function getInstanceType() { if ($this->instanceType === null) { $this->instanceType = $this->farmRole->GetSetting(FarmRoleSetting::INSTANCE_TYPE); } return $this->instanceType; }
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; }
/** * Retrieves server for backup * * @param DBFarmRole $dbFarmRole DBFarmRole object to search * @return DBServer|null Returns server or null */ public function getServerForBackup(DBFarmRole $dbFarmRole) { $serverTypeForBackup = $dbFarmRole->GetSetting(self::ROLE_DATA_BACKUP_SERVER_TYPE); if (!$serverTypeForBackup) { $serverTypeForBackup = 'master-if-no-slaves'; } $servers = $dbFarmRole->GetServersByFilter(array('status' => array(SERVER_STATUS::RUNNING))); $masterServer = null; $slaveServer = null; $currentMetric = 0; foreach ($servers as $dbServer) { $isMaster = $dbServer->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER); if ($isMaster) { $masterServer = $dbServer; } else { $slaveServer = $dbServer; } } switch ($serverTypeForBackup) { case 'slave': return $slaveServer; break; case 'master': return $masterServer; break; case 'master-if-no-slaves': return $slaveServer ? $slaveServer : $masterServer; break; } }
private function performDbMsrAction($action, DBFarmRole $dbFarmRole, $tz) { $timeouted = false; if ($dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_ENABLED")) && $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_EVERY")) != 0) { if ($dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_IS_RUNNING")) == 1) { // Wait for timeout time * 2 (Example: NIVs problem with big mysql snapshots) // We must wait for running bundle process. $timeout = $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_EVERY")) * (3600 * 2); $lastTs = $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_RUNNING_TS")); if ($lastTs + $timeout < time()) { $timeouted = true; } if ($timeouted) { $dbFarmRole->SetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_IS_RUNNING"), 0, DBFarmRole::TYPE_LCL); } } else { /* * Check bundle window */ $period = $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_EVERY")); $timeout = $period * 3600; $lastActionTime = $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_LAST_TS")); $performAction = false; if ($period % 24 == 0) { if ($lastActionTime) { $days = $period / 24; $dateTime = new DateTime(null, new DateTimeZone($tz)); $currentDate = (int) $dateTime->format("Ymd"); $dateTime->setTimestamp(strtotime("+{$days} day", $lastActionTime)); $nextDate = (int) $dateTime->format("Ymd"); if ($nextDate > $currentDate) { return; } } $pbwFrom = (int) ($dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_TIMEFRAME_START_HH")) . $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_TIMEFRAME_START_MM"))); $pbwTo = (int) ($dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_TIMEFRAME_END_HH")) . $dbFarmRole->GetSetting(Scalr_Db_Msr::getConstant("DATA_{$action}_TIMEFRAME_END_MM"))); if ($pbwFrom && $pbwTo) { $dateTime = new DateTime(null, new DateTimeZone($tz)); $currentTime = (int) $dateTime->format("Hi"); //$current_time = (int)date("Hi"); //BUG HERE: 22:00 - 6:00 - doesn't work if ($pbwFrom <= $currentTime && $pbwTo >= $currentTime) { $performAction = true; } } else { $performAction = true; } } else { //Check timeout if ($lastActionTime + $timeout < time()) { $performAction = true; } } if ($performAction) { $behavior = Scalr_Role_Behavior::loadByName($dbFarmRole->GetRoleObject()->getDbMsrBehavior()); if ($action == 'BUNDLE') { $behavior->createDataBundle($dbFarmRole, array('compressor' => $dbFarmRole->GetSetting(Scalr_Role_DbMsrBehavior::ROLE_DATA_BUNDLE_COMPRESSION), 'useSlave' => $dbFarmRole->GetSetting(Scalr_Role_DbMsrBehavior::ROLE_DATA_BUNDLE_USE_SLAVE))); } if ($action == 'BACKUP') { $behavior->createBackup($dbFarmRole); } } } } }
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 function getVolumeConfig(DBFarmRole $dbFarmRole, DBServer $dbServer) { $r = new ReflectionClass($this); if ($r->hasConstant("ROLE_VOLUME_ID")) { if ($dbFarmRole->GetSetting(static::ROLE_VOLUME_ID)) { try { $volume = Scalr_Storage_Volume::init()->loadById($dbFarmRole->GetSetting(static::ROLE_VOLUME_ID)); $volumeConfig = $volume->getConfig(); } catch (Exception $e) { } } if (!$volumeConfig) { $volumeConfig = new stdClass(); $volumeConfig->type = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE); if (in_array($dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE), array(MYSQL_STORAGE_ENGINE::EBS, MYSQL_STORAGE_ENGINE::CSVOL))) { $volumeConfig->size = $dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_EBS_SIZE); } elseif ($dbFarmRole->GetSetting(static::ROLE_DATA_STORAGE_ENGINE) == MYSQL_STORAGE_ENGINE::EPH) { $volumeConfig->snap_backend = sprintf("cf://scalr-%s-%s/data-bundles/%s/%s", $dbServer->envId, $dbServer->GetCloudLocation(), $dbFarmRole->FarmID, $this->behavior); $volumeConfig->vg = $this->behavior; $volumeConfig->disk = new stdClass(); $volumeConfig->disk->type = 'loop'; $volumeConfig->disk->size = '75%root'; } } return $volumeConfig; } else { return false; } }
public function onFarmSave(DBFarm $dbFarm, DBFarmRole $dbFarmRole) { $vpcId = $dbFarm->GetSetting(DBFarm::SETTING_EC2_VPC_ID); if (!$vpcId) { //REMOVE VPC RELATED SETTINGS return; } if ($dbFarmRole->GetSetting(self::ROLE_VPC_ROUTER_CONFIGURED) == 1) { // ALL OBJECTS ALREADY CONFIGURED return true; } $aws = $dbFarm->GetEnvironmentObject()->aws($dbFarmRole->CloudLocation); $filter = array(array('name' => SubnetFilterNameType::vpcId(), 'value' => $vpcId), array('name' => SubnetFilterNameType::tagKey(), 'value' => 'scalr-sn-type'), array('name' => SubnetFilterNameType::tagValue(), 'value' => self::INTERNET_ACCESS_FULL)); // Try to find scalr FULL subnet $subnets = $aws->ec2->subnet->describe(null, $filter); if ($subnets->count() > 0) { $subnetId = $subnets->get(0)->subnetId; } if (!$subnetId) { $platform = PlatformFactory::NewPlatform(SERVER_PLATFORMS::EC2); $subnet = $platform->AllocateNewSubnet($aws->ec2, $vpcId, null); $subnetId = $subnet->subnetId; //ADD TAGS try { $subnet->createTags(array(array('key' => "scalr-id", 'value' => SCALR_ID), array('key' => "scalr-sn-type", 'value' => self::INTERNET_ACCESS_FULL), array('key' => "Name", 'value' => 'Scalr System Subnet'))); } catch (Exception $e) { } $routingTableId = $platform->getRoutingTable(self::INTERNET_ACCESS_FULL, $aws, null, $vpcId); //Associate Routing table with subnet $aws->ec2->routeTable->associate($routingTableId, $subnetId); } $niId = $dbFarmRole->GetSetting(self::ROLE_VPC_NID); if (!$niId) { //Create Network interface $createNetworkInterfaceRequestData = new CreateNetworkInterfaceRequestData($subnetId); // Check and create security group $filter = array(array('name' => SecurityGroupFilterNameType::groupName(), 'value' => array('SCALR-VPC')), array('name' => SecurityGroupFilterNameType::vpcId(), 'value' => $vpcId)); try { $list = $aws->ec2->securityGroup->describe(null, null, $filter); if ($list->count() > 0 && $list->get(0)->groupName == 'SCALR-VPC') { $sgId = $list->get(0)->groupId; } } catch (Exception $e) { throw new Exception("Cannot get list of security groups (1): {$e->getMessage()}"); } if (!$sgId) { $sgId = $aws->ec2->securityGroup->create('SCALR-VPC', 'System SG for Scalr VPC integration', $vpcId); $ipRangeList = new IpRangeList(); $ipRangeList->append(new IpRangeData('0.0.0.0/0')); $ipRangeListLocal = new IpRangeList(); $ipRangeListLocal->append(new IpRangeData('10.0.0.0/8')); $aws->ec2->securityGroup->authorizeIngress(array(new IpPermissionData('tcp', 8008, 8013, $ipRangeList), new IpPermissionData('tcp', 80, 80, $ipRangeList), new IpPermissionData('tcp', 443, 443, $ipRangeList), new IpPermissionData('tcp', 0, 65535, $ipRangeListLocal), new IpPermissionData('udp', 0, 65535, $ipRangeListLocal)), $sgId); } $createNetworkInterfaceRequestData->setSecurityGroupId(array('groupId' => $sgId)); $networkInterface = $aws->ec2->networkInterface->create($createNetworkInterfaceRequestData); // Disable sourceDeskCheck $networkInterface->modifyAttribute(NetworkInterfaceAttributeType::sourceDestCheck(), 0); $niId = $networkInterface->networkInterfaceId; $dbFarmRole->SetSetting(self::ROLE_VPC_NID, $niId, DBFarmRole::TYPE_LCL); try { $networkInterface->createTags(array(array('key' => "scalr-id", 'value' => SCALR_ID), array('key' => "Name", 'value' => 'Scalr System ENI'))); } catch (Exception $e) { } } // If there is no public IP allocate it and associate with NI $publicIp = $dbFarmRole->GetSetting(self::ROLE_VPC_IP); if ($niId && !$publicIp) { $address = $aws->ec2->address->allocate('vpc'); $publicIp = $address->publicIp; $dbFarmRole->SetSetting(self::ROLE_VPC_IP, $publicIp, DBFarmRole::TYPE_LCL); $dbFarmRole->SetSetting(self::ROLE_VPC_AID, $address->allocationId, DBFarmRole::TYPE_LCL); $associateAddressRequestData = new AssociateAddressRequestData(); $associateAddressRequestData->networkInterfaceId = $niId; $associateAddressRequestData->allocationId = $address->allocationId; //Associate PublicIP with NetworkInterface $aws->ec2->address->associate($associateAddressRequestData); } $dbFarmRole->SetSetting(self::ROLE_VPC_ROUTER_CONFIGURED, 1, DBFarmRole::TYPE_LCL); }