Java App.setInstances方法代码示例

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
private App createZookeeperApp() {
    App app = new App();
    app.setId(this.id);
    app.setCpus(cpu);
    app.setMem(mem);
    app.setInstances(instances);
    app.setContainer(new Container());
    app.getContainer().setType(CONTAINER_TYPE);
    app.getContainer().setDocker(new Docker());
    app.getContainer().getDocker().setImage(ZK_IMAGE);
    List<HealthCheck> healthCheckList = new ArrayList<>();
    final HealthCheck hc = setHealthCheck(300, "TCP", false, 60, 20, 0, ZKSERVICE_ZKPORT);
    healthCheckList.add(hc);
    app.setHealthChecks(healthCheckList);

    return app;
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
private void mergeApp(Customer customer, App newApp, App oldApp)
{
    // add customer id as service tag
    Map<String, String> envVariables = newApp.getEnv();
    if (envVariables.containsKey("SERVICE_TAGS")) {
        envVariables.put("SERVICE_TAGS", envVariables.get("SERVICE_TAGS") + ",customer-" + customer.getId());
    } else {
        envVariables.put("SERVICE_TAGS", "customer-" + customer.getId());
    }

    if (null == oldApp) {
        return;
    }
    // only merge settings for scaled applications
    if (null != newApp.getLabels() && newApp.getLabels().containsKey(MarathonMonitor.LABEL_SCALING_STRATEGY)) {
        return;
    }
    newApp.setInstances(oldApp.getInstances());
    newApp.setCpus(oldApp.getCpus());
    newApp.setMem(oldApp.getMem());
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
@Test
public void testScaleDownByCPU()
{
    App app = createApp(2, 4);
    AppStatistics statistics = createStatistics(0, 32);
    app.setInstances(4);

    // 0% across 4 instances => scale down by one
    horizontal.scale(app, statistics);
    assertSame(3, app.getInstances());

    // 0% across 3 instances => scale down by one
    horizontal.scale(app, statistics);
    assertSame(2, app.getInstances());

    // 0% across 2 instances => do nothing, already min instances
    horizontal.scale(app, statistics);
    assertSame(2, app.getInstances());
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
@Test
public void testScaleDownByMemory()
{
    App app = createApp(2, 4);
    AppStatistics statistics = createStatistics(0, 80);
    app.setInstances(4);

    // 80MB across 4 instances => scale down by one
    horizontal.scale(app, statistics);
    assertSame(3, app.getInstances());

    // 80MB across 3 instances => scale down by one
    horizontal.scale(app, statistics);
    assertSame(2, app.getInstances());

    // 80MB across 2 instances => do nothing, already min
    horizontal.scale(app, statistics);
    assertSame(2, app.getInstances());
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
@Override
protected App generateExternalTaskRepresentation(MarathonApp marathonTask) {
  App app = new App();
  String id = marathonTask.getId();
  if (!APP_NAME_VALIDATOR.matcher(id).matches()) {
    throw new IllegalArgumentException(String.format(
        "Illegal name for TOSCA node <%s>: "
            + "name for nodes of type %s must fully match regular expression %s",
        id, marathonTask.getToscaNodeName(), APP_NAME_VALIDATOR.pattern()));
  }
  app.setId(id);
  app.setCmd(marathonTask.getCmd());
  app.setConstraints(marathonTask.getConstraints());
  app.setCpus(marathonTask.getCpus());
  app.setMem(marathonTask.getMemSize());
  app.setUris(marathonTask.getUris());
  app.setLabels(marathonTask.getLabels());
  app.setEnv(new HashMap<>(marathonTask.getEnv()));
  app.setInstances(marathonTask.getInstances());
  marathonTask
      .getContainer()
      .ifPresent(mesosContainer -> app.setContainer(generateContainer(mesosContainer)));
  return app;
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
/**
 * To configure the controller app.
 *
 * @return App instance of marathon app
 */
private App createPravegaControllerApp() {
    App app = new App();
    app.setId(this.id);
    app.setCpus(cpu);
    app.setMem(mem);
    app.setInstances(instances);
    app.setConstraints(setConstraint("hostname", "UNIQUE"));
    app.setContainer(new Container());
    app.getContainer().setType(CONTAINER_TYPE);
    app.getContainer().setDocker(new Docker());
    app.getContainer().getDocker().setImage(IMAGE_PATH + "/nautilus/pravega:" + PRAVEGA_VERSION);
    String zk = zkUri.getHost() + ":" + ZKSERVICE_ZKPORT;
    //set port
    app.setPortDefinitions(Arrays.asList(createPortDefinition(CONTROLLER_PORT), createPortDefinition(REST_PORT)));
    app.setRequirePorts(true);
    List<HealthCheck> healthCheckList = new ArrayList<HealthCheck>();
    healthCheckList.add(setHealthCheck(300, "TCP", false, 60, 20, 0, CONTROLLER_PORT));
    app.setHealthChecks(healthCheckList);
    //set env
    String controllerSystemProperties = "-Xmx512m" +
            setSystemProperty("ZK_URL", zk) +
            setSystemProperty("CONTROLLER_RPC_PUBLISHED_HOST", this.id + ".marathon.mesos") +
            setSystemProperty("CONTROLLER_RPC_PUBLISHED_PORT", String.valueOf(CONTROLLER_PORT)) +
            setSystemProperty("CONTROLLER_SERVER_PORT", String.valueOf(CONTROLLER_PORT)) +
            setSystemProperty("REST_SERVER_PORT", String.valueOf(REST_PORT)) +
            setSystemProperty("log.level", "DEBUG") +
            setSystemProperty("log.dir", "$MESOS_SANDBOX/pravegaLogs") +
            setSystemProperty("curator-default-session-timeout", String.valueOf(10 * 1000)) +
            setSystemProperty("MAX_LEASE_VALUE", String.valueOf(60 * 1000)) +
            setSystemProperty("MAX_SCALE_GRACE_PERIOD", String.valueOf(60 * 1000));
    Map<String, Object> map = new HashMap<>();
    map.put("PRAVEGA_CONTROLLER_OPTS", controllerSystemProperties);
    app.setEnv(map);
    app.setArgs(Arrays.asList("controller"));

    return app;
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
private App createBookieApp() {
    App app = new App();
    app.setId(this.id);
    app.setCpus(cpu);
    app.setMem(mem);
    app.setInstances(instances);
    app.setConstraints(setConstraint("hostname", "UNIQUE"));
    app.setContainer(new Container());
    app.getContainer().setType(CONTAINER_TYPE);
    app.getContainer().setDocker(new Docker());
    app.getContainer().getDocker().setImage(IMAGE_PATH + "/nautilus/bookkeeper:" + PRAVEGA_VERSION);
    Collection<Volume> volumeCollection = new ArrayList<>();
    volumeCollection.add(createVolume("/bk", "mnt", "RW"));
    //TODO: add persistent volume  (see issue https://github.com/pravega/pravega/issues/639)
    app.getContainer().setVolumes(volumeCollection);
    app.setPorts(Arrays.asList(BK_PORT));
    app.setRequirePorts(true);
    //set env
    String zk = zkUri.getHost() + ":" + ZKSERVICE_ZKPORT;
    Map<String, Object> map = new HashMap<>();
    map.put("ZK_URL", zk);
    map.put("ZK", zk);
    map.put("bookiePort", String.valueOf(BK_PORT));
    map.put("DLOG_EXTRA_OPTS", "-Xms512m");
    app.setEnv(map);
    //healthchecks
    List<HealthCheck> healthCheckList = new ArrayList<>();
    healthCheckList.add(setHealthCheck(300, "TCP", false, 60, 20, 0, BK_PORT));
    app.setHealthChecks(healthCheckList);

    return app;
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
/**
 * @return an app with 64MB memory, 0.5 cpus and 1 instance
 */
protected App createApp()
{
    App app = new App();
    app.setId("/test");
    app.setMem(64.0);
    app.setCpus(0.5);
    app.setInstances(1);

    return app;
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
private void createAppDeployment(AppDeploymentRequest request, String deploymentId, Container container, Integer index) {
	App app = new App();
	app.setContainer(container);
	app.setId(deploymentId);

	Map<String, String> env = new HashMap<>();
	env.putAll(request.getDefinition().getProperties());
	for (String envVar : properties.getEnvironmentVariables()) {
		String[] strings = envVar.split("=", 2);
		Assert.isTrue(strings.length == 2, "Invalid environment variable declared: " + envVar);
		env.put(strings[0], strings[1]);
	}
	if (index != null) {
		env.put(INSTANCE_INDEX_PROPERTY_KEY, index.toString());
	}
	app.setEnv(env);

	Collection<String> uris = deduceUris(request);
	app.setUris(uris);

	Collection<Constraint> constraints = deduceConstraints(request);
	app.setConstraints(constraints.stream().map(Constraint::toStringList).collect(Collectors.toList()));

	Double cpus = deduceCpus(request);
	Double memory = deduceMemory(request);
	Integer instances = index == null ? deduceInstances(request) : 1;

	app.setCpus(cpus);
	app.setMem(memory);
	app.setInstances(instances);

	HealthCheck healthCheck = new HealthCheck();
	healthCheck.setPath("/health");
	healthCheck.setGracePeriodSeconds(300);
	app.setHealthChecks(Arrays.asList(healthCheck));

	logger.debug("Creating app with definition:\n" + app.toString());
	try {
		marathon.createApp(app);
	}
	catch (MarathonException e) {
		throw new RuntimeException(e);
	}
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
private App createPravegaSegmentStoreApp() {
    App app = new App();
    app.setId(this.id);
    app.setCpus(cpu);
    app.setMem(mem);
    app.setInstances(instances);
    //set constraints
    app.setConstraints(setConstraint("hostname", "UNIQUE"));
    //docker container
    app.setContainer(new Container());
    app.getContainer().setType(CONTAINER_TYPE);
    app.getContainer().setDocker(new Docker());
    //set the image and network
    app.getContainer().getDocker().setImage(IMAGE_PATH + "/nautilus/pravega:" + PRAVEGA_VERSION);
    //set port
    app.setPortDefinitions(Arrays.asList(createPortDefinition(SEGMENTSTORE_PORT)));
    app.setRequirePorts(true);
    //healthchecks
    List<HealthCheck> healthCheckList = new ArrayList<HealthCheck>();
    healthCheckList.add(setHealthCheck(300, "TCP", false, 60, 20, 0, SEGMENTSTORE_PORT));
    app.setHealthChecks(healthCheckList);
    //set env
    String zk = zkUri.getHost() + ":" + ZKSERVICE_ZKPORT;

    //Environment variables to configure SS service.
    Map<String, Object> map = new HashMap<>();
    map.put("ZK_URL", zk);
    map.put("BK_ZK_URL", zk);
    map.put("CONTROLLER_URL", conUri.toString());
    getCustomEnvVars(map, SEGMENTSTORE_EXTRA_ENV);

    //Properties set to override defaults for system tests
    String hostSystemProperties = "-Xmx1024m" +
            setSystemProperty("autoScale.muteInSeconds", "120") +
            setSystemProperty("autoScale.cooldownInSeconds", "120") +
            setSystemProperty("autoScale.cacheExpiryInSeconds", "120") +
            setSystemProperty("autoScale.cacheCleanUpInSeconds", "120") +
            setSystemProperty("log.level", "DEBUG") +
            setSystemProperty("log.dir", "$MESOS_SANDBOX/pravegaLogs") +
            setSystemProperty("curator-default-session-timeout", String.valueOf(30 * 1000)) +
            setSystemProperty("hdfs.replaceDataNodesOnFailure", "false");

    map.put("PRAVEGA_SEGMENTSTORE_OPTS", hostSystemProperties);
    app.setEnv(map);
    app.setArgs(Arrays.asList("segmentstore"));

    return app;
}
 

import mesosphere.marathon.client.model.v2.App; //导入方法依赖的package包/类
@Override
public void scale(App app, AppStatistics statistics)
{
    Map<String, String> labels = app.getLabels();
    int maxInstances = app.getInstances();
    if (labels.containsKey(LABEL_MAX_INSTANCES)) {
        maxInstances = Integer.parseInt(labels.get(LABEL_MAX_INSTANCES));
    }
    int minInstances = app.getInstances();
    if (labels.containsKey(LABEL_MIN_INSTANCES)) {
        minInstances = Integer.parseInt(labels.get(LABEL_MIN_INSTANCES));
    }
    if (app.getInstances() == 0) {
        return;
    }

    float cpuAverage = statistics.getCpu().orElse(0F) / app.getInstances();
    float memoryAverage = statistics.getMemoryInMegabytes() / app.getInstances();

    // scaling up
    if (app.getInstances() < maxInstances) {
        if (cpuAverage > 0.9) {
            app.setInstances(app.getInstances() + 1);
            logger.info(
                "scaling app '{}' up to {} instances due to cpu usage ({}%)",
                app.getId(),
                app.getInstances(),
                cpuAverage * 100
            );

            return;
        }

        if (memoryAverage > app.getMem() * 0.9) {
            app.setInstances(app.getInstances() + 1);
            logger.info(
                "scaling app '{}' up to {} instances due to memory usage ({} MB/{} MB)",
                app.getId(),
                app.getInstances(),
                memoryAverage,
                app.getMem()
            );

            return;
        }
    }


    // scaling down
    if (app.getInstances() > minInstances) {
        // check for presence to avoid scaling down, when no value exists
        if (statistics.getCpu().isPresent() && cpuAverage < 0.1
            && statistics.getMemory().isPresent() && memoryAverage < app.getMem() * 0.5) {
            app.setInstances(app.getInstances() - 1);
            logger.info(
                "scaling app '{}' down to {} instances due to low resource usage (CPU {}%, Memory: {}/{} MB)",
                app.getId(),
                app.getInstances(),
                cpuAverage * 100,
                memoryAverage,
                app.getMem()
            );
        }
    }
}