PHP DBFarmRole::SetSetting方法代码示例

 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()})");
     }
 }

 public function onFarmSave(DBFarm $dbFarm, DBFarmRole $dbFarmRole)
 {
     if (!$dbFarmRole->GetSetting(self::ROLE_COOKIE_NAME)) {
         $cookie = substr(sha1(microtime(true) . rand(0, 100000)), 0, 20);
         $dbFarmRole->SetSetting(self::ROLE_COOKIE_NAME, $cookie, DBFarmRole::TYPE_LCL);
     }
 }

 public function setMsrSettings($settings)
 {
     if ($settings->volumeConfig) {
         try {
             $storageVolume = Scalr_Storage_Volume::init();
             try {
                 $storageVolume->loadById($settings->volumeConfig->id);
                 $storageVolume->setConfig($settings->volumeConfig);
                 $storageVolume->save();
             } catch (Exception $e) {
                 if (strpos($e->getMessage(), 'not found')) {
                     $storageVolume->loadBy(array('id' => $settings->volumeConfig->id, 'client_id' => $this->dbServer->clientId, 'env_id' => $this->dbServer->envId, 'name' => "'{$this->databaseType}' data volume", 'type' => $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_ENGINE), 'platform' => $this->dbServer->platform, 'size' => $settings->volumeConfig->size, 'fstype' => $settings->volumeConfig->fstype, 'purpose' => $this->databaseType, 'farm_roleid' => $this->dbFarmRole->ID, 'server_index' => $this->dbServer->index));
                     $storageVolume->setConfig($settings->volumeConfig);
                     $storageVolume->save(true);
                 } else {
                     throw $e;
                 }
             }
             $this->dbFarmRole->SetSetting(Scalr_Db_Msr::VOLUME_ID, $storageVolume->id, DBFarmRole::TYPE_LCL);
         } catch (Exception $e) {
             $this->logger->error(new FarmLogMessage($this->dbServer->farmId, "Cannot save storage volume: {$e->getMessage()}"));
         }
     }
     if ($settings->snapshotConfig) {
         try {
             $storageSnapshot = Scalr_Model::init(Scalr_Model::STORAGE_SNAPSHOT);
             try {
                 $storageSnapshot->loadById($settings->snapshotConfig->id);
                 $storageSnapshot->setConfig($settings->snapshotConfig);
                 $storageSnapshot->save();
             } catch (Exception $e) {
                 if (strpos($e->getMessage(), 'not found')) {
                     $storageSnapshot->loadBy(array('id' => $settings->snapshotConfig->id, 'client_id' => $this->dbServer->clientId, 'farm_id' => $this->dbServer->farmId, 'farm_roleid' => $this->dbServer->farmRoleId, 'env_id' => $this->dbServer->envId, 'name' => sprintf(_("'{$this->databaseType}' data bundle #%s"), $settings->snapshotConfig->id), 'type' => $this->dbFarmRole->GetSetting(Scalr_Db_Msr::DATA_STORAGE_ENGINE), 'platform' => $this->dbServer->platform, 'description' => sprintf(_("'{$this->databaseType}' data bundle created on Farm '%s' -> Role '%s'"), $this->dbFarmRole->GetFarmObject()->name, $this->dbFarmRole->GetRoleObject()->name), 'service' => $this->databaseType));
                     $storageSnapshot->setConfig($settings->snapshotConfig);
                     $storageSnapshot->save(true);
                 } else {
                     throw $e;
                 }
             }
             $this->dbFarmRole->SetSetting(Scalr_Db_Msr::SNAPSHOT_ID, $storageSnapshot->id, DBFarmRole::TYPE_LCL);
         } catch (Exception $e) {
             $this->logger->error(new FarmLogMessage($event->DBServer->farmId, "Cannot save storage snapshot: {$e->getMessage()}"));
         }
     }
 }

 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);
 }

 public function onFarmTerminated(DBFarmRole $dbFarmRole)
 {
     $dbFarmRole->SetSetting(self::ROLE_CLUSTER_STATUS, "", DBFarmRole::TYPE_LCL);
 }

 public function onFarmTerminated(DBFarmRole $dbFarmRole)
 {
     if (in_array($this->behavior, array(ROLE_BEHAVIORS::PERCONA, ROLE_BEHAVIORS::MYSQL2, ROLE_BEHAVIORS::MARIADB))) {
         $dbFarmRole->SetSetting(self::ROLE_NO_DATA_BUNDLE_FOR_SLAVES, 1, DBFarmRole::TYPE_LCL);
     }
 }

 /**
  * @return DBFarmRole
  * @param DBRole $DBRole
  */
 public function AddRole(DBRole $DBRole, $platform, $cloudLocation, $launchIndex)
 {
     $this->DB->Execute("INSERT INTO farm_roles SET \r\n\t\t\t\tfarmid=?, role_id=?, reboot_timeout=?, launch_timeout=?, status_timeout = ?, launch_index = ?, platform = ?, cloud_location=?", array($this->ID, $DBRole->id, 300, 300, 600, $launchIndex, $platform, $cloudLocation));
     $farm_role_id = $this->DB->Insert_ID();
     $DBFarmRole = new DBFarmRole($farm_role_id);
     $DBFarmRole->FarmID = $this->ID;
     $DBFarmRole->RoleID = $DBRole->id;
     $DBFarmRole->Platform = $platform;
     $DBFarmRole->CloudLocation = $cloudLocation;
     $default_settings = array(DBFarmRole::SETTING_SCALING_MIN_INSTANCES => 1, DBFarmRole::SETTING_SCALING_MAX_INSTANCES => 1, DBFarmRole::SETTING_SCALING_POLLING_INTERVAL => 2, DBFarmRole::SETTING_EXCLUDE_FROM_DNS => false, DBFarmRole::SETTING_BALANCING_USE_ELB => false, DBFarmRole::SETTING_AWS_AVAIL_ZONE => 'x-scalr-diff', DBFarmRole::SETTING_AWS_INSTANCE_TYPE => $DBRole->instanceType);
     foreach ($default_settings as $k => $v) {
         $DBFarmRole->SetSetting($k, $v);
     }
     return $DBFarmRole;
 }

 /**
  * Adds a role to farm
  *
  * @param   DBRole     $DBRole        The role object
  * @param   string     $platform      The cloud platform
  * @param   string     $cloudLocation The cloud location
  * @param   int        $launchIndex   Launch index
  * @param   string     $alias         optional
  * @return  DBFarmRole
  */
 public function AddRole(DBRole $DBRole, $platform, $cloudLocation, $launchIndex, $alias = "")
 {
     if (empty($alias)) {
         $alias = $DBRole->name;
     }
     $this->DB->Execute("\n            INSERT INTO farm_roles\n            SET farmid=?,\n                role_id=?,\n                reboot_timeout=?,\n                launch_timeout=?,\n                status_timeout = ?,\n                launch_index = ?,\n                platform = ?,\n                cloud_location=?,\n                `alias` = ?\n        ", [$this->ID, $DBRole->id, 300, 300, 600, $launchIndex, $platform, $cloudLocation, $alias]);
     $farm_role_id = $this->DB->Insert_ID();
     $DBFarmRole = new DBFarmRole($farm_role_id);
     $DBFarmRole->FarmID = $this->ID;
     $DBFarmRole->RoleID = $DBRole->id;
     $DBFarmRole->Platform = $platform;
     $DBFarmRole->CloudLocation = $cloudLocation;
     $DBFarmRole->Alias = $alias;
     $default_settings = [Entity\FarmRoleSetting::SCALING_MIN_INSTANCES => 1, Entity\FarmRoleSetting::SCALING_MAX_INSTANCES => 1];
     foreach ($default_settings as $k => $v) {
         $DBFarmRole->SetSetting($k, $v);
     }
     if ($farm_role_id && $DBFarmRole && \Scalr::getContainer()->analytics->enabled) {
         \Scalr::getContainer()->analytics->tags->syncValue($this->ClientID, \Scalr\Stats\CostAnalytics\Entity\TagEntity::TAG_ID_FARM_ROLE, $farm_role_id, sprintf('%s', $DBFarmRole->Alias));
     }
     return $DBFarmRole;
 }

 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);
 }

 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 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)
 {
     $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 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));
