@Override public void expect(ClusterState state, SchedulerDriver mockDriver) throws AssertionError { Set<Protos.ExecutorInfo> executors = Arrays.asList(taskNames).stream() .map(name -> state.getLastLaunchedTask(name).getExecutor()) .collect(Collectors.toSet()); Assert.assertEquals(String.format( "Expected tasks to share a single matching executor, but had: %s", executors.stream().map(e -> TextFormat.shortDebugString(e)).collect(Collectors.toList())), 1, executors.size()); }
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) throws AssertionError { Plan plan = state.getPlans().stream() .filter(p -> p.getName().equals(Constants.DEPLOY_PLAN_NAME)) .findFirst().get(); Assert.assertNotEquals(Status.ERROR, plan.getStatus()); }
public static ClusterState create(ServiceSpec serviceSpec, AbstractScheduler scheduler) { return new ClusterState(serviceSpec, scheduler); }
Set<String> lastCycleOfferIds = state.getLastOfferCycle().stream() .map(o -> o.getId().getValue()) .collect(Collectors.toSet()); LaunchedTask task = state.getLastLaunchedTask(taskName); expectedResourceIds.addAll(ResourceUtils.getResourceIds(task.getTask().getResourcesList())); expectedResourceIds.addAll(ResourceUtils.getResourceIds(task.getExecutor().getResourcesList()));
private Protos.Offer getOfferForPod(ClusterState state) { Optional<PodSpec> matchingSpec = state.getServiceSpec().getPods().stream() .filter(podSpec -> podType.equals(podSpec.getType())) .findAny(); throw new IllegalArgumentException(String.format("No PodSpec found with type=%s: types=%s", podType, state.getServiceSpec().getPods().stream() .map(podSpec -> podSpec.getType()) .collect(Collectors.toList()))); if (podToReuse.isPresent()) { List<AcceptEntry> acceptCalls = state.getAcceptCalls(podToReuse.get()); AcceptEntry lastLaunch = acceptCalls.get(acceptCalls.size() - 1);
Set<String> lastCycleOfferIds = state.getLastOfferCycle().stream() .map(o -> o.getId().getValue()) .collect(Collectors.toSet()); state.addAcceptCall( new AcceptEntry(executorsById.values(), launchedTaskInfos, reservedResources));
private static Map<String, Status> getExpectedStepStatuses(ClusterState state, StepCount stepCount) { Map<String, Status> expectedSteps = new TreeMap<>(); expectedSteps.put(String.format("kill-%s-server", stepCount.phaseName), stepCount.statusOfStepIndex(expectedSteps.size())); List<AcceptEntry> acceptCalls = state.getAcceptCalls(stepCount.phaseName); // Get information based on the LAST operation. This wouldn't work if the last operation didn't reserve // anything, as would occur when a task is restarted, but this is close enough for our purposes. AcceptEntry acceptCall = acceptCalls.get(acceptCalls.size() - 1); Collection<String> resourceIds = new ArrayList<>(); resourceIds.addAll(ResourceUtils.getResourceIds(ResourceUtils.getAllResources(acceptCall.getTasks()))); resourceIds.addAll(acceptCall.getExecutors().stream() .map(e -> ResourceUtils.getResourceIds(e.getResourcesList())) .flatMap(Collection::stream) .collect(Collectors.toList())); for (String resourceId : resourceIds) { expectedSteps.put(String.format("unreserve-%s", resourceId), stepCount.statusOfStepIndex(expectedSteps.size())); } expectedSteps.put(String.format("erase-%s-server", stepCount.phaseName), stepCount.statusOfStepIndex(expectedSteps.size())); return expectedSteps; } }
if (oldClusterState == null) { clusterState = ClusterState.create(serviceSpec, abstractScheduler); } else { clusterState = ClusterState.withUpdatedConfig(oldClusterState, serviceSpec, abstractScheduler);
public static ClusterState withUpdatedConfig( ClusterState clusterState, ServiceSpec serviceSpec, AbstractScheduler scheduler) { ClusterState updatedClusterState = create(serviceSpec, scheduler); updatedClusterState.sentOfferSets.addAll(clusterState.sentOfferSets); updatedClusterState.acceptCalls.addAll(clusterState.acceptCalls); return updatedClusterState; }
@Override public void send(ClusterState state, SchedulerDriver mockDriver, Scheduler scheduler) { PodResource r = (PodResource) state.getHTTPEndpoints().stream() .filter(resource -> resource instanceof PodResource) .findAny().get(); r.replace(podName); }
@Override public void send(ClusterState state, SchedulerDriver mockDriver, Scheduler scheduler) { List<Protos.Offer> offers = new ArrayList<>(); for (int i = 0; i < count; ++i) { offers.add(getOfferForPod(state)); } state.addSentOffers(offers); scheduler.resourceOffers(mockDriver, offers); }
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) { ArgumentCaptor<Protos.OfferID> offerIdCaptor = ArgumentCaptor.forClass(Protos.OfferID.class); Set<String> lastCycleOfferIds = state.getLastOfferCycle().stream() .map(o -> o.getId().getValue()) .collect(Collectors.toSet()); Mockito.verify(mockDriver, Mockito.atLeast(lastCycleOfferIds.size())).declineOffer(offerIdCaptor.capture(), any()); // Check that the offer ids from the last cycle were all declined: Set<String> declinedOfferIds = offerIdCaptor.getAllValues().stream() .map(o -> o.getValue()) .collect(Collectors.toSet()); Assert.assertTrue( String.format("Expected all offers from last offer cycle to be declined: %s, got: %s", lastCycleOfferIds, declinedOfferIds), declinedOfferIds.containsAll(lastCycleOfferIds)); }
task.getName(), new LaunchedTask(findMatchingExecutor(task, acceptCall.getExecutors()), task));
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) { Collection<Plan> plans = state.getPlans(); for (Plan plan : plans) { if (!plan.isComplete()) { Assert.fail(String.format( "%s plan is not complete. Plans: %s", plan.getName(), plans.stream().map(p -> p.toString()).collect(Collectors.toList()))); } } }
/** * Returns the last task id for a task of the specified name. * * @param taskName the task name to be found * @return the task id * @throws IllegalStateException if no such task was found */ public Protos.TaskID getTaskId(String taskName) { return getLastLaunchedTask(taskName).getTask().getTaskId(); } }
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) throws AssertionError { Plan plan = state.getPlans().stream() .filter(p -> p.getName().equals(planName)) .findFirst().get(); Assert.assertEquals(plan.toString(), status, plan.getStatus()); }
private static void checkNamespace( ServiceTestResult result, String sanitizedServiceName, String resourceNamespace, String persisterPrefix) throws Exception { Collection<String> taskNames = Arrays.asList("hello-0-server", "world-0-server", "world-1-server"); // Persister: everything under a specified prefix (or no prefix). Assert.assertEquals(new TreeSet<>(taskNames), result.getPersister().getChildren(persisterPrefix + "/Tasks")); Assert.assertEquals(1, result.getPersister().getChildren(persisterPrefix + "/Configurations").size()); for (String taskName : taskNames) { LaunchedTask launchedTask = result.getClusterState().getLastLaunchedTask(taskName); // Each task should have a taskId and executorId containing the service name, regardless of namespacing: Assert.assertEquals(sanitizedServiceName, CommonIdUtils.toSanitizedServiceName(launchedTask.getExecutor().getExecutorId()).get()); Assert.assertEquals(sanitizedServiceName, CommonIdUtils.toSanitizedServiceName(launchedTask.getTask().getTaskId()).get()); if (resourceNamespace != null) { // All task+executor resources should have a 'namespace' label for (Protos.Resource resource : ResourceUtils.getAllResources(launchedTask.getTask())) { Assert.assertEquals(resourceNamespace, ResourceUtils.getNamespace(resource).get()); } } else { // All task+executor resources should NOT have a 'namespace' label for (Protos.Resource resource : ResourceUtils.getAllResources(launchedTask.getTask())) { Assert.assertFalse(ResourceUtils.getNamespace(resource).isPresent()); } } } }
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) { Optional<Plan> plan = state.getPlans().stream() .filter(p -> p.getName().equals(planName)) .findAny(); Assert.assertTrue(String.format("Missing plan '%s', plans were: %s", planName, state.getPlans().stream().map(p -> p.getName()).collect(Collectors.toList())), plan.isPresent()); int stepCount = 0; for (Phase phase : plan.get().getChildren()) { stepCount += phase.getChildren().size(); } Assert.assertEquals(plan.get().toString(), expectedStepCount, stepCount); }
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) { Optional<Plan> plan = state.getPlans().stream() .filter(p -> p.getName().equals(planName)) .findAny(); Assert.assertTrue(String.format("Missing plan '%s', plans were: %s", planName, state.getPlans().stream().map(p -> p.getName()).collect(Collectors.toList())), plan.isPresent()); Optional<Phase> phase = plan.get().getChildren().stream() .filter(p -> p.getName().equals(phaseName)) .findAny(); Assert.assertTrue(String.format("Missing phase '%s' in plan '%s':%n%s", phaseName, planName, plan.get().toString()), phase.isPresent()); Optional<Step> step = phase.get().getChildren().stream() .filter(s -> s.getName().equals(stepName)) .findAny(); Assert.assertTrue(String.format("Missing step '%s' in plan '%s'/phase '%s':%n%s", stepName, planName, phaseName, plan.get().toString()), step.isPresent()); Assert.assertEquals(plan.get().toString(), expectedStatus, step.get().getStatus()); }
@Override public void expect(ClusterState state, SchedulerDriver mockDriver) { List<String> deployErrors = state.getPlans().stream() .filter(p -> p.isDeployPlan()) .findFirst() .get().getErrors(); Assert.assertTrue(deployErrors.get(0).contains("PodSpec named 'hello' has 0 tasks, expected >=1 tasks")); }