Пример #1
0
 protected function run1($stage)
 {
     $this->console->out("Initializing instance_type_name field in servers_history table");
     $result = $this->db->Execute("\n            SELECT sh.* FROM servers_history sh\n            JOIN servers s USING(server_id)\n            WHERE sh.instance_type_name IS NULL\n                AND sh.type IS NOT NULL\n                AND sh.cloud_location IS NOT NULL\n            ORDER BY sh.env_id, sh.platform DESC\n        ");
     $env = null;
     $platform = null;
     $this->db->BeginTrans();
     try {
         $sql = "UPDATE servers_history sh SET sh.instance_type_name = ? WHERE sh.server_id = ?";
         while ($record = $result->FetchRow()) {
             if (!isset($env) || $env->id != $record['env_id']) {
                 $env = Scalr_Environment::init()->loadById($record['env_id']);
                 $platform = null;
             }
             if (in_array($record['platform'], [\SERVER_PLATFORMS::EC2, \SERVER_PLATFORMS::GCE])) {
                 $this->db->Execute($sql, [$record['type'], $record['server_id']]);
                 continue;
             }
             if (!isset($platform) || $platform != $record['platform']) {
                 $platform = $record['platform'];
                 $platformModule = PlatformFactory::NewPlatform($record['platform']);
                 $url = $platformModule->getEndpointUrl($env);
             }
             $cloudLocationId = CloudLocation::calculateCloudLocationId($record['platform'], $record['cloud_location'], $url);
             $instanceTypeEntity = CloudInstanceType::findPk($cloudLocationId, $record['type']);
             /* @var $instanceTypeEntity CloudInstanceType */
             if ($instanceTypeEntity) {
                 $this->db->Execute($sql, [$instanceTypeEntity->name, $record['server_id']]);
             }
         }
         $this->db->CommitTrans();
     } catch (Exception $e) {
         $this->db->RollbackTrans();
     }
 }
Пример #2
0
 /**
  * Gets a normalized url for an each platform
  *
  * @param    string $platform Cloud platform
  * @return   string Returns url
  */
 public function getUrl($platform)
 {
     if (!isset($this->aUrl[$platform])) {
         if ($platform == \SERVER_PLATFORMS::EC2 || $platform == \SERVER_PLATFORMS::GCE || $platform == \SERVER_PLATFORMS::AZURE) {
             $value = '';
         } else {
             if (PlatformFactory::isOpenstack($platform)) {
                 $value = CloudLocation::normalizeUrl($this->env->keychain($platform)->properties[CloudCredentialsProperty::OPENSTACK_KEYSTONE_URL]);
             } else {
                 if (PlatformFactory::isCloudstack($platform)) {
                     $value = CloudLocation::normalizeUrl($this->env->keychain($platform)->properties[CloudCredentialsProperty::CLOUDSTACK_API_URL]);
                 }
             }
         }
         $this->aUrl[$platform] = $value;
     }
     return $this->aUrl[$platform];
 }
Пример #3
0
 /**
  * SCALRCORE-951 we should avoid ON DUPLICATE KEY UPDATE clause on tables with multiple unique indexes
  * @test
  * @functional
  */
 public function testFunctionalSeveralUniqueKeys()
 {
     $db = \Scalr::getDb();
     //Removes previously created records if they exist
     $this->cleanupCloudLocations();
     $cl2Identifier = CloudLocation::calculateCloudLocationId(self::CL_PLATFORM, self::CL_NAME, self::CL_URL);
     $cl3Identifier = CloudLocation::calculateCloudLocationId(self::CL_PLATFORM, self::CL_NAME . '3', self::CL_URL);
     //Creates the first record
     $cl = $this->getCloudLocationEntity();
     $cl->save();
     unset($cl);
     //Checks if it has been saved properly
     $cl = CloudLocation::findPk(self::CL_LOC_ID);
     $this->assertInstanceOf('Scalr\\Model\\Entity\\CloudLocation', $cl);
     $this->assertEquals(self::CL_LOC_ID, $cl->cloudLocationId);
     $this->assertEquals(self::CL_URL, $cl->url);
     $this->assertEquals(self::CL_NAME, $cl->cloudLocation);
     $this->assertEquals(self::CL_PLATFORM, $cl->platform);
     $cl3 = $this->getCloudLocationEntity($cl3Identifier);
     $cl3->cloudLocation = self::CL_NAME . '3';
     $cl3->save();
     //Record with this unique key already exists
     $cl3->cloudLocation = self::CL_NAME;
     //Saving record with existing unique key
     $ex = false;
     try {
         $cl3->save();
         $this->cleanupCloudLocations();
     } catch (Exception $e) {
         //"Duplicate entry 'test--test' for key 'idx_unique'"
         $ex = true;
         $this->assertContains("Duplicate entry", $e->getMessage());
     }
     $this->assertTrue($ex, "Duplicate entry 'test--test' for key 'idx_unique' must be thrown here (3)");
     //Trying to create with the same unique key as $cl but different primary key
     $cl2 = $this->getCloudLocationEntity($cl2Identifier);
     //Checks they're different
     $this->assertNotEquals(self::CL_LOC_ID, $cl2Identifier);
     //unique key should cause error, and should not be just ignored
     $ex = false;
     try {
         $cl2->save();
         $this->cleanupCloudLocations();
     } catch (Exception $e) {
         $ex = true;
         $this->assertContains("Duplicate entry", $e->getMessage());
     }
     $this->assertTrue($ex, "Duplicate entry 'test--test' for key 'idx_unique' must be thrown here (2)");
     $this->assertNull(CloudLocation::findPk($cl2Identifier));
     $this->cleanupCloudLocations();
 }