//.........这里部分代码省略.........

 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, "");
//.........这里部分代码省略.........

 /**
  * @return DBFarmRole
  * @param DBRole $DBRole
  */
 public function AddRole(DBRole $DBRole, $platform, $cloudLocation, $launchIndex, $alias = "")
 {
     if (empty($alias)) {
         $alias = $DBRole->name;
     }
     $this->DB->Execute("INSERT INTO farm_roles SET\n            farmid=?, role_id=?, reboot_timeout=?, launch_timeout=?, status_timeout = ?,\n            launch_index = ?, platform = ?, cloud_location=?, `alias` = ?", array($this->ID, $DBRole->id, 300, 300, 600, $launchIndex, $platform, $cloudLocation, $alias));
     $farm_role_id = $this->DB->Insert_ID();
     $DBFarmRole = new DBFarmRole($farm_role_id);
     $DBFarmRole->FarmID = $this->ID;
     $DBFarmRole->RoleID = $DBRole->id;
     $DBFarmRole->Platform = $platform;
     $DBFarmRole->CloudLocation = $cloudLocation;
     $DBFarmRole->Alias = $alias;
     $default_settings = array(DBFarmRole::SETTING_SCALING_MIN_INSTANCES => 1, DBFarmRole::SETTING_SCALING_MAX_INSTANCES => 1);
     foreach ($default_settings as $k => $v) {
         $DBFarmRole->SetSetting($k, $v);
     }
     return $DBFarmRole;
 }