Java Protos.Offer方法代码示例

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private List<Protos.TaskInfo> getTaskInfoList(final Collection<String> integrityViolationJobs, final VMAssignmentResult vmAssignmentResult, final String hostname, final Protos.Offer offer) {
    List<Protos.TaskInfo> result = new ArrayList<>(vmAssignmentResult.getTasksAssigned().size());
    for (TaskAssignmentResult each: vmAssignmentResult.getTasksAssigned()) {
        TaskContext taskContext = TaskContext.from(each.getTaskId());
        String jobName = taskContext.getMetaInfo().getJobName();
        if (!integrityViolationJobs.contains(jobName) && !facadeService.isRunning(taskContext) && !facadeService.isJobDisabled(jobName)) {
            Protos.TaskInfo taskInfo = getTaskInfo(offer, each);
            if (null != taskInfo) {
                result.add(taskInfo);
                facadeService.addMapping(taskInfo.getTaskId().getValue(), hostname);
                taskScheduler.getTaskAssigner().call(each.getRequest(), hostname);
            }
        }
    }
    return result;
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private Protos.TaskInfo buildCustomizedExecutorTaskInfo(final TaskContext taskContext, final CloudAppConfiguration appConfig, final CloudJobConfiguration jobConfig, 
                                                        final ShardingContexts shardingContexts, final Protos.Offer offer, final Protos.CommandInfo command) {
    Protos.TaskInfo.Builder result = Protos.TaskInfo.newBuilder().setTaskId(Protos.TaskID.newBuilder().setValue(taskContext.getId()).build())
            .setName(taskContext.getTaskName()).setSlaveId(offer.getSlaveId())
            .addResources(buildResource("cpus", jobConfig.getCpuCount(), offer.getResourcesList()))
            .addResources(buildResource("mem", jobConfig.getMemoryMB(), offer.getResourcesList()))
            .setData(ByteString.copyFrom(new TaskInfoData(shardingContexts, jobConfig).serialize()));
    Protos.ExecutorInfo.Builder executorBuilder = Protos.ExecutorInfo.newBuilder().setExecutorId(Protos.ExecutorID.newBuilder()
            .setValue(taskContext.getExecutorId(jobConfig.getAppName()))).setCommand(command)
            .addResources(buildResource("cpus", appConfig.getCpuCount(), offer.getResourcesList()))
            .addResources(buildResource("mem", appConfig.getMemoryMB(), offer.getResourcesList()));
    if (env.getJobEventRdbConfiguration().isPresent()) {
        executorBuilder.setData(ByteString.copyFrom(SerializationUtils.serialize(env.getJobEventRdbConfigurationMap()))).build();
    }
    return result.setExecutor(executorBuilder.build()).build();
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Test
public void testSuccessKeystore() throws Exception {
    ArrayList<TransportEncryptionSpec> transportEncryptionSpecs = new ArrayList<>();
    transportEncryptionSpecs.add(new DefaultTransportEncryptionSpec.Builder()
            .name("test-tls")
            .type(TransportEncryptionSpec.Type.KEYSTORE)
            .build());

    Protos.Offer offer = OfferTestUtils.getOffer(ResourceTestUtils.getUnreservedCpus(2.0));
    PodInfoBuilder podInfoBuilder = getPodInfoBuilderForTransportEncryption(transportEncryptionSpecs);

    EvaluationOutcome outcome = tlsEvaluationStage.evaluate(
            new MesosResourcePool(offer, Optional.of(Constants.ANY_ROLE)), podInfoBuilder);
    Assert.assertTrue(outcome.isPassing());

    // Check that TLS update was invoked
    verify(mockTLSArtifactsUpdater).update(Matchers.any(), Matchers.any(), Matchers.eq("test-tls"));

    Protos.ContainerInfo executorContainer =
            podInfoBuilder.getTaskBuilder(TestConstants.TASK_NAME).getExecutor().getContainer();
    Assert.assertEquals(0, executorContainer.getVolumesCount());

    Protos.ContainerInfo taskContainer = podInfoBuilder.getTaskBuilder(TestConstants.TASK_NAME).getContainer();
    assertKeystoreArtifacts(taskContainer, tlsArtifactPaths, "test-tls");
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private void runReconcile(QueuedSchedulerDriver driver) {
    while (!scheduler.getReconciler().isReconciled()) {

        final Protos.Offer offer = TestUtils.generateOffer(frameworkId.getValue(), 4, 10240, 10240);
        scheduler.resourceOffers(driver, Arrays.asList(offer));
        final Collection<Protos.TaskStatus> taskStatuses = driver.drainReconciling();
        if (taskStatuses.isEmpty()) {
            // All reconciled
            cassandraState.getTaskStatuses().forEach(status -> scheduler.statusUpdate(driver, status));
        } else {
            taskStatuses.forEach(status -> scheduler.statusUpdate(driver, status));
        }

        if (!scheduler.getReconciler().isReconciled()) {
            final Collection<Protos.OfferID> declined = driver.drainDeclined();
            assertEquals(1, declined.size());
            assertEquals(declined.iterator().next(), offer.getId());
        }
    }
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Test
public void testHealthCheckPortEnvvarIsCorrectOnOverlay() throws Exception {
    DefaultPodInstance podInstance = getPodInstance("valid-port-healthcheck-overlay.yml");
    PodInstanceRequirement podInstanceRequirement =
            PodInstanceRequirement.newBuilder(podInstance, TaskUtils.getTaskNames(podInstance))
                    .build();
    PodInfoBuilder podInfoBuilder = getPodInfoBuilder(podInstanceRequirement, true);
    Protos.Resource offeredPorts = ResourceTestUtils.getUnreservedPorts(10000, 10000);
    Protos.Offer offer = OfferTestUtils.getOffer(offeredPorts);
    PortEvaluationStage portEvaluationStage =
            new PortEvaluationStage(getPortSpec(podInstance), TestConstants.TASK_NAME, Optional.empty());
    EvaluationOutcome outcome = portEvaluationStage.evaluate(
            new MesosResourcePool(offer, Optional.of(Constants.ANY_ROLE)), podInfoBuilder);
    Assert.assertTrue(outcome.isPassing());
    Assert.assertEquals(0, outcome.getOfferRecommendations().size());
    Protos.TaskInfo.Builder taskBuilder = podInfoBuilder.getTaskBuilders().stream().findFirst().get();
    Assert.assertTrue(taskBuilder.getCommand().getEnvironment().getVariablesList().stream()
            .filter(variable -> variable.getName().equals("PORT_TEST_PORT") && variable.getValue().equals("10000"))
            .count() == 1);
    Assert.assertTrue(taskBuilder.getHealthCheck().getCommand().getEnvironment().getVariablesList().stream()
            .filter(variable -> variable.getName().equals("PORT_TEST_PORT") && variable.getValue().equals("10000"))
            .count() == 1);
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private static void updateFaultDomainEnv(Protos.TaskInfo.Builder builder, Protos.Offer offer) {
    if (!offer.hasDomain() || !offer.getDomain().hasFaultDomain() || !builder.hasCommand()) {
        return;
    }

    Protos.Environment.Variable regionVar = Protos.Environment.Variable.newBuilder()
            .setName(EnvConstants.REGION_TASKENV)
            .setValue(offer.getDomain().getFaultDomain().getRegion().getName())
            .build();

    Protos.Environment.Variable zoneVar = Protos.Environment.Variable.newBuilder()
            .setName(EnvConstants.ZONE_TASKENV)
            .setValue(offer.getDomain().getFaultDomain().getZone().getName())
            .build();

    builder.getCommandBuilder()
            .getEnvironmentBuilder()
            .addVariables(regionVar)
            .addVariables(zoneVar);
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private Protos.TaskInfo getTaskInfo(final Protos.Offer offer, final TaskAssignmentResult taskAssignmentResult) {
    TaskContext taskContext = TaskContext.from(taskAssignmentResult.getTaskId());
    Optional<CloudJobConfiguration> jobConfigOptional = facadeService.load(taskContext.getMetaInfo().getJobName());
    if (!jobConfigOptional.isPresent()) {
        return null;
    }
    CloudJobConfiguration jobConfig = jobConfigOptional.get();
    Optional<CloudAppConfiguration> appConfigOptional = facadeService.loadAppConfig(jobConfig.getAppName());
    if (!appConfigOptional.isPresent()) {
        return null;
    }
    CloudAppConfiguration appConfig = appConfigOptional.get();
    taskContext.setSlaveId(offer.getSlaveId().getValue());
    ShardingContexts shardingContexts = getShardingContexts(taskContext, appConfig, jobConfig);
    boolean isCommandExecutor = CloudJobExecutionType.TRANSIENT == jobConfig.getJobExecutionType() && JobType.SCRIPT == jobConfig.getTypeConfig().getJobType();
    String script = appConfig.getBootstrapScript();
    if (isCommandExecutor) {
        script = ((ScriptJobConfiguration) jobConfig.getTypeConfig()).getScriptCommandLine();
    }
    Protos.CommandInfo.URI uri = buildURI(appConfig, isCommandExecutor);
    Protos.CommandInfo command = buildCommand(uri, script, shardingContexts, isCommandExecutor);
    if (isCommandExecutor) {
        return buildCommandExecutorTaskInfo(taskContext, jobConfig, shardingContexts, offer, command);
    } else {
        return buildCustomizedExecutorTaskInfo(taskContext, appConfig, jobConfig, shardingContexts, offer, command);
    }
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private Protos.TaskInfo buildCommandExecutorTaskInfo(final TaskContext taskContext, final CloudJobConfiguration jobConfig, final ShardingContexts shardingContexts,
                                                     final Protos.Offer offer, final Protos.CommandInfo command) {
    Protos.TaskInfo.Builder result = Protos.TaskInfo.newBuilder().setTaskId(Protos.TaskID.newBuilder().setValue(taskContext.getId()).build())
            .setName(taskContext.getTaskName()).setSlaveId(offer.getSlaveId())
            .addResources(buildResource("cpus", jobConfig.getCpuCount(), offer.getResourcesList()))
            .addResources(buildResource("mem", jobConfig.getMemoryMB(), offer.getResourcesList()))
            .setData(ByteString.copyFrom(new TaskInfoData(shardingContexts, jobConfig).serialize()));
    return result.setCommand(command).build();
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Override
public void resourceOffers(final SchedulerDriver schedulerDriver, final List<Protos.Offer> offers) {
    for (Protos.Offer offer: offers) {
        log.trace("Adding offer {} from host {}", offer.getId(), offer.getHostname());
        LeasesQueue.getInstance().offer(offer);
    }
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
public static Protos.Offer createOffer(final String offerId) {
    return Protos.Offer.newBuilder()
            .setId(Protos.OfferID.newBuilder().setValue(offerId))
            .setFrameworkId(Protos.FrameworkID.newBuilder().setValue("elastic-job-cloud-test").build())
            .setSlaveId(Protos.SlaveID.newBuilder().setValue("slave-" + offerId).build())
            .setHostname("localhost")
            .addResources(Protos.Resource.newBuilder().setName("cpus").setType(Protos.Value.Type.SCALAR).setScalar(Protos.Value.Scalar.newBuilder().setValue(100d).build()).build())
            .addResources(Protos.Resource.newBuilder().setName("mem").setType(Protos.Value.Type.SCALAR).setScalar(Protos.Value.Scalar.newBuilder().setValue(128000d).build()).build())
            .build();
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Test
public void assertResourceOffers() {
    SchedulerDriver schedulerDriver = mock(SchedulerDriver.class);
    List<Protos.Offer> offers = Arrays.asList(OfferBuilder.createOffer("offer_0"), OfferBuilder.createOffer("offer_1"));
    schedulerEngine.resourceOffers(schedulerDriver, offers);
    assertThat(LeasesQueue.getInstance().drainTo().size(), is(2));
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Override
public Protos.TaskInfo create(String taskId, Protos.Offer offer, List<Protos.Resource> resources, ExecutionParameters executionParameters) {
    logger.debug("Creating Mesos task for taskId={}", taskId);
    return Protos.TaskInfo.newBuilder()
            .setName(applicationName + ".task")
            .setSlaveId(offer.getSlaveId())
            .setTaskId(Protos.TaskID.newBuilder().setValue(taskId))
            .addAllResources(resources)
            .setData(ByteString.copyFromUtf8(String.join(";", humioHost, humioDataspace, humioIngesttoken,
                humioDataDir, defaultIfEmpty(filebeatConfigUrl, " "), defaultIfEmpty(metricbeatConfigUrl, " "))))
            .setLabels(Protos.Labels.newBuilder().addLabels(createLabel("HUMIO_IGNORE", "true")).build())
            .setDiscovery(Protos.DiscoveryInfo.newBuilder()
                .setName(applicationName)
                .setVisibility(Protos.DiscoveryInfo.Visibility.FRAMEWORK)
                .build())
            .setExecutor(Protos.ExecutorInfo.newBuilder()
                .setName("humioexecutor")
                    .setData(ByteString.copyFromUtf8(dcosAuthToken.concat(";").concat(enableContainerMetrics.toString())))
                .setExecutorId(Protos.ExecutorID.newBuilder().setValue("humioexecutor." + offer.getSlaveId()
                    .getValue()).build())
                .setCommand(Protos.CommandInfo.newBuilder()
                    .setValue("jre*/bin/java -jar executor-*.jar")
                    .addAllUris(mesosConfig.getUri().stream().map(uri -> Protos.CommandInfo.URI
                        .newBuilder().setValue(uri).build()).collect(Collectors.toList()))
                    .build())
                .build())
        .build();
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
public Plan(List<OfferAcceptor> offerAcceptors,
     List<Job> toKeep,
     List<Protos.Offer> toStock) {
    this.offerAcceptors = Objects.requireNonNull(offerAcceptors);
    this.toKeep = Objects.requireNonNull(toKeep);
    this.toStock = Objects.requireNonNull(toStock);
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Test
public void testTakeOne() {
    OfferQueue offerQueue = new OfferQueue(TEST_CAPACITY);
    offerQueue.offer(getOffer());
    List<Protos.Offer> offers = offerQueue.takeAll();
    Assert.assertEquals(1, offers.size());
    Assert.assertEquals(TEST_CAPACITY, offerQueue.getRemainingCapacity());
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private Protos.TaskID installStep(int phaseIndex, int stepIndex, Protos.Offer offer) {
    // Get first Step associated with Task A-0
    List<Protos.Offer> offers = Arrays.asList(offer);
    Protos.OfferID offerId = offer.getId();
    Step step = getDeploymentPlan().getChildren().get(phaseIndex).getChildren().get(stepIndex);
    Assert.assertTrue(step.isPending());

    // Offer sufficient Resource and wait for its acceptance
    defaultScheduler.getMesosScheduler().get()
            .resourceOffers(mockSchedulerDriver, offers);
    verify(mockSchedulerDriver, times(1)).acceptOffers(
            Matchers.argThat(isACollectionThat(contains(offerId))),
            operationsCaptor.capture(),
            any());

    // Verify 2 Reserve and 1 Launch Operations were executed
    Collection<Protos.Offer.Operation> operations = operationsCaptor.getValue();
    Assert.assertEquals(8, operations.size());
    Assert.assertEquals(6, countOperationType(Protos.Offer.Operation.Type.RESERVE, operations));
    Assert.assertEquals(1, countOperationType(Protos.Offer.Operation.Type.CREATE, operations));
    Assert.assertEquals(1, countOperationType(Offer.Operation.Type.LAUNCH_GROUP, operations));
    Assert.assertTrue(step.isStarting());

    // Sent TASK_RUNNING status
    Protos.TaskID taskId = getTaskId(operations);
    statusUpdate(getTaskId(operations), Protos.TaskState.TASK_RUNNING);

    // Wait for the Step to become Complete
    Assert.assertTrue(step.isComplete());

    return taskId;
}