Пример #4
0
 /**
  * {@inheritdoc}
  * @see \Scalr\Modules\PlatformModuleInterface::getInstanceType()
  */
 public function getInstanceType($instanceTypeId, \Scalr_Environment $env, $cloudLocation = null)
 {
     $cloudLocationId = CloudLocation::calculateCloudLocationId(SERVER_PLATFORMS::GCE, $cloudLocation, $this->getEndpointUrl($env));
     $cit = CloudInstanceType::findPk($cloudLocationId, $instanceTypeId);
     if ($cit === null) {
         $instanceTypes = $this->getInstanceTypes($env, $cloudLocation, true);
         if (!empty($instanceTypes[$instanceTypeId])) {
             $cit = CloudInstanceType::findPk($cloudLocationId, $instanceTypeId);
         }
     }
     return $cit;
 }
 /**
  * {@inheritdoc}
  * @see \Scalr\Modules\PlatformModuleInterface::getInstanceTypes()
  */
 public function getInstanceTypes(\Scalr_Environment $env = null, $cloudLocation = null, $details = false)
 {
     if (!$env instanceof \Scalr_Environment) {
         throw new \InvalidArgumentException(sprintf("Method %s requires environment to be specified.", __METHOD__));
     }
     $ret = [];
     $detailed = [];
     //Trying to retrieve instance types from the cache
     $url = $this->getConfigVariable(static::API_URL, $env);
     $collection = $this->getCachedInstanceTypes($this->platform, $url, $cloudLocation ?: '');
     if ($collection === false || $collection->count() == 0) {
         //No cache. Fetching data from the cloud
         $client = $env->cloudstack($this->platform);
         foreach ($client->listServiceOfferings() as $offering) {
             $detailed[(string) $offering->id] = array('name' => (string) $offering->name, 'ram' => (string) $offering->memory, 'vcpus' => (string) $offering->cpunumber, 'disk' => "", 'type' => strtoupper((string) $offering->storagetype));
             if (!$details) {
                 $ret[(string) $offering->id] = (string) $offering->name;
             } else {
                 $ret[(string) $offering->id] = $detailed[(string) $offering->id];
             }
         }
         //Refreshes/creates a cache
         CloudLocation::updateInstanceTypes($this->platform, $url, $cloudLocation ?: '', $detailed);
     } else {
         //Takes data from cache
         foreach ($collection as $cloudInstanceType) {
             /* @var $cloudInstanceType \Scalr\Model\Entity\CloudInstanceType */
             if (!$details) {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->name;
             } else {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->getProperties();
             }
         }
     }
     return $ret;
 }
