Java Protos.HealthCheck方法代码示例

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Test
public void testReadinessCheckTagging() throws TaskException {
    Protos.HealthCheck inReadinessCheck = Protos.HealthCheck.newBuilder()
            .setDelaySeconds(1.0)
            .build();
    Protos.TaskInfo.Builder builder = getTestTaskInfo().toBuilder();
    builder.setLabels(new TaskLabelWriter(builder)
            .setReadinessCheck(inReadinessCheck)
            .toProto());
    Protos.HealthCheck outReadinessCheck = new TaskLabelWriter(builder.build()) {
        @Override
        public Optional<HealthCheck> getReadinessCheck() throws TaskException {
            return super.getReadinessCheck();
        }
    }.getReadinessCheck().get();

    Assert.assertEquals(inReadinessCheck.getDelaySeconds(), outReadinessCheck.getDelaySeconds(), 0.0);
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
public static CheckHandler create(
        ExecutorDriver executorDriver,
        Protos.TaskInfo taskInfo,
        LaunchedTask launchedTask,
        Protos.HealthCheck healthCheck,
        ScheduledExecutorService scheduledExecutorService,
        CheckStats healthCheckStats,
        String checkType)
        throws CheckValidationException {
    return new CheckHandler(
            executorDriver,
            taskInfo,
            launchedTask,
            new ProcessRunner(),
            healthCheck,
            scheduledExecutorService,
            healthCheckStats,
            checkType);
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
/**
 * Allows providing a custom {@link ProcessRunner} for testing.
 */
@VisibleForTesting
CheckHandler(
        ExecutorDriver executorDriver,
        Protos.TaskInfo taskInfo,
        LaunchedTask launchedTask,
        ProcessRunner processRunner,
        Protos.HealthCheck healthCheck,
        ScheduledExecutorService scheduledExecutorService,
        CheckStats healthCheckStats,
        String checkType)
        throws CheckValidationException {
    validate(healthCheck);
    this.healthCheck = healthCheck;
    this.scheduledExecutorService = scheduledExecutorService;
    this.healthCheckRunner = new CheckRunner(
            executorDriver,
            taskInfo,
            launchedTask,
            processRunner,
            healthCheck,
            healthCheckStats,
            checkType);
    this.checkType = checkType;
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
/**
 * Custom Executors are responsible for implementing HealthChecks.  This Custom Executor implements a subset of
 * all possible Health Checks describable by a HealthCheckInfo object.
 * <p>
 * They must be command HealthChecks as HTTP is not recommended by Mesos yet and is unneeded from a completeness
 * perspective.  `curl -f` normally is sufficient.  Since all HealthChecks as currently implemented by this Custom
 * Executor are excuted as sub-processes we further require that the HealthCheck specifies that it is a "shell"
 * command to avoid unexpected behavior.
 *
 * @param healthCheck The HealthCheck to be executed
 * @throws CheckValidationException when a HealthCheck does not adhere to the HealthChecks supported
 *                                        by this Custom Executor
 */
private void validate(Protos.HealthCheck healthCheck) throws CheckValidationException {
    // Validate HealthCheck
    if (healthCheck.hasHttp()) {
        throw new CheckValidationException(String.format(
                "The following %s check contains an unsupported HTTP configuration: %s", checkType, healthCheck));
    }

    if (!healthCheck.hasCommand()) {
        throw new CheckValidationException(String.format(
                "The following %s check does not contain a Command: %s", checkType, healthCheck));
    }

    // Validate Command
    Protos.CommandInfo commandInfo = healthCheck.getCommand();
    if (!Boolean.valueOf(commandInfo.getShell())) {
        throw new CheckValidationException(String.format(
                "Only shell based %s checks are supported for commmand: %s", checkType, commandInfo));
    }
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private CheckRunner(
        ExecutorDriver executorDriver,
        Protos.TaskInfo taskInfo,
        LaunchedTask launchedTask,
        ProcessRunner processRunner,
        Protos.HealthCheck healthCheck,
        CheckStats healthCheckStats,
        String checkType) {
    this.executorDriver = executorDriver;
    this.taskInfo = taskInfo;
    this.launchedTask = launchedTask;
    this.processRunner = processRunner;
    this.healthCheck = healthCheck;
    this.healthCheckStats = healthCheckStats;
    this.checkType = checkType;
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private void scheduleReadinessCheck(
        ExecutorDriver executorDriver,
        Protos.TaskInfo taskInfo,
        LaunchedTask launchedTask) {

    Optional<Protos.HealthCheck> readinessCheckOptional = Optional.empty();
    try {
        readinessCheckOptional = new ExecutorTaskLabelReader(taskInfo).getReadinessCheck();
    } catch (TaskException e) {
        LOGGER.error(String.format(
                "Failed to extract readiness check from task: %s", taskInfo.getTaskId().getValue()), e);
        return;
    }

    if (!readinessCheckOptional.isPresent()) {
        return;
    }

    scheduleCheck(executorDriver, taskInfo, readinessCheckOptional.get(), launchedTask, "Readiness");
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
@Override
public Protos.HealthCheck create(List<Protos.Resource> resources) {
    // Dev note: HealthCheck does not work in 0.25: https://issues.apache.org/jira/browse/MESOS-3738
    Protos.HealthCheck healthDefault = Protos.HealthCheck.getDefaultInstance();
    if (mesosConfig.getHealthCheck() == null) {
        return healthDefault;
    } else {
        return Protos.HealthCheck.newBuilder()
                .setCommand(
                        Protos.CommandInfo.newBuilder()
                                .setValue(mesosConfig.getHealthCheck().getOrDefault("command", "echo Success"))
                )
                .setTimeoutSeconds(Double.valueOf(mesosConfig.getHealthCheck().getOrDefault("timeout", Double.toString(healthDefault.getTimeoutSeconds()))))
                .setDelaySeconds(Double.valueOf(mesosConfig.getHealthCheck().getOrDefault("delay", Double.toString(healthDefault.getDelaySeconds()))))
                .setConsecutiveFailures(Integer.valueOf(mesosConfig.getHealthCheck().getOrDefault("consecutiveFailures", Integer.toString(healthDefault.getConsecutiveFailures()))))
                .setGracePeriodSeconds(Double.valueOf(mesosConfig.getHealthCheck().getOrDefault("gracePeriod", Double.toString(healthDefault.getGracePeriodSeconds()))))
                .setIntervalSeconds(Double.valueOf(mesosConfig.getHealthCheck().getOrDefault("interval", Double.toString(healthDefault.getIntervalSeconds()))))
                .build();
    }
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
public CheckMonitor(
        Protos.HealthCheck healthCheck,
        CheckHandler healthCheckHandler,
        LaunchedTask launchedTask,
        String checkType) {
    this.healthCheck = healthCheck;
    this.healthCheckHandler = healthCheckHandler;
    this.launchedTask = launchedTask;
    this.checkType = checkType;
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private static Protos.HealthCheck getHealthCheck(int maxConsecutiveFailures) {
    return Protos.HealthCheck.newBuilder()
            .setIntervalSeconds(SHORT_INTERVAL_S)
            .setDelaySeconds(SHORT_DELAY_S)
            .setGracePeriodSeconds(SHORT_GRACE_PERIOD_S)
            .setTimeoutSeconds(TIMEOUT_S)
            .setConsecutiveFailures(maxConsecutiveFailures)
            .setCommand(Protos.CommandInfo.newBuilder()
                    .setValue("this_command_should_not_be_run")
                    .build())
            .build();
}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private void scheduleCheck(
        ExecutorDriver executorDriver,
        Protos.TaskInfo taskInfo,
        Protos.HealthCheck check,
        LaunchedTask launchedTask,
        String checkType) {

    try {
        CheckMonitor healthCheckMonitor =
                new CheckMonitor(
                        check,
                        CheckHandler.create(
                                executorDriver,
                                taskInfo,
                                launchedTask,
                                check,
                                HEALTH_CHECK_THREAD_POOL,
                                new CheckStats(taskInfo.getName()),
                                checkType),
                        launchedTask,
                        checkType);
        LOGGER.info("Submitting {} check monitor.", checkType);
        Future<Optional<CheckStats>> futureOptionalHealthCheckStats =
                executorService.submit(healthCheckMonitor);

        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    Optional<CheckStats> optionalHealthCheckStats = futureOptionalHealthCheckStats.get();
                    if (optionalHealthCheckStats.isPresent()) {
                        LOGGER.info("{} check exited with statistics: {}",
                                checkType, optionalHealthCheckStats.get());
                    }
                } catch (InterruptedException | ExecutionException e) {
                    LOGGER.error(String.format("Failed to get %s check stats with exception: ", checkType), e);
                }
            }
        });
    } catch (CheckHandler.CheckValidationException ex) {
        LOGGER.error(String.format("Task did not generate a %s check with exception: ", checkType), ex);
    }

}
 

import org.apache.mesos.Protos; //导入方法依赖的package包/类
private static Protos.HealthCheck getReadinessCheck() {
    return getHealthCheck(0);
}