private function DeregisterInstanceFromLB(DBServer $DBServer) { try { $DBFarmRole = $DBServer->GetFarmRoleObject(); if ($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_USE_ELB) == 1) { $Client = $DBServer->GetClient(); $AmazonELBClient = Scalr_Service_Cloud_Aws::newElb($DBServer->GetProperty(EC2_SERVER_PROPERTIES::REGION), $DBServer->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::ACCESS_KEY), $DBServer->GetEnvironmentObject()->getPlatformConfigValue(Modules_Platforms_Ec2::SECRET_KEY)); $AmazonELBClient->DeregisterInstancesFromLoadBalancer($DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME), array($DBServer->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID))); Logger::getLogger(LOG_CATEGORY::FARM)->info(new FarmLogMessage($this->FarmID, sprintf(_("Instance '%s' deregistered from '%s' load balancer"), $DBServer->GetProperty(EC2_SERVER_PROPERTIES::INSTANCE_ID), $DBFarmRole->GetSetting(DBFarmRole::SETTING_BALANCING_NAME)))); } } catch (Exception $e) { Logger::getLogger(LOG_CATEGORY::FARM)->info(new FarmLogMessage($this->FarmID, sprintf(_("Cannot deregister instance from the load balancer: %s"), $e->getMessage()))); } }
public function GetServerIPAddresses(DBServer $DBServer) { $client = $this->getOsClient($DBServer->GetEnvironmentObject(), $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $result = $client->servers->getServerDetails($DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::SERVER_ID)); if ($result->accessIPv4) { $remoteIp = $result->accessIPv4; } if (!$remoteIp) { if (is_array($result->addresses->public)) { foreach ($result->addresses->public as $addr) { if ($addr->version == 4) { $remoteIp = $addr->addr; break; } } } } if (is_array($result->addresses->private)) { foreach ($result->addresses->private as $addr) { if ($addr->version == 4) { $localIp = $addr->addr; break; } } } if (!$localIp) { $localIp = $remoteIp; } return array('localIp' => $localIp, 'remoteIp' => $remoteIp); }
/** * {@inheritdoc} * @see \Scalr\Modules\Platforms\Openstack\OpenstackPlatformModule::GetServerIPAddresses() */ public function GetServerIPAddresses(\DBServer $DBServer) { $config = \Scalr::getContainer()->config; $client = $this->getOsClient($DBServer->GetEnvironmentObject(), $DBServer->GetProperty(\OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $result = $client->servers->getServerDetails($DBServer->GetProperty(\OPENSTACK_SERVER_PROPERTIES::SERVER_ID)); $publicNetworkName = 'public'; $privateNetworkName = 'private'; if (is_array($result->addresses->{$publicNetworkName})) { foreach ($result->addresses->{$publicNetworkName} as $addr) { if ($addr->version == 4) { $remoteIp = $addr->addr; break; } } } if (!$remoteIp && $result->accessIPv4) { $remoteIp = $result->accessIPv4; } if (is_array($result->addresses->{$privateNetworkName})) { foreach ($result->addresses->{$privateNetworkName} as $addr) { if ($addr->version == 4) { $localIp = $addr->addr; break; } } } if (!$localIp) { $localIp = $remoteIp; } return array('localIp' => $localIp, 'remoteIp' => $remoteIp); }
public static function removeIpFromServer(\DBServer $dbServer) { try { if ($dbServer->GetProperty(\OPENSTACK_SERVER_PROPERTIES::FLOATING_IP)) { if ($dbServer->farmRoleId) { if ($dbServer->GetFarmRoleObject()->GetSetting(\DBFarmRole::SETTING_OPENSTACK_KEEP_FIP_ON_SUSPEND)) { if (in_array($dbServer->status, array(\SERVER_STATUS::PENDING_SUSPEND, \SERVER_STATUS::SUSPENDED)) || $dbServer->GetRealStatus()->isSuspended()) { return false; } } } $environment = $dbServer->GetEnvironmentObject(); $osClient = $environment->openstack($dbServer->platform, $dbServer->GetCloudLocation()); $ipId = $dbServer->GetProperty(\OPENSTACK_SERVER_PROPERTIES::FLOATING_IP_ID); if ($osClient->hasService('network')) { $osClient->network->floatingIps->delete($ipId); } else { $osClient->servers->deleteFloatingIp($ipId); } $dbServer->SetProperties(array(\OPENSTACK_SERVER_PROPERTIES::FLOATING_IP => null, \OPENSTACK_SERVER_PROPERTIES::FLOATING_IP_ID => null)); } } catch (\Exception $e) { \Logger::getLogger("OpenStackObserver")->fatal("OpenStackObserver observer failed: " . $e->getMessage()); } }
public function PutAccessData(\DBServer $DBServer, \Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof \Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof \Scalr_Messaging_Msg_BeforeHostUp; $put |= $message instanceof \Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_NewMasterUp; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_CreateBackup; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_NewMasterUp; if ($put) { $ccProps = $DBServer->GetEnvironmentObject()->keychain($DBServer->platform)->properties; $accessData = new \stdClass(); $accessData->apiKey = $ccProps[CloudCredentialsProperty::CLOUDSTACK_API_KEY]; $accessData->secretKey = $ccProps[CloudCredentialsProperty::CLOUDSTACK_SECRET_KEY]; $apiUrl = $ccProps[CloudCredentialsProperty::CLOUDSTACK_API_URL]; if ($apiUrl == 'https://apis.i.noahcloud.jp/portal/client/api') { $accessData->apiUrl = "https://api.noahcloud.jp/portal/client/api"; } else { $accessData->apiUrl = $apiUrl; } $message->platformAccessData = $accessData; } }
public static function setupScalrAgent(\DBServer $dbServer) { $baseurl = \Scalr::config('scalr.endpoint.scheme') . "://" . \Scalr::config('scalr.endpoint.host'); $env = $dbServer->GetEnvironmentObject(); $azure = $env->azure(); $branch = $dbServer->getScalarizrRepository()['repository']; $develRepos = \Scalr::getContainer()->config->get('scalr.scalarizr_update.devel_repos'); $scmBranch = $dbServer->GetFarmRoleObject()->GetSetting('user-data.scm_branch'); if ($scmBranch != '' && $develRepos) { $branch = $dbServer->GetFarmRoleObject()->GetSetting('base.devel_repository'); $scmBranch = "{$scmBranch}/"; } else { $scmBranch = ''; } if ($dbServer->osType == 'linux') { $extensionProperties = new ResourceExtensionProperties('Microsoft.OSTCExtensions', 'CustomScriptForLinux', '1.2'); $extensionProperties->setSettings(['commandToExecute' => "bash -c 'curl -k -L \"{$baseurl}/public/linux/{$branch}/azure/{$scmBranch}install_scalarizr.sh\" | bash && service scalr-upd-client start'"]); } else { $extensionProperties = new ResourceExtensionProperties('Microsoft.Compute', 'CustomScriptExtension', '1.4'); $extensionProperties->setSettings(["commandToExecute" => "powershell -NoProfile -ExecutionPolicy Bypass -Command \"iex ((new-object net.webclient).DownloadString('{$baseurl}/public/windows/{$branch}/{$scmBranch}install_scalarizr.ps1')); start-service ScalrUpdClient\""]); } $createExtension = new CreateResourceExtension('scalarizr', $dbServer->cloudLocation, $extensionProperties); try { $response = $azure->compute->resourceExtension->create($env->keychain(SERVER_PLATFORMS::AZURE)->properties[Entity\CloudCredentialsProperty::AZURE_SUBSCRIPTION_ID], $dbServer->GetProperty(\AZURE_SERVER_PROPERTIES::RESOURCE_GROUP), $dbServer->GetProperty(\AZURE_SERVER_PROPERTIES::SERVER_NAME), $createExtension); \Scalr::getContainer()->logger(\LOG_CATEGORY::FARM)->info(new \FarmLogMessage($dbServer, sprintf(_("Created azure resource extension to install and launch scalr agent")))); $dbServer->SetProperty(\AZURE_SERVER_PROPERTIES::SZR_EXTENSION_DEPLOYED, 1); } catch (\Exception $e) { \Scalr::getContainer()->logger(\LOG_CATEGORY::FARM)->fatal(new \FarmLogMessage($dbServer, sprintf(_("Unable to create azure resource extension to install and launch scalr agent: %s"), $e->getMessage()))); } }
public function PutAccessData(\DBServer $DBServer, \Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof \Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof \Scalr_Messaging_Msg_BeforeHostUp; $put |= $message instanceof \Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_NewMasterUp; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof \Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_CreateBackup; $put |= $message instanceof \Scalr_Messaging_Msg_DbMsr_NewMasterUp; if ($put) { $environment = $DBServer->GetEnvironmentObject(); $accessData = new \stdClass(); $accessData->apiKey = $this->getConfigVariable(self::API_KEY, $environment); $accessData->secretKey = $this->getConfigVariable(self::SECRET_KEY, $environment); $apiUrl = $this->getConfigVariable(self::API_URL, $environment); if ($apiUrl == 'https://apis.i.noahcloud.jp/portal/client/api') { $accessData->apiUrl = "https://api.noahcloud.jp/portal/client/api"; } else { $accessData->apiUrl = $apiUrl; } $message->platformAccessData = $accessData; } }
public function TerminateServer(DBServer $DBServer) { $cs = $this->getCloudStackClient($DBServer->GetEnvironmentObject(), $this->GetServerCloudLocation($DBServer)); if (!$DBServer->GetProperty(CLOUDSTACK_SERVER_PROPERTIES::IS_STOPPED_BEFORE_TERMINATE)) { $cs->stopVirtualMachine($DBServer->GetProperty(CLOUDSTACK_SERVER_PROPERTIES::SERVER_ID), true); $DBServer->SetProperty(CLOUDSTACK_SERVER_PROPERTIES::IS_STOPPED_BEFORE_TERMINATE, 1); } return parent::TerminateServer($DBServer); }
/** * {@inheritdoc} * @see \Scalr\Modules\Platforms\Cloudstack\CloudstackPlatformModule::TerminateServer() */ public function TerminateServer(\DBServer $DBServer) { $cs = $DBServer->GetEnvironmentObject()->cloudstack($this->platform); if (!$DBServer->GetProperty(\CLOUDSTACK_SERVER_PROPERTIES::IS_STOPPED_BEFORE_TERMINATE)) { $cs->instance->stop($DBServer->GetProperty(\CLOUDSTACK_SERVER_PROPERTIES::SERVER_ID), true); $DBServer->SetProperty(\CLOUDSTACK_SERVER_PROPERTIES::IS_STOPPED_BEFORE_TERMINATE, 1); } return parent::TerminateServer($DBServer); }
/** * Associates IP Address to the server * * @param DBServer $dbServer DBServer object * @param string $ipAddress Public IP address to associate with server. * @throws Exception */ private static function associateIpAddress(DBServer $dbServer, $ipAddress, $allocationId = null) { $platform = PlatformFactory::NewPlatform($dbServer->platform); $cs = Scalr_Service_Cloud_Cloudstack::newCloudstack($platform->getConfigVariable(Modules_Platforms_Cloudstack::API_URL, $dbServer->GetEnvironmentObject()), $platform->getConfigVariable(Modules_Platforms_Cloudstack::API_KEY, $dbServer->GetEnvironmentObject()), $platform->getConfigVariable(Modules_Platforms_Cloudstack::SECRET_KEY, $dbServer->GetEnvironmentObject()), $dbServer->platform); $assign_retries = 1; $retval = false; // Remove OLD static NAT if ($dbServer->remoteIp) { try { $info = $cs->listPublicIpAddresses(null, null, null, null, null, $dbServer->remoteIp); $info = $info->publicipaddress[0]; if ($info->issystem && $info->isstaticnat) { $cs->disableStaticNat($info->id); } } catch (Exception $e) { Logger::getLogger('Cloudstack_Helper')->error("Unable to disable old static NAT: {$e->getMessage()}"); } } try { $cs->disableStaticNat($allocationId); } catch (Exception $e) { } $assignRetries = 0; while (true) { try { $assignRetries++; $cs->enableStaticNat($allocationId, $dbServer->GetCloudServerID()); $retval = true; break; } catch (Exception $e) { if (!stristr($e->getMessage(), "already assigned to antoher vm") || $assignRetries == 3) { throw new Exception($e->getMessage()); } else { sleep(1); } } //break; } return $retval; }
private function cleanupFloatingIps(DBServer $dbServer) { try { if ($dbServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::FLOATING_IP)) { $environment = $dbServer->GetEnvironmentObject(); $osClient = $environment->openstack($dbServer->platform, $dbServer->GetCloudLocation()); $ipId = $dbServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::FLOATING_IP_ID); if ($osClient->hasService('network')) { $osClient->network->floatingIps->delete($ipId); } else { $osClient->servers->deleteFloatingIp($ipId); } $dbServer->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::FLOATING_IP => null, OPENSTACK_SERVER_PROPERTIES::FLOATING_IP_ID => null)); } } catch (Exception $e) { Logger::getLogger("OpenStackObserver")->fatal("OpenStackObserver observer failed: " . $e->getMessage()); } }
public static function listServerGlobalVariables(DBServer $dbServer, $includeSystem = false, AbstractServerEvent $event = null) { $retval = array(); if ($includeSystem) { $variables = $dbServer->GetScriptingVars(); if ($event) { if ($event->DBServer) { foreach ($event->DBServer->GetScriptingVars() as $k => $v) { $variables["event_{$k}"] = $v; } } foreach ($event->GetScriptingVars() as $k => $v) { $variables[$k] = $event->{$v}; } if (isset($event->params) && is_array($event->params)) { foreach ($event->params as $k => $v) { $variables[$k] = $v; } } $variables['event_name'] = $event->GetName(); } $formats = \Scalr::config("scalr.system.global_variables.format"); foreach ($variables as $name => $value) { $name = "SCALR_" . strtoupper($name); $value = trim($value); if (isset($formats[$name])) { $value = @sprintf($formats[$name], $value); } $private = strpos($name, 'SCALR_EVENT_') === 0 ? 1 : 0; $retval[] = (object) array('name' => $name, 'value' => $value, 'private' => $private, 'system' => 1); } } try { $globalVariables = new Scalr_Scripting_GlobalVariables($dbServer->GetEnvironmentObject()->clientId, $dbServer->envId, ScopeInterface::SCOPE_SERVER); $vars = $globalVariables->listVariables($dbServer->GetFarmRoleObject()->RoleID, $dbServer->farmId, $dbServer->farmRoleId, $dbServer->serverId); foreach ($vars as $v) { $retval[] = (object) $v; } } catch (Exception $e) { } return $retval; }
public function PutAccessData(DBServer $DBServer, Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_NewMasterUp; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateBackup; if ($put) { $environment = $DBServer->GetEnvironmentObject(); $accessData = new stdClass(); $accessData->username = $environment->getPlatformConfigValue(self::USERNAME, true, $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $accessData->password = $environment->getPlatformConfigValue(self::API_KEY, true, $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $accessData->authUrl = $environment->getPlatformConfigValue(self::API_URL, true, $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $accessData->projectId = $environment->getPlatformConfigValue(self::PROJECT_NAME, true, $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $accessData->cloudLocation = $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION); $message->platformAccessData = $accessData; } }
public function PutAccessData(DBServer $DBServer, Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_NewMasterUp; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateBackup; if ($put) { $environment = $DBServer->GetEnvironmentObject(); $accessData = new stdClass(); $accessData->username = $environment->getPlatformConfigValue(self::USERNAME, true, $DBServer->GetProperty(RACKSPACE_SERVER_PROPERTIES::DATACENTER)); $accessData->apiKey = $environment->getPlatformConfigValue(self::API_KEY, true, $DBServer->GetProperty(RACKSPACE_SERVER_PROPERTIES::DATACENTER)); switch ($DBServer->GetProperty(RACKSPACE_SERVER_PROPERTIES::DATACENTER)) { case 'rs-ORD1': $accessData->authHost = 'auth.api.rackspacecloud.com'; break; case 'rs-LONx': $accessData->authHost = 'lon.auth.api.rackspacecloud.com'; break; } $message->platformAccessData = $accessData; } }
public function PutAccessData(DBServer $DBServer, Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof Scalr_Messaging_Msg_BeforeHostUp; $put |= $message instanceof Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_BeforeHostTerminate; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_NewMasterUp; if ($put) { $environment = $DBServer->GetEnvironmentObject(); $message->platformAccessData = $this->GetPlatformAccessData($environment, $DBServer); } }
public function PutAccessData(DBServer $DBServer, Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateBackup; $environment = $DBServer->GetEnvironmentObject(); if ($put) { $accessData = new stdClass(); $accessData->accountId = $environment->getPlatformConfigValue(self::ACCOUNT_ID, true, $DBServer->GetCloudLocation()); $accessData->keyId = $environment->getPlatformConfigValue(self::ACCESS_KEY, true, $DBServer->GetCloudLocation()); $accessData->key = $environment->getPlatformConfigValue(self::SECRET_KEY, true, $DBServer->GetCloudLocation()); $accessData->cert = $environment->getPlatformConfigValue(self::CERTIFICATE, true, $DBServer->GetCloudLocation()); $accessData->pk = $environment->getPlatformConfigValue(self::PRIVATE_KEY, true, $DBServer->GetCloudLocation()); $accessData->ec2_url = $environment->getPlatformConfigValue(self::EC2_URL, true, $DBServer->GetCloudLocation()); $accessData->s3_url = $environment->getPlatformConfigValue(self::S3_URL, true, $DBServer->GetCloudLocation()); $accessData->cloud_cert = $environment->getPlatformConfigValue(self::CLOUD_CERTIFICATE, true, $DBServer->GetCloudLocation()); $message->platformAccessData = $accessData; } }
private function onHello($message, DBServer $dbserver) { if ($dbserver->status == SERVER_STATUS::TEMPORARY) { $bundleTask = BundleTask::LoadById($dbserver->GetProperty(SERVER_PROPERTIES::SZR_IMPORTING_BUNDLE_TASK_ID)); $bundleTask->status = SERVER_SNAPSHOT_CREATION_STATUS::PENDING; $bundleTask->Log("Received Hello message from scalarizr on server. Creating image"); $bundleTask->osFamily = $message->dist->distributor; $bundleTask->osName = $message->dist->codename; $bundleTask->osVersion = $message->dist->release; if (in_array($message->dist->distributor, array('redhat', 'oel', 'scientific')) && $dbserver->platform == SERVER_PLATFORMS::EC2) { $bundleTask->bundleType = SERVER_SNAPSHOT_CREATION_TYPE::EC2_EBS_HVM; } $bundleTask->save(); } if ($dbserver->status == SERVER_STATUS::IMPORTING) { if (!$dbserver->remoteIp || !$dbserver->localIp) { if (!$dbserver->remoteIp && $message->remoteIp && $dbserver->platform != SERVER_PLATFORMS::IDCF) { $dbserver->remoteIp = $message->remoteIp; } if (!$dbserver->localIp && $message->localIp) { $dbserver->localIp = $message->localIp; } if (!$message->behaviour) { $message->behaviour = array('base'); } if ((!$dbserver->remoteIp || $dbserver->localIp == $dbserver->remoteIp) && $message->messageIpAddress != $dbserver->remoteIp) { $dbserver->remoteIp = $message->messageIpAddress; } } if (count($message->behaviour) == 1 && $message->behaviour[0] == ROLE_BEHAVIORS::CHEF) { $message->behaviour[] = ROLE_BEHAVIORS::BASE; } $dbserver->SetProperty(SERVER_PROPERTIES::SZR_IMPORTING_BEHAVIOR, @implode(",", $message->behaviour)); $dbserver->save(); $importVersion = $dbserver->GetProperty(SERVER_PROPERTIES::SZR_IMPORTING_VERSION); if ($importVersion == 2) { $dbserver->SetProperties(array(SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); } else { if ($dbserver->isOpenstack()) { $env = $dbserver->GetEnvironmentObject(); $os = $env->openstack($dbserver->platform, $dbserver->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); $csServer = null; $list = $os->servers->list(true); do { foreach ($list as $_tmp) { $ipaddresses = array(); if (!is_array($_tmp->addresses)) { $_tmp->addresses = (array) $_tmp->addresses; } foreach ($_tmp->addresses as $net => $addresses) { foreach ($addresses as $addr) { if ($addr->version == 4) { array_push($ipaddresses, $addr->addr); } } } if ($_tmp->accessIPv4) { array_push($ipaddresses, $_tmp->accessIPv4); } if (in_array($dbserver->localIp, $ipaddresses) || in_array($dbserver->remoteIp, $ipaddresses)) { $osServer = $_tmp; } } } while (false !== ($list = $list->getNextPage())); if (!$osServer) { $this->logger->error(sprintf("Server not found on Openstack (server_id: %s, remote_ip: %s, local_ip: %s)", $dbserver->serverId, $dbserver->remoteIp, $dbserver->localIp)); return; } $dbserver->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::SERVER_ID => $osServer->id, OPENSTACK_SERVER_PROPERTIES::NAME => $osServer->name, OPENSTACK_SERVER_PROPERTIES::IMAGE_ID => $osServer->image->id, OPENSTACK_SERVER_PROPERTIES::FLAVOR_ID => $osServer->flavor->id, OPENSTACK_SERVER_PROPERTIES::HOST_ID => $osServer->hostId, SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); } elseif ($dbserver->isCloudstack()) { $dbserver->SetProperties(array(CLOUDSTACK_SERVER_PROPERTIES::SERVER_ID => $message->cloudstack->instanceId, CLOUDSTACK_SERVER_PROPERTIES::CLOUD_LOCATION => $message->cloudstack->availZone, SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); } else { switch ($dbserver->platform) { case SERVER_PLATFORMS::EC2: $dbserver->SetProperties(array(EC2_SERVER_PROPERTIES::AMIID => $message->awsAmiId, EC2_SERVER_PROPERTIES::INSTANCE_ID => $message->awsInstanceId, EC2_SERVER_PROPERTIES::INSTANCE_TYPE => $message->awsInstanceType, EC2_SERVER_PROPERTIES::AVAIL_ZONE => $message->awsAvailZone, EC2_SERVER_PROPERTIES::REGION => substr($message->awsAvailZone, 0, -1), SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); break; case SERVER_PLATFORMS::EUCALYPTUS: $dbserver->SetProperties(array(EUCA_SERVER_PROPERTIES::EMIID => $message->awsAmiId, EUCA_SERVER_PROPERTIES::INSTANCE_ID => $message->awsInstanceId, EUCA_SERVER_PROPERTIES::INSTANCE_TYPE => $message->awsInstanceType, EUCA_SERVER_PROPERTIES::AVAIL_ZONE => $message->awsAvailZone, SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); break; case SERVER_PLATFORMS::GCE: $dbserver->SetProperties(array(GCE_SERVER_PROPERTIES::CLOUD_LOCATION => $message->{$dbserver->platform}->cloudLocation, GCE_SERVER_PROPERTIES::SERVER_ID => $message->{$dbserver->platform}->serverId, GCE_SERVER_PROPERTIES::SERVER_NAME => $message->{$dbserver->platform}->serverName, GCE_SERVER_PROPERTIES::MACHINE_TYPE => $message->{$dbserver->platform}->machineType, SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); break; case SERVER_PLATFORMS::NIMBULA: $dbserver->SetProperties(array(NIMBULA_SERVER_PROPERTIES::NAME => $message->serverName, SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); break; case SERVER_PLATFORMS::RACKSPACE: $env = $dbserver->GetEnvironmentObject(); $cs = Scalr_Service_Cloud_Rackspace::newRackspaceCS($env->getPlatformConfigValue(RackspacePlatformModule::USERNAME, true, $dbserver->GetProperty(RACKSPACE_SERVER_PROPERTIES::DATACENTER)), $env->getPlatformConfigValue(RackspacePlatformModule::API_KEY, true, $dbserver->GetProperty(RACKSPACE_SERVER_PROPERTIES::DATACENTER)), $dbserver->GetProperty(RACKSPACE_SERVER_PROPERTIES::DATACENTER)); $csServer = null; $list = $cs->listServers(true); if ($list) { foreach ($list->servers as $_tmp) { if ($_tmp->addresses->public && in_array($message->remoteIp, $_tmp->addresses->public)) { $csServer = $_tmp; } } } if (!$csServer) { $this->logger->error(sprintf("Server not found on CloudServers (server_id: %s, remote_ip: %s, local_ip: %s)", $dbserver->serverId, $message->remoteIp, $message->localIp)); return; } $dbserver->SetProperties(array(RACKSPACE_SERVER_PROPERTIES::SERVER_ID => $csServer->id, RACKSPACE_SERVER_PROPERTIES::NAME => $csServer->name, RACKSPACE_SERVER_PROPERTIES::IMAGE_ID => $csServer->imageId, RACKSPACE_SERVER_PROPERTIES::FLAVOR_ID => $csServer->flavorId, RACKSPACE_SERVER_PROPERTIES::HOST_ID => $csServer->hostId, SERVER_PROPERTIES::ARCHITECTURE => $message->architecture)); break; } } } //TODO: search for existing bundle task // Bundle image $creInfo = new ServerSnapshotCreateInfo($dbserver, $dbserver->GetProperty(SERVER_PROPERTIES::SZR_IMPORTING_ROLE_NAME), SERVER_REPLACEMENT_TYPE::NO_REPLACE); $bundleTask = BundleTask::Create($creInfo); $bundleTask->osFamily = $message->dist->distributor; $bundleTask->osName = $message->dist->codename; $bundleTask->osVersion = $message->dist->release; if (in_array($message->dist->distributor, array('oel', 'redhat', 'scientific')) && $dbserver->platform == SERVER_PLATFORMS::EC2) { $bundleTask->bundleType = SERVER_SNAPSHOT_CREATION_TYPE::EC2_EBS_HVM; } $bundleTask->setDate("started"); $bundleTask->createdByEmail = $dbserver->GetProperty(SERVER_PROPERTIES::LAUNCHED_BY_EMAIL); $bundleTask->createdById = $dbserver->GetProperty(SERVER_PROPERTIES::LAUNCHED_BY_ID); if ($importVersion == 2) { $bundleTask->status = SERVER_SNAPSHOT_CREATION_STATUS::ESTABLISHING_COMMUNICATION; } $bundleTask->Save(); $dbserver->SetProperty(SERVER_PROPERTIES::SZR_IMPORTING_BUNDLE_TASK_ID, $bundleTask->id); } }
private function openstackSetFloatingIp(DBServer $DBServer) { $ipPool = $DBServer->GetFarmRoleObject()->GetSetting(DBFarmRole::SETTING_OPENSTACK_IP_POOL); if (!$DBServer->remoteIp && in_array($DBServer->status, array(SERVER_STATUS::PENDING, SERVER_STATUS::INIT, SERVER_STATUS::SUSPENDED)) && $ipPool) { //$ipAddress = \Scalr\Modules\Platforms\Openstack\Helpers\OpenstackHelper::setFloatingIpForServer($DBServer); $osClient = $DBServer->GetEnvironmentObject()->openstack($DBServer->platform, $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::CLOUD_LOCATION)); if ($osClient->hasService('network')) { $platform = PlatformFactory::NewPlatform($DBServer->platform); $serverIps = $platform->GetServerIPAddresses($DBServer); /********* USE Quantum (Neuron) NETWORK *******/ $ips = $osClient->network->floatingIps->list(); //Check free existing IP $ipAssigned = false; $ipAddress = false; $ipInfo = false; foreach ($ips as $ip) { if ($ip->fixed_ip_address == $serverIps['localIp'] && $ip->port_id) { $ipAssigned = true; $ipInfo = $ip; break; } if (!$ip->fixed_ip_address && $ip->floating_ip_address && !$ip->port_id) { $ipInfo = $ip; } } if ($ipInfo) { Logger::getLogger("Openstack")->warn(new FarmLogMessage($DBServer->farmId, "Found free floating IP: {$ipInfo->floating_ip_address} for use (" . json_encode($ipInfo) . ")")); } if (!$ipInfo || !$ipAssigned) { // Get instance port $ports = $osClient->network->ports->list(); foreach ($ports as $port) { /* */ if ($port->device_id == $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::SERVER_ID)) { $serverNetworkPort[] = $port; } } if (count($serverNetworkPort) == 0) { Logger::getLogger("Openstack")->error(new FarmLogMessage($DBServer->farmId, "Unable to identify network port of instance")); } else { $publicNetworkId = $ipPool; while (count($serverNetworkPort) > 0) { try { $port = array_shift($serverNetworkPort); if (!$ipInfo) { $ipInfo = $osClient->network->floatingIps->create($publicNetworkId, $port->id); Logger::getLogger("Openstack")->warn(new FarmLogMessage($DBServer->farmId, "Allocated new IP {$ipInfo->floating_ip_address} for port: {$port->id}")); } else { $osClient->network->floatingIps->update($ipInfo->id, $port->id); Logger::getLogger("Openstack")->warn(new FarmLogMessage($DBServer->farmId, "Existing floating IP {$ipInfo->floating_ip_address} was used for port: {$port->id}")); } $DBServer->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::FLOATING_IP => $ipInfo->floating_ip_address, OPENSTACK_SERVER_PROPERTIES::FLOATING_IP_ID => $ipInfo->id)); $ipAddress = $ipInfo->floating_ip_address; break; } catch (Exception $e) { $this->logger->error("Scalr unable to allocate new floating IP from pool: " . $e->getMessage()); } } } } else { Logger::getLogger("Openstack")->warn(new FarmLogMessage($DBServer->farmId, "IP: {$ipInfo->floating_ip_address} already assigned")); $ipAddress = $ipInfo->floating_ip_address; } } else { /********* USE NOVA NETWORK *******/ //Check free existing IP $ipAssigned = false; $ipAddress = false; $ips = $osClient->servers->floatingIps->list($ipPool); foreach ($ips as $ip) { //if (!$ip->instance_id) { // $ipAddress = $ip->ip; //} if ($ip->instance_id == $DBServer->GetProperty(OPENSTACK_SERVER_PROPERTIES::SERVER_ID)) { $ipAddress = $ip->ip; $ipAssigned = true; } } //If no free IP allocate new from pool if (!$ipAddress) { $ip = $osClient->servers->floatingIps->create($ipPool); $ipAddress = $ip->ip; $DBServer->SetProperties(array(OPENSTACK_SERVER_PROPERTIES::FLOATING_IP => $ip->ip, OPENSTACK_SERVER_PROPERTIES::FLOATING_IP_ID => $ip->id)); } if (!$ipAssigned) { //Associate floating IP with Instance $osClient->servers->addFloatingIp($DBServer->GetCloudServerID(), $ipAddress); } } if ($ipAddress) { $DBServer->remoteIp = $ipAddress; $DBServer->Save(); $DBServer->SetProperty(SERVER_PROPERTIES::SYSTEM_IGNORE_INBOUND_MESSAGES, null); } } }
public function LaunchServer(DBServer $DBServer, Scalr_Server_LaunchOptions $launchOptions = null) { $RDSClient = $this->getRdsClient($DBServer->GetEnvironmentObject(), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::REGION)); $DBRole = DBRole::loadById($DBServer->roleId); $server_id = "scalr-{$DBServer->serverId}"; $avail_zone = $DBServer->GetProperty(RDS_SERVER_PROPERTIES::AVAIL_ZONE) ? $DBServer->GetProperty(RDS_SERVER_PROPERTIES::AVAIL_ZONE) : $DBServer->GetProperty(RDS_SERVER_PROPERTIES::REGION) . "a"; try { if ($DBRole->getImageId(SERVER_PLATFORMS::RDS, $DBServer->GetProperty(RDS_SERVER_PROPERTIES::REGION)) == 'ScalrEmpty') { $RDSClient->CreateDBInstance($server_id, $DBServer->GetProperty(RDS_SERVER_PROPERTIES::STORAGE), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::INSTANCE_CLASS), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::INSTANCE_ENGINE), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::MASTER_USER), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::MASTER_PASS), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::PORT), null, null, null, $avail_zone, null, null, null); } else { $RDSClient->RestoreDBInstanceFromDBSnapshot($DBRole->getImageId(SERVER_PLATFORMS::RDS, $DBServer->GetProperty(RDS_SERVER_PROPERTIES::REGION)), $server_id, $DBServer->GetProperty(RDS_SERVER_PROPERTIES::INSTANCE_CLASS), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::PORT), $DBServer->GetProperty(RDS_SERVER_PROPERTIES::AVAIL_ZONE)); } $DBServer->SetProperty(RDS_SERVER_PROPERTIES::INSTANCE_ID, $server_id); $DBServer->SetProperty(RDS_SERVER_PROPERTIES::SNAPSHOT_ID, $DBRole->getImageId(SERVER_PLATFORMS::RDS, $DBServer->GetProperty(RDS_SERVER_PROPERTIES::REGION))); return $DBServer; } catch (Exception $e) { throw new Exception(sprintf(_("Cannot launch new instance. %s"), $e->getMessage())); } }
private function onHostInit($message, DBServer $dbserver) { if ($dbserver->status == SERVER_STATUS::PENDING) { // Update server crypto key $srv_props = array(); if ($message->cryptoKey) { $srv_props[SERVER_PROPERTIES::SZR_KEY] = trim($message->cryptoKey); $srv_props[SERVER_PROPERTIES::SZR_KEY_TYPE] = SZR_KEY_TYPE::PERMANENT; } if ($dbserver->platform != SERVER_PLATFORMS::CLOUDSTACK) { $srv_props[SERVER_PROPERTIES::SZR_SNMP_PORT] = $message->snmpPort; $remoteIp = $message->remoteIp; } else { if ($dbserver->farmRoleId) { $dbFarmRole = $dbserver->GetFarmRoleObject(); $networkType = $dbFarmRole->GetSetting(DBFarmRole::SETTING_CLOUDSTACK_NETWORK_TYPE); if ($networkType == 'Direct') { $remoteIp = $message->localIp; $srv_props[SERVER_PROPERTIES::SZR_SNMP_PORT] = $message->snmpPort; } else { $env = $dbserver->GetEnvironmentObject(); $remoteIp = $env->getPlatformConfigValue(Modules_Platforms_Cloudstack::SHARED_IP . "." . $dbserver->GetProperty(CLOUDSTACK_SERVER_PROPERTIES::CLOUD_LOCATION), false); } } else { $remoteIp = $message->localIp; $srv_props[SERVER_PROPERTIES::SZR_SNMP_PORT] = $message->snmpPort; } } //Update auto-update settings //TODO: Check auto-update client version if ($dbserver->IsSupported('0.7.225')) { $dbserver->SetProperties($srv_props); try { $repo = $dbserver->GetFarmObject()->GetSetting(DBFarm::SETTING_SZR_UPD_REPOSITORY); $schedule = $dbserver->GetFarmObject()->GetSetting(DBFarm::SETTING_SZR_UPD_SCHEDULE); if ($repo && $schedule) { $updateClient = new Scalr_Net_Scalarizr_UpdateClient($dbserver); $updateClient->configure($repo, $schedule); } } catch (Exception $e) { } } // MySQL specific $dbFarmRole = $dbserver->GetFarmRoleObject(); if ($dbFarmRole->GetRoleObject()->hasBehavior(ROLE_BEHAVIORS::MYSQL)) { $master = $dbFarmRole->GetFarmObject()->GetMySQLInstances(true); // If no masters in role this server becomes it if (!$master[0] && !(int) $dbFarmRole->GetSetting(DbFarmRole::SETTING_MYSQL_SLAVE_TO_MASTER)) { $srv_props[SERVER_PROPERTIES::DB_MYSQL_MASTER] = 1; } } //MSR Replication Master //TODO: MySQL if ($dbFarmRole->GetRoleObject()->getDbMsrBehavior()) { $servers = $dbFarmRole->GetServersByFilter(array('status' => array(SERVER_STATUS::INIT, SERVER_STATUS::RUNNING))); if (!$dbFarmRole->GetSetting(Scalr_Db_Msr::SLAVE_TO_MASTER)) { $masterFound = false; foreach ($servers as $server) { if ($server->GetProperty(Scalr_Db_Msr::REPLICATION_MASTER)) { $masterFound = true; } } if (!$masterFound) { $srv_props[Scalr_Db_Msr::REPLICATION_MASTER] = 1; } } elseif ($dbFarmRole->GetSetting(Scalr_Db_Msr::SLAVE_TO_MASTER) && count($servers) == 0) { $dbFarmRole->SetSetting(Scalr_Db_Msr::SLAVE_TO_MASTER, 0); $srv_props[Scalr_Db_Msr::REPLICATION_MASTER] = 1; } } $dbserver->SetProperties($srv_props); return new HostInitEvent($dbserver, $message->localIp, $remoteIp, $message->sshPubKey); } else { $this->logger->error("Strange situation. Received HostInit message" . " from server '{$dbserver->serverId}' ({$message->remoteIp})" . " with state {$dbserver->status}!"); } }
public function PutAccessData(DBServer $DBServer, Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_NewMasterUp; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateBackup; if ($put) { $environment = $DBServer->GetEnvironmentObject(); $accessData = new stdClass(); $accessData->username = $environment->getPlatformConfigValue(self::USERNAME); $accessData->apiUrl = $environment->getPlatformConfigValue(self::API_URL); $accessData->password = $environment->getPlatformConfigValue(self::PASSWORD); $message->platformAccessData = $accessData; } }
/** * Associates IP Address to the server * * @param \DBServer $dbServer \DBServer object * @param string $ipAddress Public IP address to associate with server. * @throws Exception */ private static function associateIpAddress(\DBServer $dbServer, $ipAddress, $allocationId = null) { $platform = PlatformFactory::NewPlatform($dbServer->platform); $cs = $dbServer->GetEnvironmentObject()->cloudstack($dbServer->platform); $assign_retries = 1; $retval = false; // Remove OLD static NAT if ($dbServer->remoteIp) { try { $requestObject = new ListIpAddressesData(); $requestObject->ipaddress = $dbServer->remoteIp; $info = $cs->listPublicIpAddresses($requestObject); $info = $info[0]; if ($info->issystem && $info->isstaticnat) { $cs->firewall->disableStaticNat($info->id); \Scalr::getContainer()->logger('Cloudstack_Helper')->warn("[STATIC_NAT] Removed old IP static NAT from IP: {$info->id}"); } } catch (Exception $e) { \Scalr::getContainer()->logger('Cloudstack_Helper')->error("[STATIC_NAT] Unable to disable old static NAT: {$e->getMessage()}"); } } $requestObject = new ListIpAddressesData(); $requestObject->ipaddress = $ipAddress; $info = $cs->listPublicIpAddresses($requestObject); $info = $info[0]; $oldVM = $info->virtualmachinedisplayname; if ($info->isstaticnat) { \Scalr::getContainer()->logger('Cloudstack_Helper')->warn("[STATIC_NAT] IP {$ipAddress} associated with another VM. Disabling Static NAT."); try { $result = $cs->firewall->disableStaticNat($allocationId); for ($i = 0; $i <= 20; $i++) { $res = $cs->queryAsyncJobResult($result->jobid); if ($res->jobstatus != 0) { \Scalr::getContainer()->logger('Cloudstack_Helper')->warn("[STATIC_NAT] After {$i}x2 seconds, IP {$ipAddress} is free and ready to use."); //UPDATING OLD SERVER try { $oldDbServer = \DBServer::LoadByID($oldVM); $ips = $platform->GetServerIPAddresses($oldDbServer); $oldDbServer->remoteIp = $ips['remoteIp']; $oldDbServer->save(); } catch (Exception $e) { } break; } sleep(2); } } catch (Exception $e) { \Scalr::getContainer()->logger('Cloudstack_Helper')->error("[STATIC_NAT] Unable to disable static NAT: {$e->getMessage()}"); } } $assignRetries = 0; while (true) { try { $assignRetries++; $cs->firewall->enableStaticNat(array('ipaddressid' => $allocationId, 'virtualmachineid' => $dbServer->GetCloudServerID())); $retval = true; break; } catch (Exception $e) { if (!stristr($e->getMessage(), "already assigned to antoher vm") || $assignRetries == 3) { \Scalr::getContainer()->logger('Cloudstack_Helper')->error("[STATIC_NAT] Unable to enable static NAT ({$assignRetries}): {$e->getMessage()}"); throw new Exception($e->getMessage()); } else { sleep(1); } } } return $retval; }
public function PutAccessData(DBServer $DBServer, Scalr_Messaging_Msg $message) { $put = false; $put |= $message instanceof Scalr_Messaging_Msg_Rebundle; $put |= $message instanceof Scalr_Messaging_Msg_BeforeHostUp; $put |= $message instanceof Scalr_Messaging_Msg_HostInitResponse; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_Mysql_CreateBackup; $put |= $message instanceof Scalr_Messaging_Msg_BeforeHostTerminate; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_PromoteToMaster; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateDataBundle; $put |= $message instanceof Scalr_Messaging_Msg_DbMsr_CreateBackup; if ($put) { $environment = $DBServer->GetEnvironmentObject(); $accessData = new stdClass(); $accessData->accountId = $environment->getPlatformConfigValue(self::ACCOUNT_ID); $accessData->keyId = $environment->getPlatformConfigValue(self::ACCESS_KEY); $accessData->key = $environment->getPlatformConfigValue(self::SECRET_KEY); $accessData->cert = $environment->getPlatformConfigValue(self::CERTIFICATE); $accessData->pk = $environment->getPlatformConfigValue(self::PRIVATE_KEY); $message->platformAccessData = $accessData; } }