Пример #6
0
 /**
  * {@inheritdoc}
  * @see \Scalr\Modules\PlatformModuleInterface::getInstanceTypes()
  */
 public function getInstanceTypes(\Scalr_Environment $env = null, $cloudLocation = null, $details = false)
 {
     if (!$env instanceof \Scalr_Environment || empty($cloudLocation)) {
         throw new \InvalidArgumentException(sprintf("Method %s requires both environment object and cloudLocation to be specified.", __METHOD__));
     }
     $ret = [];
     $detailed = [];
     //Trying to retrieve instance types from the cache
     $url = $env->cloudCredentials($this->platform)->properties[Entity\CloudCredentialsProperty::OPENSTACK_KEYSTONE_URL];
     $collection = $this->getCachedInstanceTypes($this->platform, $url, $cloudLocation);
     if ($collection === false || $collection->count() == 0) {
         //No cache. Fetching data from the cloud
         $client = $env->openstack($this->platform, $cloudLocation);
         foreach ($client->servers->listFlavors() as $flavor) {
             $detailed[(string) $flavor->id] = array('name' => (string) $flavor->name, 'ram' => (string) $flavor->ram, 'vcpus' => (string) $flavor->vcpus, 'disk' => (string) $flavor->disk, 'type' => 'HDD');
             if (!$details) {
                 $ret[(string) $flavor->id] = (string) $flavor->name;
             } else {
                 $ret[(string) $flavor->id] = $detailed[(string) $flavor->id];
             }
         }
         //Refreshes/creates a cache
         CloudLocation::updateInstanceTypes($this->platform, $url, $cloudLocation, $detailed);
     } else {
         //Takes data from cache
         foreach ($collection as $cloudInstanceType) {
             /* @var $cloudInstanceType \Scalr\Model\Entity\CloudInstanceType */
             if (!$details) {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->name;
             } else {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->getProperties();
             }
         }
     }
     return $ret;
 }
Пример #7
0
 /**
  * Normalizes an url from environment settings to use for price_history table
  *
  * @param   string    $url  Original url
  * @return  string    Returns normalized url to use in price_history database table
  */
 public function normalizeUrl($url)
 {
     return CloudLocation::normalizeUrl($url);
 }
 /**
  * {@inheritdoc}
  * @see \Scalr\Modules\PlatformModuleInterface::getInstanceTypes()
  */
 public function getInstanceTypes(\Scalr_Environment $env = null, $cloudLocation = null, $details = false)
 {
     if (!$env instanceof \Scalr_Environment || empty($cloudLocation)) {
         throw new \InvalidArgumentException(sprintf("Method %s requires both environment object and cloudLocation to be specified.", __METHOD__));
     }
     $ret = [];
     $detailed = [];
     //Trying to retrieve instance types from the cache
     $url = $this->getConfigVariable(static::EC2_URL, $env, false, $cloudLocation);
     $collection = $this->getCachedInstanceTypes(\SERVER_PLATFORMS::EUCALYPTUS, $url, $cloudLocation);
     if ($collection === false || $collection->count() == 0) {
         //No cache. Fetching data from the cloud
         $client = $env->eucalyptus($cloudLocation);
         foreach ($client->describeInstanceTypes() as $item) {
             $detailed[(string) $item->name] = ['name' => (string) $item->name, 'ram' => (string) $item->memory, 'vcpus' => (string) $item->cpu, 'disk' => (string) $item->disk, 'type' => 'hdd'];
             if (!$details) {
                 $ret[(string) $item->name] = sprintf("%s (CPUs: %d DISK: %d RAM: %d)", $item->name, $item->cpu, $item->disk, $item->memory);
             } else {
                 $ret[(string) $item->name] = $detailed[(string) $item->name];
             }
         }
         //Refreshes/creates a cache
         CloudLocation::updateInstanceTypes(\SERVER_PLATFORMS::EUCALYPTUS, $url, $cloudLocation, $detailed);
     } else {
         //Takes data from cache
         foreach ($collection as $cloudInstanceType) {
             /* @var $cloudInstanceType \Scalr\Model\Entity\CloudInstanceType */
             if (!$details) {
                 $ret[$cloudInstanceType->instanceTypeId] = sprintf("%s (CPUs: %d DISK: %d RAM: %d)", $cloudInstanceType->name, $cloudInstanceType->cpu, $cloudInstanceType->disk, $cloudInstanceType->ram);
             } else {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->getProperties();
             }
         }
     }
     return $ret;
 }
