use of com.netflix.titus.api.connector.cloud.LoadBalancer in project titus-control-plane by Netflix.
the class AwsLoadBalancerConnectorTest method testGetIpTargets.
@Ignore("AWS dependencies")
@Test
public void testGetIpTargets() {
TestSubscriber testSubscriber = new TestSubscriber();
awsLoadBalancerConnector.getLoadBalancer(targetGroupWithTargets).subscribe(testSubscriber);
testSubscriber.awaitTerminalEvent();
testSubscriber.assertCompleted();
testSubscriber.assertNoErrors();
LoadBalancer loadBalancer = (LoadBalancer) testSubscriber.getOnNextEvents().get(0);
assertEquals(targetGroupWithTargets, loadBalancer.getId());
assertThat(loadBalancer.getRegisteredIps()).isNotEmpty();
}
use of com.netflix.titus.api.connector.cloud.LoadBalancer in project titus-control-plane by Netflix.
the class DefaultLoadBalancerReconciler method updatesForRemovedLoadBalancer.
private ReconciliationUpdates updatesForRemovedLoadBalancer(LoadBalancerWithKnownTargets loadBalancer, List<JobLoadBalancerState> associations) {
logger.warn("Load balancer is gone, ignoring its associations (marking them to be GCed later), and removing known state for its targets: {}", loadBalancer.current.getId());
for (JobLoadBalancerState association : associations) {
if (association.isStateAssociated()) {
logger.info("Marking association as orphan: {}", association.getJobLoadBalancer());
markedAsOrphan.add(association.getJobLoadBalancer());
}
}
// we will force deregistration of everything that was marked as REGISTERED to force its state to be updated
Map<Boolean, Set<LoadBalancerTarget>> registeredOrNot = loadBalancer.knownTargets.stream().collect(partitioningBy(target -> target.getState().equals(State.REGISTERED), mapping(LoadBalancerTargetState::getLoadBalancerTarget, Collectors.toSet())));
// all REGISTERED
Set<LoadBalancerTarget> toDeregister = registeredOrNot.get(true);
// all DEREGISTERED
Set<LoadBalancerTarget> toRemove = registeredOrNot.get(false);
return new ReconciliationUpdates(loadBalancer.current.getId(), Collections.emptySet(), toDeregister, toRemove);
}
use of com.netflix.titus.api.connector.cloud.LoadBalancer in project titus-control-plane by Netflix.
the class DefaultLoadBalancerServiceTest method multipleLoadBalancersPerJob.
@Test
public void multipleLoadBalancersPerJob() {
PublishSubject<JobManagerEvent<?>> taskEvents = PublishSubject.create();
String jobId = UUID.randomUUID().toString();
String firstLoadBalancerId = "lb-" + UUID.randomUUID().toString();
String secondLoadBalancerId = "lb-" + UUID.randomUUID().toString();
int numberOfStartedTasks = 5;
when(client.registerAll(any(), any())).thenReturn(Completable.complete());
when(client.deregisterAll(any(), any())).thenReturn(Completable.complete());
when(v3JobOperations.observeJobs()).thenReturn(taskEvents);
LoadBalancerTests.applyValidGetJobMock(v3JobOperations, jobId);
List<Task> tasks = LoadBalancerTests.buildTasksStarted(numberOfStartedTasks, jobId);
Collection<LoadBalancerTargetState> firstExpectedTargets = tasks.stream().map(task -> new LoadBalancerTargetState(new LoadBalancerTarget(firstLoadBalancerId, task.getId(), task.getTaskContext().get(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IP)), REGISTERED)).collect(Collectors.toList());
Collection<LoadBalancerTargetState> secondExpectedTargets = tasks.stream().map(task -> new LoadBalancerTargetState(new LoadBalancerTarget(secondLoadBalancerId, task.getId(), task.getTaskContext().get(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IP)), REGISTERED)).collect(Collectors.toList());
when(v3JobOperations.getTasks(jobId)).thenReturn(CollectionsExt.merge(tasks, LoadBalancerTests.buildTasks(2, jobId, TaskState.StartInitiated), LoadBalancerTests.buildTasks(2, jobId, TaskState.KillInitiated), LoadBalancerTests.buildTasks(3, jobId, TaskState.Finished), LoadBalancerTests.buildTasks(1, jobId, TaskState.Disconnected)));
LoadBalancerConfiguration configuration = LoadBalancerTests.mockConfiguration(MIN_TIME_IN_QUEUE_MS);
DefaultLoadBalancerService service = new DefaultLoadBalancerService(runtime, configuration, client, loadBalancerStore, loadBalancerJobOperations, reconciler, validator, testScheduler);
AssertableSubscriber<Batch<TargetStateBatchable, String>> testSubscriber = service.events().test();
// associate two load balancers to the same job
assertTrue(service.addLoadBalancer(jobId, firstLoadBalancerId).await(100, TimeUnit.MILLISECONDS));
assertTrue(service.addLoadBalancer(jobId, secondLoadBalancerId).await(100, TimeUnit.MILLISECONDS));
assertThat(service.getJobLoadBalancers(jobId).toList().toBlocking().single()).containsOnly(firstLoadBalancerId, secondLoadBalancerId);
verify(v3JobOperations, times(2)).getTasks(jobId);
testScheduler.advanceTimeBy(FLUSH_WAIT_TIME_MS, TimeUnit.MILLISECONDS);
// 1 batch per loadbalancer
testSubscriber.assertNoErrors().assertValueCount(2);
assertThat(loadBalancerStore.getLoadBalancerTargets(firstLoadBalancerId).collectList().block()).containsExactlyInAnyOrderElementsOf(firstExpectedTargets);
assertThat(loadBalancerStore.getLoadBalancerTargets(secondLoadBalancerId).collectList().block()).containsExactlyInAnyOrderElementsOf(secondExpectedTargets);
verify(client).registerAll(eq(firstLoadBalancerId), argThat(targets -> targets != null && targets.size() == numberOfStartedTasks));
verify(client).registerAll(eq(secondLoadBalancerId), argThat(targets -> targets != null && targets.size() == numberOfStartedTasks));
verify(client, never()).deregisterAll(eq(firstLoadBalancerId), any());
verify(client, never()).deregisterAll(eq(secondLoadBalancerId), any());
verifyReconcilerIgnore(firstLoadBalancerId, LoadBalancerTests.ipAddresses(tasks));
verifyReconcilerIgnore(secondLoadBalancerId, LoadBalancerTests.ipAddresses(tasks));
// now some more tasks are added to the job, check if both load balancers get updated
List<Task> newTasks = new ArrayList<>();
for (int i = 1; i <= numberOfStartedTasks; i++) {
String taskId = UUID.randomUUID().toString();
Task startingWithIp = ServiceJobTask.newBuilder().withJobId(jobId).withId(taskId).withStatus(TaskStatus.newBuilder().withState(TaskState.StartInitiated).build()).withTaskContext(CollectionsExt.asMap(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IP, String.format("%1$d.%1$d.%1$d.%1$d", i + numberOfStartedTasks))).build();
Task started = startingWithIp.toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Started).build()).build();
newTasks.add(started);
taskEvents.onNext(TaskUpdateEvent.taskChange(null, started, startingWithIp, callMetadata));
}
testScheduler.advanceTimeBy(FLUSH_WAIT_TIME_MS, TimeUnit.MILLISECONDS);
// 2 more batches (one per load balancer)
testSubscriber.assertNoErrors().assertValueCount(4);
verify(client, times(2)).registerAll(eq(firstLoadBalancerId), argThat(targets -> targets != null && targets.size() == numberOfStartedTasks));
verify(client, times(2)).registerAll(eq(secondLoadBalancerId), argThat(targets -> targets != null && targets.size() == numberOfStartedTasks));
verify(client, never()).deregisterAll(eq(firstLoadBalancerId), any());
verify(client, never()).deregisterAll(eq(secondLoadBalancerId), any());
verifyReconcilerIgnore(firstLoadBalancerId, LoadBalancerTests.ipAddresses(newTasks));
verifyReconcilerIgnore(secondLoadBalancerId, LoadBalancerTests.ipAddresses(newTasks));
assertThat(loadBalancerStore.getLoadBalancerTargets(firstLoadBalancerId).collectList().block()).hasSize(firstExpectedTargets.size() + numberOfStartedTasks);
assertThat(loadBalancerStore.getLoadBalancerTargets(secondLoadBalancerId).collectList().block()).hasSize(secondExpectedTargets.size() + numberOfStartedTasks);
}
use of com.netflix.titus.api.connector.cloud.LoadBalancer in project titus-control-plane by Netflix.
the class DefaultLoadBalancerReconcilerTest method orphanLoadBalancerAssociationsAreSetAsDissociatedAndRemoved.
@Test
public void orphanLoadBalancerAssociationsAreSetAsDissociatedAndRemoved() {
List<Task> tasks = LoadBalancerTests.buildTasksStarted(5, jobId);
JobLoadBalancer jobLoadBalancer = new JobLoadBalancer(jobId, loadBalancerId);
when(v3JobOperations.getTasks(jobId)).thenReturn(tasks);
reset(connector);
OngoingStubbing<Single<LoadBalancer>> ongoingStubbing = when(connector.getLoadBalancer(loadBalancerId)).thenReturn(Single.just(new LoadBalancer(loadBalancerId, LoadBalancer.State.ACTIVE, CollectionsExt.asSet("1.1.1.1", "2.2.2.2", "3.3.3.3", "4.4.4.4", "5.5.5.5"))));
assertThat(store.addOrUpdateLoadBalancer(jobLoadBalancer, State.ASSOCIATED).await(5, TimeUnit.SECONDS)).isTrue();
// all targets were previously registered by us
store.addOrUpdateTargets(tasks.stream().map(task -> new LoadBalancerTargetState(new LoadBalancerTarget(loadBalancerId, task.getId(), task.getTaskContext().get(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IP)), LoadBalancerTarget.State.REGISTERED)).collect(Collectors.toList())).block();
testScheduler.triggerActions();
subscriber.assertNotCompleted().assertNoValues();
// load balancer was removed outside of Titus
ongoingStubbing.thenReturn(Single.just(new LoadBalancer(loadBalancerId, LoadBalancer.State.REMOVED, Collections.emptySet())));
// Let a few iterations run so all phases can be executed:
// 1. mark as orphan
// 2. update targets as DEREGISTERED
awaitReconciliationRuns(2);
subscriber.awaitValueCount(5, TEST_TIMEOUT_MS / 2, TimeUnit.MILLISECONDS).assertNoErrors();
assertThat(subscriber.getOnNextEvents()).allMatch(update -> update.getState().equals(LoadBalancerTarget.State.DEREGISTERED));
// simulate all targets got DEREGISTERED
List<LoadBalancerTargetState> currentTargets = store.getLoadBalancerTargets(loadBalancerId).collectList().block();
assertThat(currentTargets).isNotNull();
store.addOrUpdateTargets(currentTargets.stream().map(targetState -> targetState.getLoadBalancerTarget().withState(LoadBalancerTarget.State.DEREGISTERED)).collect(Collectors.toList())).block();
// 3. update orphan as Dissociated
awaitReconciliationRuns(1);
assertThat(store.getAssociations()).containsOnly(new JobLoadBalancerState(jobLoadBalancer, State.DISSOCIATED));
// 4. sweep all targets
// 5. sweep all Dissociated
awaitReconciliationRuns(2);
assertThat(store.getLoadBalancerTargets(loadBalancerId).collectList().block()).isEmpty();
assertThat(store.getAssociations()).isEmpty();
assertThat(store.getAssociatedLoadBalancersSetForJob(jobId)).isEmpty();
}
use of com.netflix.titus.api.connector.cloud.LoadBalancer in project titus-control-plane by Netflix.
the class DefaultLoadBalancerReconcilerTest method dissociatedJobsAreNotRemovedUntilAllTargetsAreDeregisteredAndRemoved.
@Test
public void dissociatedJobsAreNotRemovedUntilAllTargetsAreDeregisteredAndRemoved() throws InterruptedException {
JobLoadBalancer jobLoadBalancer = new JobLoadBalancer(jobId, loadBalancerId);
when(v3JobOperations.getTasks(jobId)).thenThrow(JobManagerException.jobNotFound(jobId));
when(v3JobOperations.getJob(jobId)).thenReturn(Optional.empty());
reset(connector);
when(connector.getLoadBalancer(loadBalancerId)).thenReturn(Single.just(new LoadBalancer(loadBalancerId, LoadBalancer.State.ACTIVE, Collections.singleton("1.2.3.4"))));
store.addOrUpdateTargets(new LoadBalancerTargetState(new LoadBalancerTarget(loadBalancerId, "some-task", "1.2.3.4"), LoadBalancerTarget.State.DEREGISTERED)).block();
assertThat(store.addOrUpdateLoadBalancer(jobLoadBalancer, State.DISSOCIATED).await(5, TimeUnit.SECONDS)).isTrue();
testScheduler.triggerActions();
subscriber.assertNotCompleted().assertNoValues();
// 1. deregister
awaitReconciliationRuns(1);
subscriber.assertNoTerminalEvent().assertValueCount(1);
assertThat(store.getAssociations()).isNotEmpty().hasSize(1);
when(connector.getLoadBalancer(loadBalancerId)).thenReturn(Single.just(new LoadBalancer(loadBalancerId, LoadBalancer.State.ACTIVE, Collections.emptySet())));
// Let a few iterations run so the remaining phases have a chance to complete:
// 2. clean up target state
// 3. clean up association
awaitReconciliationRuns(3);
assertThat(store.getAssociations()).isEmpty();
assertThat(store.getLoadBalancerTargets(loadBalancerId).collectList().block()).isEmpty();
}
Aggregations