Java SchedulerDriver.launchTasks方法代码示例

import org.apache.mesos.SchedulerDriver; //导入方法依赖的package包/类
public void launchTasks(SchedulerDriver driver) {
  final List<TaskInfo> toLaunch = Lists.newArrayListWithCapacity(acceptedTasks.size());
  final List<SingularityTaskId> taskIds = Lists.newArrayListWithCapacity(acceptedTasks.size());

  for (SingularityTask task : acceptedTasks) {
    taskIds.add(task.getTaskId());
    toLaunch.add(task.getMesosTask());
    LOG.trace("Launching {} mesos task: {}", task.getTaskId(), task.getMesosTask());
  }

  Status initialStatus = driver.launchTasks(ImmutableList.of(offer.getId()), toLaunch);

  LOG.info("{} tasks ({}) launched with status {}", taskIds.size(), taskIds, initialStatus);
}
 

import org.apache.mesos.SchedulerDriver; //导入方法依赖的package包/类
@Override public void resourceOffers(SchedulerDriver schedulerDriver, List<Protos.Offer> list) {
    double CPUS_PER_TASK = 1;
    double MEM_PER_TASK = 128;

    for (Protos.Offer offer : list) {
        List<Protos.TaskInfo> taskInfoList = new ArrayList<Protos.TaskInfo>();
        double offerCpus = 0;
        double offerMem = 0;
        for (Protos.Resource resource : offer.getResourcesList()) {
            if (resource.getName().equals("cpus")) {
                offerCpus += resource.getScalar().getValue();
            } else if (resource.getName().equals("mem")) {
                offerMem += resource.getScalar().getValue();
            }
        }
        LOGGER.info("Received Offer : " + offer.getId().getValue() + " with cpus = " + offerCpus + " and mem ="
                + offerMem);

        double remainingCpus = offerCpus;
        double remainingMem = offerMem;

        if (launchedTasks < totalTasks && remainingCpus >= CPUS_PER_TASK && remainingMem >= MEM_PER_TASK) {
            Protos.TaskID taskID = Protos.TaskID.newBuilder().setValue(Integer.toString(launchedTasks++)).build();
            LOGGER.info("Launching task :" + taskID.getValue() + " using the offer : " + offer.getId().getValue());

            Protos.TaskInfo piTaskInfo = Protos.TaskInfo.newBuilder().setName("task " + taskID.getValue())
                    .setTaskId(taskID).setSlaveId(offer.getSlaveId())
                    .addResources(Protos.Resource.newBuilder().setName("cpus")
                            .setType(
                                    Protos.Value.Type.SCALAR)
                            .setScalar(Protos.Value.Scalar
                                    .newBuilder().setValue(
                                            CPUS_PER_TASK)))
                    .addResources(Protos.Resource.newBuilder().setName("mem")
                            .setType(
                                    Protos.Value.Type.SCALAR)
                            .setScalar(Protos.Value.Scalar
                                    .newBuilder()
                                    .setValue(MEM_PER_TASK)))
                    .setExecutor(Protos.ExecutorInfo.newBuilder(
                            piExecutor))
                    .build();

            taskID = Protos.TaskID.newBuilder().setValue(Integer.toString(launchedTasks++)).build();
            LOGGER.info("Launching task :" + taskID.getValue() + " using the offer : " + offer.getId().getValue());

            taskInfoList.add(piTaskInfo);

        }
        schedulerDriver.launchTasks(offer.getId(), taskInfoList);
    }
}
 