Пример #9
0
 /**
  * {@inheritdoc}
  * @see \Scalr\Modules\PlatformModuleInterface::getInstanceTypes()
  */
 public function getInstanceTypes(\Scalr_Environment $env = null, $cloudLocation = null, $details = false)
 {
     if (!$env instanceof \Scalr_Environment || empty($cloudLocation)) {
         throw new \InvalidArgumentException(sprintf("Method %s requires both environment object and cloudLocation to be specified.", __METHOD__));
     }
     $collection = $this->getCachedInstanceTypes(\SERVER_PLATFORMS::AZURE, '', $cloudLocation);
     if ($collection === false || $collection->count() == 0) {
         $instanceTypesResult = $env->azure()->compute->location->getInstanceTypesList($env->keychain(SERVER_PLATFORMS::AZURE)->properties[CloudCredentialsProperty::AZURE_SUBSCRIPTION_ID], $cloudLocation);
         $ret = [];
         foreach ($instanceTypesResult as $instanceType) {
             $detailed[$instanceType->name] = ['name' => $instanceType->name, 'ram' => $instanceType->memoryInMB, 'vcpus' => $instanceType->numberOfCores, 'disk' => $instanceType->resourceDiskSizeInMB / 1024, 'type' => '', 'maxdatadiskcount' => $instanceType->maxDataDiskCount, 'rootdevicesize' => $instanceType->osDiskSizeInMB / 1024];
             if (!$details) {
                 $ret[$instanceType->name] = array($instanceType->name => $instanceType->name);
             } else {
                 $ret[$instanceType->name] = $detailed[$instanceType->name];
             }
         }
         CloudLocation::updateInstanceTypes(\SERVER_PLATFORMS::AZURE, '', $cloudLocation, $detailed);
     } else {
         //Takes data from cache
         foreach ($collection as $cloudInstanceType) {
             /* @var $cloudInstanceType \Scalr\Model\Entity\CloudInstanceType */
             if (!$details) {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->name;
             } else {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->getProperties();
             }
         }
     }
     return $ret;
 }
Пример #10
0
 /**
  * Gets active instance types for the specified cloud platform, url and location
  * from the cache
  *
  * @param   string     $platform      A cloud platform
  * @param   string     $url           A cloud endpoint url
  * @param   string     $cloudLocation A cloud location
  *
  * @return  \Scalr\Model\Collections\ArrayCollection|boolean
  *          Returns collection of the CloudInstanceType entities on success or false otherwise
  */
 protected function getCachedInstanceTypes($platform, $url, $cloudLocation)
 {
     //Gets a lifetime of the cached data from the config
     $lifetime = (int) \Scalr::config('scalr.cache.instance_types.lifetime');
     //If this lifetime equals zero it means we have to warm-up cache
     if ($lifetime === 0) {
         CloudLocation::warmUp();
         //We have no cached instance types
         return false;
     }
     //Checks whether there are active instance types in the cache taking lifetime into account.
     if (!CloudLocation::hasInstanceTypes($platform, $url, $cloudLocation, $lifetime)) {
         //No cached data
         return false;
     }
     //Fetches cloud location entity from the cache
     $cl = CloudLocation::findPk(CloudLocation::calculateCloudLocationId($platform, $cloudLocation, $url));
     //It is possible that it might have been already removed
     if (!$cl instanceof CloudLocation) {
         //No cached data
         return false;
     }
     //Retrieves an instance types for this cloud location.
     //We should actually return only active types.
     return $cl->getActiveInstanceTypes();
 }
Пример #11
0
 /**
  * xGetPlatformInstanceTypesAction
  *
  * @param    string        $platform      The name of the cloud platform
  * @param    string        $cloudLocation The cloud location
  * @param    string        $envId         optional The identifier of the environment
  * @param    string        $effectiveDate optional The date on which prices should be applied YYYY-MM-DD
  * @throws   \Exception
  */
 public function xGetPlatformInstanceTypesAction($platform, $cloudLocation, $envId = null, $effectiveDate = null)
 {
     list($curDate, $effectiveDate) = $this->handleEffectiveDate($effectiveDate);
     $pm = PlatformFactory::NewPlatform($platform);
     $env = null;
     $url = '';
     try {
         if (!empty($envId)) {
             $env = Scalr_Environment::init()->loadById($envId);
             if (PlatformFactory::isOpenstack($platform)) {
                 $key = $platform . '.' . OpenstackPlatformModule::KEYSTONE_URL;
             } else {
                 if (PlatformFactory::isCloudstack($platform)) {
                     $key = $platform . '.' . CloudstackPlatformModule::API_URL;
                 } else {
                     if ($platform == SERVER_PLATFORMS::EUCALYPTUS) {
                         $key = EucalyptusPlatformModule::EC2_URL;
                         $url = $this->getContainer()->analytics->prices->normalizeUrl($env->getPlatformConfigValue($key, false, $cloudLocation));
                     } else {
                         throw new Exception('This action is not yet supported for the specified cloud platform.');
                     }
                 }
             }
             if (empty($url)) {
                 $url = $this->getContainer()->analytics->prices->normalizeUrl($env->getPlatformConfigValue($key));
             }
         } else {
             if ($platform == SERVER_PLATFORMS::EC2 || $platform == SERVER_PLATFORMS::GCE) {
                 $gcenvid = $this->getPlatformEnvId($platform);
                 $env = Scalr_Environment::init()->loadById($gcenvid);
             }
         }
     } catch (Exception $e) {
         if (stristr($e->getMessage(), 'not found')) {
             //Tries to find url from the cloud_locations table
             if (empty($url) && (PlatformFactory::isOpenstack($platform) || PlatformFactory::isCloudstack($platform))) {
                 $clEntity = CloudLocation::findOne([['platform' => $platform], ['cloudLocation' => $cloudLocation]], ['updated' => false]);
                 if ($clEntity instanceof CloudLocation) {
                     $url = $clEntity->url;
                 }
             }
         } else {
             throw $e;
         }
     }
     $result = $this->getTypesWithPrices($cloudLocation, $url, $pm, $platform, $effectiveDate, $env);
     $this->response->data(['data' => $result]);
 }
