/**
* Gets an EntityManager
*
* @return \Scalr\Service\Aws\EntityManager
*/
public function getEntityManager()
{
return $this->elb->getEntityManager();
}
/**
* @test
* @depends testCreateLoadBalancers
*/
public function testFunctionalLoadBalancerComplex()
{
$this->skipIfEc2PlatformDisabled();
$aws = $this->elb->getAws();
$aws->ec2->enableEntityManager();
$aws->getEntityManager()->detachAll();
$nameTag = new ResourceTagSetData('Name', self::getTestName('elb'));
$loadBalancerName = self::getTestName(self::LB_NAME_FUNC_TEST);
$loadBalancer = $this->createLoadBalancerGently($loadBalancerName, array(array('loadBalancerPort' => 80, 'instancePort' => 1024, 'protocol' => 'HTTP', 'sslCertificateId' => null)), $aws->ec2->availabilityZone->describe(AwsTestCase::AVAILABILITY_ZONE_A));
$this->assertInstanceOf(self::CLASS_LOAD_BALANCER_DESCRIPTION_DATA, $loadBalancer, 'Could not create load balancer');
//We should clean up the instances that were created by this test before but had not been terminated.
$reservationsList = $aws->ec2->instance->describe(null, new InstanceFilterData(InstanceFilterNameType::tag('Name'), self::getTestName('elb')));
$this->assertInstanceOf($this->getEc2ClassName('DataType\\ReservationList'), $reservationsList);
foreach ($reservationsList as $r) {
/* @var $i \Scalr\Service\Aws\Ec2\DataType\InstanceData */
foreach ($r->instancesSet as $i) {
$ds = $i->describeStatus();
if ($ds->instanceState->name == InstanceStateData::NAME_RUNNING) {
$i->terminate();
}
}
}
unset($reservationsList);
try {
$listener1 = new ListenerData(1025, 1025, 'HTTP');
$ret = $loadBalancer->createListeners(array($listener1, new ListenerData(1026, 1026, 'HTTP')));
$this->assertTrue($ret, 'Could not create listeners');
$this->assertEquals(spl_object_hash($listener1), spl_object_hash($loadBalancer->listenerDescriptions->get(1)->listener));
$a = array();
foreach ($loadBalancer->listenerDescriptions as $listenerDescription) {
if (!isset($a[(string) $listenerDescription->listener])) {
$a[(string) $listenerDescription->listener] = '';
}
$a[(string) $listenerDescription->listener] .= (string) $listenerDescription->listener;
}
$mapping = array();
$newListenerDescriptions = $this->elb->loadBalancer->describe($loadBalancerName)->get(0)->listenerDescriptions;
/* @var $listenerDescription ListenerDescriptionData */
foreach ($newListenerDescriptions as $k => $listenerDescription) {
$mapping[$listenerDescription->listener->loadBalancerPort] = $k;
$this->assertArrayHasKey((string) $listenerDescription->listener, $a, 'LoadBalancerDescription->listener object has not been updated properly.');
}
$ret = $loadBalancer->createListeners();
$this->assertTrue($ret, 'Cannot create listeners from loadBalancer instance itself.');
try {
$ret = $listener1->setPolicies('policy-of-listener-1');
$this->assertTrue(false, 'Exception must be thrown here.');
} catch (ClientException $e) {
$this->assertEquals(ErrorData::ERR_POLICY_NOT_FOUND, $e->getErrorData()->getCode());
}
$ret = $loadBalancer->listenerDescriptions->get($mapping[1026])->delete();
$this->assertTrue($ret, 'Cannot remove listener');
foreach ($loadBalancer->listenerDescriptions as $listenerDescription) {
$this->assertNotEquals(1026, $listenerDescription->listener->loadBalancerPort);
}
$ret = $this->elb->loadBalancer->enableAvailabilityZones($loadBalancerName, AwsTestCase::AVAILABILITY_ZONE_D);
$this->assertContains(AwsTestCase::AVAILABILITY_ZONE_D, $ret);
$this->assertEquals($ret, $loadBalancer->availabilityZones);
$ret = $loadBalancer->disableAvailabilityZones(AwsTestCase::AVAILABILITY_ZONE_A);
$this->assertNotContains(AwsTestCase::AVAILABILITY_ZONE_A, $ret);
$this->assertEquals($ret, $loadBalancer->availabilityZones);
//It depends from the instance which should be created before this test.
//RunInstance test
$request = new RunInstancesRequestData('ami-82fa58eb', 1, 1);
$request->instanceType = 'm1.small';
$placement = new PlacementResponseData();
$placement->availabilityZone = AwsTestCase::AVAILABILITY_ZONE_A;
$request->setPlacement($placement);
$rd = $aws->ec2->instance->run($request);
$this->assertInstanceOf($this->getEc2ClassName('DataType\\ReservationData'), $rd);
/* @var $ind \Scalr\Service\Aws\Ec2\DataType\InstanceData */
$ind = $rd->instancesSet[0];
unset($request);
//Sometimes it can't find recently created instance.
sleep(8);
//Creates the tag for the instance
$res = $ind->createTags(array($nameTag, array('key' => 'Extratag', 'value' => 'extravalue')));
$this->assertTrue($res);
//Instance state must be in the running state
$maxTimeout = 300;
$interval = 2;
while ($ind->instanceState->name !== InstanceStateData::NAME_RUNNING && $maxTimeout > 0) {
sleep($interval);
$maxTimeout -= $interval;
$interval *= 2;
$ind = $ind->refresh();
}
$this->assertEquals(InstanceStateData::NAME_RUNNING, $ind->instanceState->name);
$instanceList = $loadBalancer->registerInstances($ind->instanceId);
$this->assertContains($ind->instanceId, $instanceList->getQueryArray());
$this->assertEquals($instanceList, $this->elb->loadBalancer->get($loadBalancerName)->instances);
$this->assertEquals($instanceList, $loadBalancer->instances);
$instanceStateList = $loadBalancer->describeInstanceHealth();
$this->assertInstanceOf(self::CLASS_INSTANCE_STATE_LIST, $instanceStateList);
$this->assertContains($ind->instanceId, $instanceStateList->getQueryArray());
/* @var $instanceData InstanceData */
foreach ($loadBalancer->instances as $instanceData) {
$h = $instanceData->describeHealth();
$this->assertInstanceOf(self::CLASS_INSTANCE_STATE_LIST, $h);
$this->assertEquals(1, count($h));
$this->assertContains($instanceData->instanceId, $h->getQueryArray());
}
$dInstanceList = $loadBalancer->deregisterInstances($ind->instanceId);
$this->assertEmpty($dInstanceList->getQueryArray());
$this->assertEmpty($loadBalancer->instances->getQueryArray());
$ind->terminate();
$loadBalancer->healthCheck->setInterval(29)->setTimeout(4)->setHealthyThreshold(9);
$ret = $loadBalancer->healthCheck->configure();
$this->assertEquals(spl_object_hash($ret), spl_object_hash($loadBalancer->healthCheck));
$this->assertEquals($loadBalancer->healthCheck->interval, 29);
$this->assertEquals($loadBalancer->healthCheck->timeout, 4);
$this->assertEquals($loadBalancer->healthCheck->healthyThreshold, 9);
try {
foreach ($loadBalancer->listenerDescriptions as $listenerDescription) {
if ($listenerDescription->listener->loadBalancerPort == 80) {
$listenerDescription->updateSslCertificate('invalid-sertificate-id-test');
}
}
$this->assertTrue(false, 'ClientException must be thrown here.');
} catch (ClientException $e) {
$this->assertEquals(ErrorData::ERR_INVALID_CONFIGURATION_REQUEST, $e->getErrorData()->getCode());
}
$ret = $loadBalancer->createAppCookieStickinessPolicy('test-policy-1', 'test_cookie_1');
$this->assertTrue($ret);
$this->assertInstanceOf(self::CLASS_APP_COOKIE_STICKINESS_POLICY_LIST, $loadBalancer->policies->appCookieStickinessPolicies);
$this->assertEquals(1, count($loadBalancer->policies->appCookieStickinessPolicies));
$this->assertEquals('test-policy-1', $loadBalancer->policies->appCookieStickinessPolicies->get(0)->policyName);
$this->assertEquals('test_cookie_1', $loadBalancer->policies->appCookieStickinessPolicies->get(0)->cookieName);
$ret = $loadBalancer->createLbCookieStickinessPolicy('test-lb-policy-1', 1111111111);
$this->assertTrue($ret);
$this->assertInstanceOf(self::CLASS_LB_COOKIE_STICKINESS_POLICY_LIST, $loadBalancer->policies->lbCookieStickinessPolicies);
$this->assertEquals(1, count($loadBalancer->policies->lbCookieStickinessPolicies));
$this->assertEquals('test-lb-policy-1', $loadBalancer->policies->lbCookieStickinessPolicies->get(0)->policyName);
$this->assertEquals(1111111111, $loadBalancer->policies->lbCookieStickinessPolicies->get(0)->cookieExpirationPeriod);
$policy = new AppCookieStickinessPolicyData('app-policy-2');
$loadBalancer->policies->appCookieStickinessPolicies->append($policy);
$ret = $policy->create('app_cookie_2');
$this->assertTrue($ret);
$this->assertEquals(spl_object_hash($policy), spl_object_hash($loadBalancer->policies->appCookieStickinessPolicies->get(1)));
unset($policy);
$ret = $loadBalancer->policies->appCookieStickinessPolicies->get(1)->delete();
$this->assertTrue($ret);
$this->assertEquals(1, count($loadBalancer->policies->appCookieStickinessPolicies));
$this->assertNotContains('app-policy-2', $loadBalancer->policies->appCookieStickinessPolicies->getQueryArray());
$ret = $loadBalancer->policies->lbCookieStickinessPolicies->get(0)->delete();
$this->assertTrue($ret);
$this->assertEquals(0, count($loadBalancer->policies->lbCookieStickinessPolicies));
} catch (\Exception $e) {
$loadBalancer->delete();
throw $e;
}
$ret = $loadBalancer->delete();
$this->assertTrue($ret, 'Could not delete loadbalancer');
unset($loadBalancer);
}
