for (Protos.Resource resource : executorResources) { Optional<ResourceLabels> matchingResource; if (resource.getName().equals(Constants.DISK_RESOURCE_TYPE) && resource.hasDisk()) { matchingResource = ResourceMapperUtils.findMatchingDiskSpec( resource, } else { logger.warn("Failed to find match for resource: {}", TextFormat.shortDebugString(resource)); if (resource.hasDisk()) { orphanedResources.add(resource);
public static List<String> getVolumePaths(final List<Resource> resources) { return resources.stream().filter(resource -> isDisk(resource) && resource.hasDisk() && resource.getDisk().hasVolume()).map( resource -> resource.getDisk() .getVolume().getContainerPath()) .collect(Collectors.toList()); }
public static TaskInfo copyVolumes( final TaskInfo source, final TaskInfo target) { List<Resource> sourceDisks = source.getResourcesList().stream() .filter(resource -> isDisk(resource) && resource.hasDisk()) .collect(Collectors.toList()); List<Resource> minusDisks = target.getResourcesList().stream() .filter(resource -> !isDisk(resource)) .collect(Collectors.toList()); return TaskInfo.newBuilder(target) .clearResources() .addAllResources(minusDisks) .addAllResources(sourceDisks) .build(); }
Assert.assertEquals(TestConstants.PRINCIPAL, reservation.getPrincipal()); Assert.assertEquals(36, getResourceId(reserveResource).length()); Assert.assertTrue(reserveResource.hasDisk()); Assert.assertFalse(reserveResource.getDisk().hasPersistence()); Assert.assertFalse(reserveResource.getDisk().hasVolume());
Assert.assertEquals(TestConstants.PRINCIPAL, reservation.getPrincipal()); Assert.assertEquals(36, getResourceId(reserveResource).length()); Assert.assertFalse(reserveResource.hasDisk()); Assert.assertEquals(TestConstants.PRINCIPAL, reservation.getPrincipal()); Assert.assertEquals(36, getResourceId(reserveResource).length()); Assert.assertFalse(reserveResource.hasDisk());
/** * Converts the provided {@code OfferResources} instances into an ordered list of destroy and/or * unreserve operations. */ private static Collection<OfferRecommendation> toCleanupRecommendations( Collection<OfferResources> offerResourcesList) { // ORDERING IS IMPORTANT: // The resource lifecycle is RESERVE -> CREATE -> DESTROY -> UNRESERVE // Therefore we *must* put any DESTROY calls before any UNRESERVE calls List<OfferRecommendation> destroyRecommendations = new ArrayList<>(); List<OfferRecommendation> unreserveRecommendations = new ArrayList<>(); for (OfferResources offerResources : offerResourcesList) { for (Protos.Resource resource : offerResources.getResources()) { if (resource.hasDisk() && resource.getDisk().hasPersistence()) { // Permanent volume to be DESTROYed (and also UNRESERVEd) destroyRecommendations.add( new DestroyOfferRecommendation(offerResources.getOffer(), resource)); } // Reserved resource OR permanent volume to be UNRESERVEd unreserveRecommendations.add( new UnreserveOfferRecommendation(offerResources.getOffer(), resource)); } } // Order the recommendations as DESTROYs followed by UNRESERVEs, as mentioned above: List<OfferRecommendation> allRecommendations = new ArrayList<>(); allRecommendations.addAll(destroyRecommendations); allRecommendations.addAll(unreserveRecommendations); return allRecommendations; }
@Test public void testReserveLaunchScalar() throws Exception { PodInstanceRequirement podInstanceRequirement = PodInstanceRequirementTestUtils.getCpuRequirement(1.0); Protos.Resource offeredResource = ResourceTestUtils.getUnreservedCpus(2.0); List<OfferRecommendation> recommendations = evaluator.evaluate( podInstanceRequirement, Arrays.asList(OfferTestUtils.getCompleteOffer(offeredResource))); Assert.assertEquals(6, recommendations.size()); // Validate RESERVE Operation Protos.Offer.Operation reserveOperation = recommendations.get(3).getOperation().get(); Protos.Resource reserveResource = reserveOperation.getReserve().getResources(0); Protos.Resource.ReservationInfo reservation = ResourceUtils.getReservation(reserveResource).get(); Assert.assertEquals(Protos.Offer.Operation.Type.RESERVE, reserveOperation.getType()); Assert.assertEquals(1.0, reserveResource.getScalar().getValue(), 0.0); validateRole(reserveResource); Assert.assertEquals(TestConstants.ROLE, ResourceUtils.getRole(reserveResource)); Assert.assertEquals(TestConstants.PRINCIPAL, reservation.getPrincipal()); Assert.assertEquals(36, getResourceId(reserveResource).length()); Assert.assertFalse(reserveResource.hasDisk()); // Validate LAUNCH Operation Protos.Offer.Operation launchOperation = recommendations.get(4).getOperation().get(); Protos.Resource launchResource = launchOperation.getLaunchGroup().getTaskGroup().getTasks(0).getResources(0); Assert.assertEquals(Protos.Offer.Operation.Type.LAUNCH_GROUP, launchOperation.getType()); Assert.assertEquals(getResourceId(reserveResource), getResourceId(launchResource)); Protos.ExecutorID executorId = launchOperation.getLaunchGroup().getExecutor().getExecutorId(); Assert.assertEquals(TestConstants.POD_TYPE, CommonIdUtils.toExecutorName(executorId)); }
public UnreserveOfferRecommendation(Offer offer, Resource resource) { this.offer = offer; Resource.Builder resourceBuilder = resource.toBuilder(); Resource resourceR; // If non-root disk resource, we want to clear ALL fields except for the field indicating the disk source. if (resource.hasDisk() && resource.getDisk().hasSource()) { resourceR = resourceBuilder .setDisk(Resource.DiskInfo.newBuilder().setSource(resource.getDisk().getSource())) .build(); } else { resourceR = resourceBuilder.clearDisk().clearRevocable().build(); } this.operation = Operation.newBuilder() .setType(Operation.Type.UNRESERVE) .setUnreserve( Operation.Unreserve.newBuilder().addAllResources(Collections.singletonList(resourceR)) ) .build(); this.resource = resourceR; }
@Test public void testUnreserveMountDisk() { Protos.Resource resource = ResourceTestUtils.getReservedMountVolume(1, Optional.empty()); Protos.Offer offer = OfferTestUtils.getOffer(resource); UnreserveOfferRecommendation unreserveOfferRecommendation = new UnreserveOfferRecommendation(offer, resource); Protos.Offer.Operation operation = unreserveOfferRecommendation.getOperation().get(); Assert.assertEquals(1, operation.getUnreserve().getResourcesCount()); Protos.Resource opResource = operation.getUnreserve().getResources(0); Assert.assertTrue(opResource.hasDisk()); Assert.assertTrue(opResource.getDisk().hasSource()); Assert.assertFalse(opResource.hasRevocable()); resource = resource.toBuilder().setDisk( Protos.Resource.DiskInfo.newBuilder() .setSource(resource.getDisk().getSource())) .build(); Assert.assertEquals(resource, opResource); } }
public static ResourceBuilder fromExistingResource(Protos.Resource resource) { if (!resource.hasDisk()) { return fromSpec( getResourceSpec(resource), ResourceUtils.getResourceId(resource), ResourceUtils.getNamespace(resource)); } else { return fromSpec( getVolumeSpec(resource), ResourceUtils.getResourceId(resource), ResourceUtils.getNamespace(resource), ResourceUtils.getPersistenceId(resource), ResourceUtils.getProviderId(resource), ResourceUtils.getDiskSource(resource)); } }
public static List<Resource> replaceDisks(final String path, final List<Resource> resources) { return resources.stream() .map(resource -> { if (isDisk(resource) && resource.hasDisk()) { return Resource.newBuilder(resource) .setDisk(createDiskInfo(path)) .build(); } else { return resource; } }).collect(Collectors.toList()); }
@Test public void testUnreserveRootDisk() { Protos.Resource resource = ResourceTestUtils.getReservedRootVolume(1); Protos.Offer offer = OfferTestUtils.getOffer(resource); UnreserveOfferRecommendation unreserveOfferRecommendation = new UnreserveOfferRecommendation(offer, resource); Protos.Offer.Operation operation = unreserveOfferRecommendation.getOperation().get(); Assert.assertEquals(1, operation.getUnreserve().getResourcesCount()); Protos.Resource opResource = operation.getUnreserve().getResources(0); Assert.assertFalse(opResource.hasDisk()); Assert.assertFalse(opResource.hasRevocable()); resource = resource.toBuilder().clearDisk().clearRevocable().build(); Assert.assertEquals(resource, opResource); }
public boolean isAtomic() { return resource.hasDisk() && resource.getDisk().hasSource() && resource.getDisk().getSource().getType().equals(Source.Type.MOUNT); }
private static void validateDisk(Protos.Resource resource, Optional<String> resourceId, Optional<String> namespace) { Assert.assertTrue(resource.hasDisk()); Protos.Resource.DiskInfo diskInfo = resource.getDisk(); Assert.assertTrue(diskInfo.hasPersistence()); Protos.Resource.DiskInfo.Persistence persistence = diskInfo.getPersistence(); Assert.assertEquals(36, persistence.getId().length()); Assert.assertEquals(TestConstants.PRINCIPAL, persistence.getPrincipal()); Assert.assertTrue(diskInfo.hasVolume()); Protos.Volume volume = diskInfo.getVolume(); Assert.assertEquals(TestConstants.CONTAINER_PATH, volume.getContainerPath()); Assert.assertEquals(Protos.Volume.Mode.RW, volume.getMode()); validateScalarResource(resource, resourceId, namespace); }
public static Optional<String> getPersistenceId(Protos.Resource resource) { if (resource.hasDisk() && resource.getDisk().hasPersistence()) { return Optional.of(resource.getDisk().getPersistence().getId()); } return Optional.empty(); }
private static boolean isMountVolume(Protos.Resource resource) { return resource.hasDisk() && resource.getDisk().hasSource() && resource.getDisk().getSource().hasType() && resource.getDisk().getSource().getType() .equals(Protos.Resource.DiskInfo.Source.Type.MOUNT); } }