Пример #12
0
 /**
  * Gets cloud instance type's name
  *
  * @param string $instanceTypeId    Instance type identifier
  * @param string $envId             Environment identifier
  * @param string $platform          Platform
  * @param string $cloudLocation     Cloud location
  * @return string
  */
 public function getInstanceTypeName($instanceTypeId, $envId, $platform, $cloudLocation)
 {
     static $instanceTypeNames = [];
     static $urlCache = [];
     if ($platform == \SERVER_PLATFORMS::EC2) {
         return $instanceTypeId;
     }
     if (!isset($instanceTypeNames[$envId][$platform][$cloudLocation][$instanceTypeId])) {
         try {
             if (!isset($urlCache[$envId][$platform])) {
                 $curEnv = Scalr_Environment::init()->loadById($envId);
                 $platformObj = PlatformFactory::NewPlatform($platform);
                 $urlCache[$envId][$platform] = $platformObj->getEndpointUrl($curEnv);
             }
             $cloudLocationId = CloudLocation::calculateCloudLocationId($platform, $cloudLocation, $urlCache[$envId][$platform]);
             $rows = $this->db->Execute("\n                    SELECT cit.instance_type_id, cit.name\n                    FROM cloud_instance_types cit\n                    WHERE cit.cloud_location_id = UNHEX(?)\n                ", [str_replace('-', '', $cloudLocationId)]);
             while ($row = $rows->FetchRow()) {
                 $instanceTypeNames[$envId][$platform][$cloudLocation][$row['instance_type_id']] = $row['name'];
             }
         } catch (Exception $e) {
         }
     }
     return !empty($instanceTypeNames[$envId][$platform][$cloudLocation][$instanceTypeId]) ? $instanceTypeNames[$envId][$platform][$cloudLocation][$instanceTypeId] : $instanceTypeId;
 }
Пример #13
0
<?php

require_once __DIR__ . '/../src/prepend.inc.php';
use Scalr\Model\Entity\CloudLocation;
//Cleans out cloud locations cache
CloudLocation::warmUp();
Пример #14
0
 /**
  * xGetPlatformInstanceTypesAction
  *
  * @param    string        $platform      The name of the cloud platform
  * @param    string        $cloudLocation The cloud location
  * @param    string        $envId         optional The identifier of the environment
  * @param    string        $effectiveDate optional The date on which prices should be applied YYYY-MM-DD
  * @throws   \Exception
  */
 public function xGetPlatformInstanceTypesAction($platform, $cloudLocation, $envId = null, $effectiveDate = null)
 {
     list($curDate, $effectiveDate) = $this->handleEffectiveDate($effectiveDate);
     $pm = PlatformFactory::NewPlatform($platform);
     $env = null;
     $url = '';
     try {
         if (!empty($envId)) {
             $env = Scalr_Environment::init()->loadById($envId);
             if (PlatformFactory::isOpenstack($platform)) {
                 $key = Entity\CloudCredentialsProperty::OPENSTACK_KEYSTONE_URL;
             } else {
                 if (PlatformFactory::isCloudstack($platform)) {
                     $key = Entity\CloudCredentialsProperty::CLOUDSTACK_API_URL;
                 } else {
                     throw new Exception('This action is not yet supported for the specified cloud platform.');
                 }
             }
             if (empty($url)) {
                 $url = $env->keychain($platform)->properties[$key];
             }
         } else {
             if ($platform == SERVER_PLATFORMS::EC2 || $platform == SERVER_PLATFORMS::GCE) {
                 $gcenvid = $this->getEnvIdByPlatform($platform);
                 $env = Scalr_Environment::init()->loadById($gcenvid);
             }
         }
     } catch (Exception $e) {
         if (stristr($e->getMessage(), 'not found')) {
             //Tries to find url from the cloud_locations table
             if (empty($url) && (PlatformFactory::isOpenstack($platform) || PlatformFactory::isCloudstack($platform))) {
                 $clEntity = CloudLocation::findOne([['platform' => $platform], ['cloudLocation' => $cloudLocation]], null, ['updated' => false]);
                 if ($clEntity instanceof CloudLocation) {
                     $url = $clEntity->url;
                 }
             }
         } else {
             throw $e;
         }
     }
     $result = $this->getTypesWithPrices($cloudLocation, $url, $pm, $platform, $effectiveDate, $env);
     $this->response->data(['data' => $result]);
 }
