mesosphere.marathon.client.Marathon Java Examples

/**
 * 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();
}
 

/**
 * 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());
    }
}
 

@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();
}
 

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);
}
 

@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());
	}
}
 

@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());
	}
}
 

@Bean
public Marathon marathonClient(MarathonProperties properties) throws MarathonException {
    Marathon client = mock(Marathon.class);

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

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

    return client;
}
 

@Autowired
public MarathonRibbonClientConfiguration(Marathon client,
                                         IClientConfig clientConfig,
                                         MarathonDiscoveryProperties properties) {
    this.client = client;
    this.clientConfig = clientConfig;
    this.properties = properties;
}
 

public MarathonServerList(Marathon client, MarathonDiscoveryProperties properties) {
    this.client = client;
    this.properties = properties;
    this.queryMap = new HashMap<>();
    this.ignoreServiceId = false;
    metaDataFilter = new HashMap<>();
}
 

@Autowired
public MarathonEndpoint(Marathon marathon) {
    this.marathon = marathon;
}
 

@Test
public void testExternalVolumes() throws Exception {
    final MockWebServer server = new MockWebServer();
    final String mockResponse = "{\"container\": {\"volumes\": [" +
            "{\"containerPath\":\"/data/db\",\"mode\":\"RW\",\"external\":" +
            "{\"name\":\"mongodb-testvol\",\"provider\":\"dvdi\",\"options\":" +
            "{\"dvdi/driver\":\"rexray\"}}}]}}";

    try {
        server.enqueue(new MockResponse().setBody(mockResponse));
        server.start();
        Marathon client = MarathonClient.getInstance(server.url("/").toString());

        App app = new App();
        app.setId("mongo");
        app.setCpus(1.0);
        app.setMem(256.0);
        app.setContainer(new Container());
        app.getContainer().setDocker(new Docker());
        app.getContainer().getDocker().setImage("mongo");
        app.getContainer().setVolumes(new ArrayList<Volume>());

        ExternalVolume externalVolume = new ExternalVolume();
        externalVolume.setName("mongodb-testvol");
        externalVolume.setMode("RW");
        externalVolume.setContainerPath("/data/db");
        externalVolume.setProvider("dvdi");
        externalVolume.setDriver("rexray");

        app.getContainer().getVolumes().add(externalVolume);

        final App appRes = client.createApp(app);
        assertFalse(appRes.getContainer().getVolumes().isEmpty());

        ExternalVolume responseVolume = (ExternalVolume) appRes.getContainer().getVolumes().iterator().next();
        assertEquals("mongodb-testvol", responseVolume.getExternalVolumeInfo().getName());

        RecordedRequest request = server.takeRequest();
        assertNotNull(request);

        final String requestBody = request.getBody().readUtf8();
        assertNotNull(requestBody);

        // request to JSON
        JsonObject requestPayload = new Gson().fromJson(requestBody, JsonObject.class);
        assertNotNull(requestPayload);
        JsonObject requestVolume = requestPayload.getAsJsonObject("container").getAsJsonArray("volumes").get(0).getAsJsonObject();
        assertNotNull(requestVolume);
        assertEquals("RW", requestVolume.get("mode").getAsString());
        assertEquals("/data/db", requestVolume.get("containerPath").getAsString());
    } finally {
        server.shutdown();
    }
}
 

private static Marathon createMarathonClient() {
    String token = LoginClient.getAuthToken(LOGIN_URL);
    return getInstance(ENDPOINT, new TokenAuthRequestInterceptor(token));
}
 

public static Marathon getClient() {
    return createMarathonClient();
}
 

@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(value = "spring.cloud.discovery.client.marathon.health-indicator.enabled", matchIfMissing = true )
public MarathonHealthIndicator healthIndicator(Marathon client) {
    return new MarathonHealthIndicator(client);
}
 

@Override
protected void obtainResource() throws Exception {
	context = new SpringApplicationBuilder(Config.class).web(false).run();
	resource = context.getBean(Marathon.class);
	resource.getServerInfo();
}
 

@Bean
@RefreshScope
public AppDeployer appDeployer(MarathonAppDeployerProperties marathonProperties, Marathon marathon) {
	return new MarathonAppDeployer(marathonProperties, marathon);
}
 

@Bean
@ConditionalOnMissingBean
public MarathonEndpoint marathonEndpoint(Marathon client) {
    return new MarathonEndpoint(client);
}
 

@Autowired
public MarathonAppDeployer(MarathonAppDeployerProperties properties,
                           Marathon marathon) {
	this.properties = properties;
	this.marathon = marathon;
}
 

@Bean
public Marathon marathonClient(MarathonProperties properties) {
    return mock(Marathon.class);
}
 

@Bean
public Marathon marathonClient(MarathonProperties properties) {
    return mock(Marathon.class);
}
 

public MarathonDiscoveryClient(Marathon client) {
    this.client = client;
}
 

@Bean
public Marathon marathonClient(MarathonProperties properties) {
    return mock(Marathon.class, withSettings().defaultAnswer(Answers.RETURNS_MOCKS.get()));
}
 

public MarathonHealthIndicator(Marathon client) {
    this.client = client;
}
 

/**
 * Get a default Marathon client. This does not include any authentication headers.
 *
 * @return Marathon client without authentication mechanisms
 */
private Marathon getMarathonClient() {
    return MarathonClient.getInstance(getURL());
}
 

/**
 * Get a Marathon client with basic auth using the username and password within the provided credentials.
 *
 * @param credentials Username and password credentials
 * @return Marathon client with basic authentication filled in
 */
private Marathon getMarathonClient(UsernamePasswordCredentials credentials) {
    return MarathonClient
            .getInstanceWithBasicAuth(getURL(), credentials.getUsername(), credentials.getPassword().getPlainText());
}