import org.apache.mesos.SchedulerDriver; //导入方法依赖的package包/类
@Override
public void resourceOffers(SchedulerDriver schedulerDriver, List<Protos.Offer> offers) {

    loggerWrapper.debug("Resource offers with " + offers.size() + " offers" );

    for (Protos.Offer offer : offers) {
        if (!constraints.constraintsAllow(offer) ||
                runningInstances.size() + pendingInstances.size() >= desiredInstances) {
            schedulerDriver.declineOffer(offer.getId());
            schedulerDriver.suppressOffers();
            continue;
        }

        Double offerCpus = 0d;
        Double offerMem = 0d;
        for (Resource resource : offer.getResourcesList()) {
          if (resource.getName().equals("cpus")) {
            offerCpus += resource.getScalar().getValue();
          } else if (resource.getName().equals("mem")) {
            offerMem += resource.getScalar().getValue();
          }
        }
        if (offerCpus < cpu || offerMem < memory) {
            schedulerDriver.declineOffer(offer.getId());
            continue;
        }

        List<Protos.TaskInfo> tasks = new ArrayList<>();
        // generate a unique task ID
        Protos.TaskID taskId = Protos.TaskID.newBuilder()
                .setValue(TaskIdGeneratorHelper.getTaskId(context)).build();

        loggerWrapper.debug("Launching task " + taskId.getValue());
        pendingInstances.add(taskId.getValue());

        // docker image info
        Protos.ContainerInfo.DockerInfo.Builder dockerInfoBuilder = Protos.ContainerInfo.DockerInfo.newBuilder();
        dockerInfoBuilder.setImage(imageName);
        dockerInfoBuilder.setNetwork(Protos.ContainerInfo.DockerInfo.Network.BRIDGE);
        dockerInfoBuilder.setForcePullImage(forcePullImage);
        if (!parameters.isEmpty()) {
            dockerInfoBuilder.addAllParameters(parameters);
        }

        // container info
        Protos.ContainerInfo.Builder containerInfoBuilder = Protos.ContainerInfo.newBuilder();
        containerInfoBuilder.setType(Protos.ContainerInfo.Type.DOCKER);
        containerInfoBuilder.setDocker(dockerInfoBuilder.build());
        if (!volumes.isEmpty()) {
            containerInfoBuilder.addAllVolumes(volumes);
        }

        // create task to run
        Protos.TaskInfo task = Protos.TaskInfo.newBuilder()
                .setName("task " + taskId.getValue())
                .setTaskId(taskId)
                .setSlaveId(offer.getSlaveId())
                .addResources(Protos.Resource.newBuilder()
                        .setName("cpus")
                        .setType(Protos.Value.Type.SCALAR)
                        .setScalar(Protos.Value.Scalar.newBuilder().setValue(cpu)))
                .addResources(Protos.Resource.newBuilder()
                        .setName("mem")
                        .setType(Protos.Value.Type.SCALAR)
                        .setScalar(Protos.Value.Scalar.newBuilder().setValue(memory)))
                .setContainer(containerInfoBuilder)
                .setCommand(commandInfoBuilder)
                .build();

        tasks.add(task);

        loggerWrapper.task = task;
        loggerWrapper.stoptMesosTailWait();

        // Only accept offer when tasks size greater than 0.
        Protos.Filters filters = Protos.Filters.newBuilder().setRefuseSeconds(1).build();
        schedulerDriver.launchTasks(offer.getId(), tasks, filters);
    }
}
 

import org.apache.mesos.SchedulerDriver; //导入方法依赖的package包/类
@Override
public void resourceOffers(SchedulerDriver schedulerDriver, List<Protos.Offer> list) {
    for (Protos.Offer offer : list) {
        Protos.SlaveID slaveId = offer.getSlaveId();
        if (needMoreNodes() && !slaveContainsHazelcastNode(slaveId)) {
            System.out.println("Launching Hazelcast on slaveId = " + slaveId.getValue());
            Protos.TaskID.Builder taskId = Protos.TaskID.newBuilder().setValue("node-" + slaveId.getValue());

            HazelcastMessages.HazelcastServerProcessTask processTask = HazelcastMessages.HazelcastServerProcessTask
                    .newBuilder()
                    .setVersion(getHazelcastVersion())
                    .addCommand("java")
                    .addCommand("-server")
                    .addCommand("-Xms" + getMinHeap())
                    .addCommand("-Xmx" + getMaxHeap())
                    .addCommand("-Djava.net.preferIPv4Stack=true")
                    .addCommand("-cp")
                    .addCommand("hazelcast-" + getHazelcastVersion() + ".jar:hazelcast-zookeeper.jar")
                    .addCommand("com.hazelcast.core.server.StartServer")
                    .build();

            Protos.TaskInfo.Builder builder = Protos.TaskInfo.newBuilder()
                    .setSlaveId(slaveId)
                    .setName("Hazelcast node")
                    .addResources(resource("cpus", getCpuPerNode()))
                    .addResources(resource("mem", getMemoryPerNode()))
                    .setData(processTask.toByteString())
                    .setTaskId(taskId);

            Protos.ExecutorInfo executor = buildExecutor();
            Protos.TaskInfo taskInfo = builder.setExecutor(executor).build();
            schedulerDriver.launchTasks(singletonList(offer.getId()), singletonList(taskInfo));
            HazelcastNode hazelcastNode = new HazelcastNode(offer.getHostname(), slaveId.getValue(), taskId.getValue());
            activeNodes.add(hazelcastNode);
        } else if (needLessNodes() && slaveContainsHazelcastNode(slaveId)) {
            Protos.TaskID taskID = Protos.TaskID.newBuilder().setValue("node-" + slaveId.getValue()).build();
            schedulerDriver.killTask(taskID);
            removeNodeFromActiveNodesWithTaskID(taskID);
        } else {
            schedulerDriver.declineOffer(offer.getId());
        }
    }
}