import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
/**
 * Construct a Marathon client based on the provided credentialsId and execute an update for the configuration's
 * Marathon application.
 *
 * @param credentialsId A string ID for a credential within Jenkin's Credential store
 * @throws MarathonException thrown if the Marathon service has an error
 */
private void doUpdate(final String credentialsId) throws MarathonException {
    final Credentials credentials = MarathonBuilderUtils.getJenkinsCredentials(credentialsId, Credentials.class);

    Marathon client;

    if (credentials instanceof UsernamePasswordCredentials) {
        client = getMarathonClient((UsernamePasswordCredentials) credentials);
    } else if (credentials instanceof StringCredentials) {
        client = getMarathonClient((StringCredentials) credentials);
    } else {
        client = getMarathonClient();
    }

    if (client != null) {
        client.updateApp(getApp().getId(), getApp(), config.getForceUpdate());
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
/**
 * Get a Marathon client with Authorization headers using the token within provided credentials. If the content of
 * credentials is JSON, this will use the "jenkins_token" field; if the content is just a string, that will be
 * used as the token value.
 *
 * @param credentials String credentials
 * @return Marathon client with token in auth header
 */
private Marathon getMarathonClient(StringCredentials credentials) {
    String token;

    try {
        final JSONObject json = JSONObject.fromObject(credentials.getSecret().getPlainText());
        if (json.has("jenkins_token")) {
            token = json.getString("jenkins_token");
        } else {
            token = "";
        }
    } catch (JSONException jse) {
        token = credentials.getSecret().getPlainText();
    }

    if (StringUtils.isNotEmpty(token)) {
        return MarathonClient
                .getInstanceWithTokenAuth(getURL(), token);
    }

    return getMarathonClient();
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
public static MarathonTestEnvironment createTestEnvironment(Strategy strategy) throws ResourceConfigException, ResourceException, IOException, EnvironmentConfigException {
    Map<String, String> environmentVariables = TestEnvironmentUtil.loadEnvironmentVariables(
            MARATHON_TOKEN_ENV,
            MARATHON_URL_ENV
    );

    EnvironmentConfig environmentConfig = createEnvironmentConfig(environmentVariables, strategy);

    // Replace the token.
    TokenResource tokenResource = new TokenResource(environmentConfig);
    String apiToken = tokenResource.retrieveAuthenticationToken(environmentVariables.get(MARATHON_TOKEN_ENV));
    environmentConfig.getAuthConfig().setToken(apiToken);

    ClientFactory clientFactory = createClientFactory(environmentConfig);

    Marathon marathonClient = createMarathonClient(environmentConfig);
    return new MarathonTestEnvironment(clientFactory, environmentConfig, marathonClient);
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
private void getAppTasks(Marathon marathon, App app) throws MojoExecutionException {
    try {
        final GetAppTasksResponse getAppTasksResponse = marathon.getAppTasks(app.getId());
        int taskCount = 0;
        for (final Task task : getAppTasksResponse.getTasks()) {
            final String hostPropertyName = propertyPrefix + "host" + taskCount;
            project.getProperties().put(hostPropertyName, task.getHost());
            getLog().info("Setting " + hostPropertyName + " = " + task.getHost());
            int portCount = 0;
            for (final Integer port : task.getPorts()) {
                final String portPropertyName = propertyPrefix + "port"
                        + taskCount + "-" + portCount;
                project.getProperties().put(portPropertyName, String.valueOf(port));
                getLog().info("Setting " + portPropertyName + " = " + port);
                portCount++;
            }
            taskCount++;
        }
    } catch (Exception deleteAppException) {
        throw new MojoExecutionException("Failed to get tasks for Marathon instance "
                + marathonHost, deleteAppException);
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    final Marathon marathon = MarathonClient.getInstance(marathonHost);
    App app = readApp(finalMarathonConfigFile);
    getLog().info("deploying Marathon config for " + app.getId()
            + " from " + finalMarathonConfigFile + " to " + marathonHost);
    if (appExists(marathon, app.getId())) {
        getLog().info(app.getId() + " already exists - will be updated");
        updateApp(marathon, app);
    } else {
        getLog().info(app.getId() + " does not exist yet - will be created");
        app = createApp(marathon, app);
    }

    if (waitForDeploymentFinished) {
        try {
            waitForApp(marathon, app);
        } catch (MarathonException e) {
            throw new MojoExecutionException("error waiting for app", e);
        }
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
/**
 * Generate a new Marathon client.
 * 
 * @param marathonProperties
 *          the properties containing the client information
 * @return the new client
 */
@Override
public Marathon build(MarathonProperties marathonProperties) {
  LOG.info("Generating Marathon client with parameters: {}", marathonProperties);

  return Feign
      .builder()
      .encoder(new GsonEncoder(ModelUtils.GSON))
      .decoder(new GsonDecoder(ModelUtils.GSON))
      .logger(new Slf4jLogger(Marathon.class))
      .logLevel(Level.FULL)
      .errorDecoder(new DeserializingMarathonErrorDecoder())
      .requestInterceptor(new BasicAuthRequestInterceptor(
          marathonProperties.getUsername(), marathonProperties.getPassword()))
      .requestInterceptor(template -> {
        template.header(HttpHeaders.ACCEPT, "application/json");
        template.header(HttpHeaders.CONTENT_TYPE, "application/json");
      })
      .target(Marathon.class, marathonProperties.getUrl().toString());
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Deprecated
// TODO remove it and use just getGroup with embed params (requires marathon client version >
// 6.0.0)
private Group getPolulatedGroup(Deployment deployment, String groupId) throws MarathonException {
  final Marathon client = getMarathonClient(deployment);
  Group group = client.getGroup(groupId);

  Collection<App> apps = Optional.ofNullable(group.getApps()).orElseGet(Collections::emptyList);

  List<App> completeInfoApps = new ArrayList<>();
  for (App app : apps) {
    completeInfoApps.add(client.getApp(app.getId()).getApp());
  }
  apps = completeInfoApps;

  group.setApps(apps);
  return group;
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
/**
 * The generalized version of the method that allows more in-depth customizations via
 * {@link RequestInterceptor}s.
 *
 * @param endpoint
 * 		URL of Marathon
 */
private static Marathon getInstance(String endpoint, RequestInterceptor... interceptors) {
	Builder b = Feign.builder()
			.encoder(new GsonEncoder(ModelUtils.GSON))
			.decoder(new GsonDecoder(ModelUtils.GSON))
			.errorDecoder(new MarathonErrorDecoder());

	if (interceptors!=null)
		b.requestInterceptors(asList(interceptors));

	b.requestInterceptor(new MarathonHeadersInterceptor());

	return b.target(Marathon.class, endpoint);
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public Marathon marathonClient(MarathonProperties properties) {
    return new RibbonMarathonClient.Builder(properties.getEndpoint())
            .withListOfServers(properties.getListOfServers())
            .withToken(properties.getToken())
            .withUsername(properties.getUsername())
            .withPassword(properties.getPassword())
            .build();
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
public MarathonServerList(Marathon client, MarathonDiscoveryProperties properties) {
    this.client = client;
    this.properties = properties;
    this.queryMap = new HashMap<>();
    this.ignoreServiceId = false;
    metaDataFilter = new HashMap<>();
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Autowired
public MarathonRibbonClientConfiguration(Marathon client,
                                         IClientConfig clientConfig,
                                         MarathonDiscoveryProperties properties) {
    this.client = client;
    this.clientConfig = clientConfig;
    this.properties = properties;
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Bean
public Marathon marathonClient(MarathonProperties properties) throws MarathonException {
    Marathon client = mock(Marathon.class);

    when(client.getServerInfo()).thenReturn(new GetServerInfoResponse());

    GetAppsResponse appsResponse = new GetAppsResponse();
    App app = new App();
    app.setId("test-app");
    appsResponse.setApps(Collections.singletonList(app));
    when(client.getApps()).thenReturn(appsResponse);

    return client;
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Bean
@RefreshScope
public Marathon marathon(MarathonAppDeployerProperties marathonProperties, DcosClusterProperties dcosClusterProperties) {
	if (StringUtils.hasText(dcosClusterProperties.getAuthorizationToken())) {
		return MarathonClient.getInstance(marathonProperties.getApiEndpoint(),
				new DcosHeadersInterceptor(dcosClusterProperties.getAuthorizationToken()));
	}
	else {
		return MarathonClient.getInstance(marathonProperties.getApiEndpoint());
	}
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Bean
public Marathon marathon(MarathonAppDeployerProperties marathonProperties,
                         DcosClusterProperties dcosClusterProperties) {
	if (StringUtils.hasText(dcosClusterProperties.getAuthorizationToken())) {
		return MarathonClient.getInstance(marathonProperties.getApiEndpoint(),
				new DcosHeadersInterceptor(dcosClusterProperties.getAuthorizationToken()));
	}
	else {
		return MarathonClient.getInstance(marathonProperties.getApiEndpoint());
	}
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
private static Marathon getInstance(String endpoint, RequestInterceptor... interceptors) {
    Feign.Builder b = Feign.builder().client(LoginClient.getClientHostVerificationDisabled())
            .logger(new Logger.ErrorLogger())
            .logLevel(Logger.Level.BASIC)
            .encoder(new GsonEncoder(ModelUtils.GSON))
            .decoder(new GsonDecoder(ModelUtils.GSON))
            .errorDecoder(new MarathonErrorDecoder())
            //max wait period = 5 seconds ; max attempts = 5
            .retryer(new Retryer.Default(SECONDS.toMillis(1), SECONDS.toMillis(5), 5));
    if (interceptors != null) {
        b.requestInterceptors(asList(interceptors));
    }
    b.requestInterceptor(new MarathonHeadersInterceptor());
    return b.target(Marathon.class, endpoint);
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
protected boolean appExists(Marathon marathon, String appId) throws MojoExecutionException {
    try {
        marathon.getApp(trimLeadingSlash(appId));
        return true;
    } catch (MarathonException getAppException) {
        if (getAppException.getStatus() == 404) {
            return false;
        } else {
            throw new MojoExecutionException("Failed to check if an app " + appId + "exists",
                    getAppException);
        }
    } catch (Exception e) {
        throw new MojoExecutionException("Failed to check if an app " + appId + "exists", e);
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    final Marathon marathon = MarathonClient.getInstance(marathonHost);
    final App app = readApp(finalMarathonConfigFile);
    getLog().info("deleting Marathon instance for " + app.getId());
    if (appExists(marathon, app.getId())) {
        getLog().info(app.getId() + " already exists - will be updated");
        deleteApp(marathon, app);
    } else {
        getLog().warn(app.getId() + " does not exist - nothing to delete");
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
private void deleteApp(Marathon marathon, App app) throws MojoExecutionException {
    try {
        marathon.deleteApp(app.getId());
    } catch (Exception deleteAppException) {
        throw new MojoExecutionException("Failed to delete Marathon instance "
                + marathonHost, deleteAppException);
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    final Marathon marathon = MarathonClient.getInstance(marathonHost);
    final App app = readApp(finalMarathonConfigFile);
    getLog().info("tasks in Marathon instance for " + app.getId());

    final ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
    final Callable<Void> callable = () -> {
        try {
            if (appExists(marathon, app.getId())) {
                getLog().info(app.getId() + " exists - getting app tasks");
                getAppTasks(marathon, app);
            } else {
                getLog().warn(app.getId() + " does not exist");
            }
        } catch (final MojoExecutionException e) {
            getLog().error("Problem communicating with Marathon", e);
        }
        return null;
    };
    final ScheduledFuture<Void> future = executor.schedule(callable, delay, TimeUnit.SECONDS);
    while (!future.isDone() && !future.isCancelled()) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException ignored) { }
    }
}
 

import mesosphere.marathon.client.Marathon; //导入依赖的package包/类
private void updateApp(Marathon marathon, App app) throws MojoExecutionException {
    try {
        marathon.updateApp(trimLeadingSlash(app.getId()), app, false);
    } catch (Exception updateAppException) {
        throw new MojoExecutionException("Failed to update Marathon config file at "
                + marathonHost, updateAppException);
    }
}