Пример #15
0
 /**
  * {@inheritdoc}
  * @see \Scalr\Modules\PlatformModuleInterface::getInstanceTypes()
  */
 public function getInstanceTypes(\Scalr_Environment $env = null, $cloudLocation = null, $details = false)
 {
     if (!$env instanceof \Scalr_Environment || empty($cloudLocation)) {
         throw new \InvalidArgumentException(sprintf("Method %s requires both environment object and cloudLocation to be specified.", __METHOD__));
     }
     $gceClient = $this->getClient($env);
     $projectId = $env->getPlatformConfigValue(self::PROJECT_ID);
     $ret = [];
     $detailed = [];
     //Trying to retrieve instance types from the cache
     $collection = $this->getCachedInstanceTypes(\SERVER_PLATFORMS::GCE, '', $cloudLocation);
     if ($collection === false || $collection->count() == 0) {
         //No cache. Fetching data from the cloud
         $types = $gceClient->machineTypes->listMachineTypes($projectId, $cloudLocation);
         foreach ($types->items as $item) {
             $isEphemeral = substr($item->name, -2) == '-d';
             if (!$isEphemeral) {
                 $detailed[(string) $item->name] = ['name' => (string) $item->name, 'description' => (string) $item->description, 'ram' => (string) $item->memoryMb, 'vcpus' => (string) $item->guestCpus, 'disk' => (string) $item->imageSpaceGb, 'type' => "HDD"];
                 if (!$details) {
                     $ret[(string) $item->name] = "{$item->name} ({$item->description})";
                 } else {
                     $ret[(string) $item->name] = $detailed[(string) $item->name];
                 }
             }
         }
         //Refreshes/creates a cache
         CloudLocation::updateInstanceTypes(\SERVER_PLATFORMS::GCE, '', $cloudLocation, $detailed);
     } else {
         //Takes data from cache
         foreach ($collection as $cloudInstanceType) {
             /* @var $cloudInstanceType \Scalr\Model\Entity\CloudInstanceType */
             if (!$details) {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->name . "(" . $cloudInstanceType->options->description . ")";
             } else {
                 $ret[$cloudInstanceType->instanceTypeId] = $cloudInstanceType->getProperties();
             }
         }
     }
     return $ret;
 }
Пример #16
0
 /**
  * Gets a normalized url for an each platform
  *
  * @param    string $platform Cloud platform
  * @return   string Returns url
  */
 public function getUrl($platform)
 {
     if (!isset($this->aUrl[$platform])) {
         if ($platform == \SERVER_PLATFORMS::EC2) {
             $value = '';
         } else {
             if (PlatformFactory::isOpenstack($platform)) {
                 $value = CloudLocation::normalizeUrl($this->env->getPlatformConfigValue($platform . '.' . OpenstackPlatformModule::KEYSTONE_URL));
             } else {
                 if (PlatformFactory::isCloudstack($platform)) {
                     $value = CloudLocation::normalizeUrl($this->env->getPlatformConfigValue($platform . '.' . CloudstackPlatformModule::API_URL));
                 } else {
                     if ($platform == \SERVER_PLATFORMS::GCE) {
                         $value = '';
                     }
                 }
             }
         }
         $this->aUrl[$platform] = $value;
     }
     return $this->aUrl[$platform];
 }
Пример #17
0
 /**
  * @test
  */
 public function testWarmUp()
 {
     CloudLocation::warmUp();
 }