Java RepositoryConfiguration类代码示例

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Override
public PackageRevision latestModificationSince(PackageConfiguration packageConfiguration,
                                               RepositoryConfiguration repositoryConfiguration,
                                               PackageRevision previouslyKnownRevision) {
    LOGGER.debug("latestModificationSince called with previous revision " + previouslyKnownRevision);

    PackageRevision latestRevision = getLatestRevision(packageConfiguration, repositoryConfiguration);

    if (latestRevision != null &&
            latestRevision.getTimestamp().after(previouslyKnownRevision.getTimestamp()))
    {
        LOGGER.info("Latest revision later than previous known.");
        return latestRevision;
    } else {
        return previouslyKnownRevision;
    }
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
private CloudFoundryClient getClient(RepositoryConfiguration repositoryConfiguration) {
    String api = repositoryConfiguration.get("REPO_URL").getValue();
    String username = repositoryConfiguration.get("USERNAME").getValue();
    String password = repositoryConfiguration.get("PASSWORD").getValue();

    LOGGER.debug("Cloud Foundry connection details: api: " + api + ", username " + username);

    ConnectionContext connectionContext = DefaultConnectionContext.builder()
            .apiHost(api)
            .skipSslValidation(true)
            .build();

    ReactorCloudFoundryClient client = ReactorCloudFoundryClient.builder()
            .connectionContext(connectionContext)
            .tokenProvider(PasswordGrantTokenProvider.builder()
                    .username(username)
                    .password(password)
                    .build())
            .build();

    return client;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
public PackageRevision latestModificationSince(PackageConfiguration packageConfig, RepositoryConfiguration repoConfig, PackageRevision previouslyKnownRevision) {
    LOGGER.info(String.format("latestModificationSince called with packageId %s, for repo: %s",
            packageConfig.get(NpmPackageConfig.PACKAGE_ID).getValue(), repoConfig.get(RepoUrl.REPO_URL).getValue()));
    validateConfig(repoConfig, packageConfig);
    NpmPackageConfig npmPackageConfig = new NpmPackageConfig(packageConfig);
    NpmParams params = new NpmParams(
            new NpmRepoConfig(repoConfig).getRepoUrl(),
            npmPackageConfig.getPackageId(),
            npmPackageConfig.getPollVersionFrom(),
            npmPackageConfig.getPollVersionTo(),
            previouslyKnownRevision);
    PackageRevision updatedPackage = poll(params);
    if (updatedPackage == null) {
        LOGGER.info(String.format("no modification since %s", previouslyKnownRevision.getRevision()));
        return null;
    }
    LOGGER.info(String.format("latestModificationSince returning with %s, %s",
            updatedPackage.getRevision(), updatedPackage.getTimestamp()));
    if (updatedPackage.getTimestamp().getTime() < previouslyKnownRevision.getTimestamp().getTime())
        LOGGER.warn(String.format("Updated Package %s published earlier (%s) than previous (%s, %s)",
                updatedPackage.getRevision(), updatedPackage.getTimestamp(), previouslyKnownRevision.getRevision(), previouslyKnownRevision.getTimestamp()));
    return updatedPackage;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Override
public Result checkConnectionToRepository(RepositoryConfiguration repoConfigs) {
    Result response = new Result();
    NpmRepoConfig npmRepoConfig = new NpmRepoConfig(repoConfigs);
    RepoUrl repoUrl = npmRepoConfig.getRepoUrl();
    if (repoUrl.isHttp()) {
        try {
            repoUrl.checkConnection(((HttpRepoURL) repoUrl).getUrlStrWithTrailingSlash());
        } catch (Exception e) {
            response.withErrorMessages(e.getMessage());
        }
    } else {
        repoUrl.checkConnection();
    }
    LOGGER.info(response.getMessagesForDisplay());
    return response;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Test
public void shouldGetRepositoryConfiguration() {
    RepositoryConfiguration configurations = pluginConfig.getRepositoryConfiguration();
    assertThat(configurations.get(RepoUrl.REPO_URL), is(notNullValue()));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(SECURE), is(false));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(REQUIRED), is(true));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(DISPLAY_NAME), is("Npm server API root"));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(DISPLAY_ORDER), is(0));
    assertThat(configurations.get(RepoUrl.USERNAME), is(notNullValue()));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(SECURE), is(false));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(REQUIRED), is(false));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(DISPLAY_NAME), is("UserName"));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(DISPLAY_ORDER), is(1));
    assertThat(configurations.get(RepoUrl.PASSWORD), is(notNullValue()));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(SECURE), is(true));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(REQUIRED), is(false));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(DISPLAY_NAME), is("Password"));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(DISPLAY_ORDER), is(2));
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Override
@EntryPoint
public ValidationResult isRepositoryConfigurationValid(RepositoryConfiguration repositoryConfiguration) {
    SaferConfiguration configuration = new SaferConfiguration(repositoryConfiguration);
    String forgeUrl = configuration.get(FORGE_URL);
    LOG.info("Validating configuration for forge (URL = %s)", forgeUrl);

    ValidationResult validationResult = new ValidationResult();
    if (forgeUrl.isEmpty()) {
        validationResult.addError(new ValidationError(FORGE_URL, "Forge URL is mandatory"));
    } else {
        try {
            URL url = new URL(forgeUrl);
            if (!url.getProtocol().matches("^https?$")) {
                validationResult.addError(new ValidationError(FORGE_URL, "Forge URL must be an HTTP(S) URL"));
            }
        } catch (MalformedURLException e) {
            validationResult.addError(new ValidationError(FORGE_URL, "Forge URL must be a URL"));
        }
    }
    return validationResult;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Override
@EntryPoint
public PackageRevision latestModificationSince(PackageConfiguration packageConfiguration, RepositoryConfiguration repositoryConfiguration, PackageRevision lastKnownRevision) {
    ModuleSpec module = moduleSpecFactory.build(packageConfiguration);
    Forge forge = forgeFactory.build(repositoryConfiguration);
    Version lastKnownReleaseVersion = Version.of(lastKnownRevision.getRevision());

    LOG.info("Looking up latest release of module %s in forge %s since version %s", module, forge, lastKnownReleaseVersion);
    try {
        ModuleVersion latestRelease = forge.getLatestVersion(module);
        if (latestRelease.getVersion().isGreaterThan(lastKnownReleaseVersion)) {
            //TODO: warn if this release is earlier than lastKnownRevision
            return latestRelease.toPackageRevision();
        } else {
            return null;
        }
    } catch (Forge.ModuleNotFound moduleNotFound) {
        LOG.info("Module %s not found in forge %s: %s", module, forge, moduleNotFound);
        return null;
    }
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
/**
 * Check the validation of the fields and then check the real connection
 *
 * @param repositoryConfiguration
 * @return
 */
@Override
public Result checkConnectionToRepository(
        final RepositoryConfiguration repositoryConfiguration) {

    Result result = this.validateRepository(repositoryConfiguration);
    if (!result.isSuccessful()) {
        return result;
    }

    DockerRegistry instance = DockerRegistry.getInstance(repositoryConfiguration);

    try {
        instance.checkConnection();
        result = new Result().withSuccessMessages(String.format("Successfully connected to %s", instance.getUrl()));
    } catch (Exception e) {
        LOG.warn(String.format("Check connection for %s failed with exception - %s", instance.getUrl(), e));
        result = new Result().withErrorMessages(String.format("Check connection failed for %s", instance.getUrl()));
    }

    return result;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
/**
 * Check if the package is valid.
 *
 * @param packageConfiguration
 * @param repositoryConfiguration
 * @return
 */
@Override
public Result checkConnectionToPackage(
        final PackageConfiguration packageConfiguration, 
        final RepositoryConfiguration repositoryConfiguration) {
    
    Result checkConnectionResult = this.checkConnectionToRepository(repositoryConfiguration);
    if (!checkConnectionResult.isSuccessful()) {
        return checkConnectionResult;
    }

    try {
        Result packageConfigurationValidationResult = packageValidation(packageConfiguration, repositoryConfiguration);
        if (!packageConfigurationValidationResult.isSuccessful()) {
            return packageConfigurationValidationResult;
        }

        PackageRevision latestRevision = this.getLatestRevision(packageConfiguration, repositoryConfiguration);
        return new Result().withSuccessMessages(String.format("Found package '%s'.", latestRevision.getRevision()));
    } catch (Exception e) {
        String message = String.format("Could not find any package that matched '%s'.", packageConfiguration.get(Constants.REPOSITORY).getValue());
        LOG.warn(message);
        return new Result().withErrorMessages(message);
    }
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
/**
 * Validate the data of both configuration.
 * 
 * @param repositoryConfigurations
 * @param packageConfigurations 
 */
private void validateData(
        final RepositoryConfiguration repositoryConfigurations, 
        final PackageConfiguration packageConfigurations) {
    
    ValidationResult validationResult = new ValidationResult();
    new DockerMaterialConfiguration().validate(packageConfigurations, repositoryConfigurations, validationResult);
    if (!validationResult.isSuccessful()) {
        StringBuilder stringBuilder = new StringBuilder();
        for (ValidationError validationError : validationResult.getErrors()) {
            stringBuilder.append(validationError.getMessage()).append("; ");
        }
        String errorString = stringBuilder.toString();
        String message = errorString.substring(0, errorString.length() - 2);
        LOG.warn(String.format("Data validation failed: %s", message));
        throw new RuntimeException(message);
    }
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
/**
 * Check the validity of the supplied repository fields. It does a syntax
 * check. It does not check if the repository is available. It checks if the
 * repository contains unwanted fields.
 *
 * NOTE: A package in Go is the repository from Docker.
 *
 * @param repositoryConfiguration
 * @return ValidationResult
 */
@Override
public ValidationResult isRepositoryConfigurationValid(
        final RepositoryConfiguration repositoryConfiguration) {

    LOG.info("Validating repository: " + repositoryConfiguration.get(Constants.REGISTRY).getValue());
    ValidationResult validationResult = new ValidationResult();
    this.validateKeys(getRepositoryConfiguration(), repositoryConfiguration, validationResult);

    Property registry = repositoryConfiguration.get(Constants.REGISTRY);
    if (registry == null) {
        validationResult.addError(new ValidationError(Constants.REGISTRY, "Registry url not specified"));
        return validationResult;
    }

    DockerRegistry.getInstance(registry.getValue()).validate(validationResult);
    return validationResult;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
public PackageRevision getLatestRevision(PackageConfiguration packageConfig, RepositoryConfiguration repoConfig) {
    LOGGER.info(String.format("getLatestRevision called with packageName %s, for repo: %s",
            packageConfig.get(GenericArtifactoryPackageConfig.PACKAGE_ID).getValue(), repoConfig.get(RepoUrl.REPO_URL).getValue()));

    validateConfig(repoConfig, packageConfig);

    GenericArtifactoryPackageConfig artifactoryPackageConfig = new GenericArtifactoryPackageConfig(packageConfig);
    GenericArtifactoryRepoConfig artifactoryRepoConfig = new GenericArtifactoryRepoConfig(repoConfig);

    GenericArtifactoryParams params = GenericArtifactoryParams.createFrom(
            artifactoryRepoConfig.getRepoUrl(),
            artifactoryPackageConfig,
            null);

    PackageRevision packageRevision = poll(params);

    LOGGER.info(String.format("getLatestRevision returning with %s, %s",
            packageRevision.getRevision(),
            packageRevision.getTimestamp()));

    return packageRevision;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Override
public Result checkConnectionToRepository(RepositoryConfiguration repoConfigs) {
    Result response = new Result();
    GenericArtifactoryRepoConfig genericArtifactoryRepoConfig = new GenericArtifactoryRepoConfig(repoConfigs);
    RepoUrl repoUrl = genericArtifactoryRepoConfig.getRepoUrl();
    if (repoUrl.isHttp()) {
        try {
            repoUrl.checkConnection(((HttpRepoURL) repoUrl).getUrlStrWithTrailingSlash());
        } catch (Exception e) {
            response.withErrorMessages(e.getMessage());
        }
    } else {
        repoUrl.checkConnection();
    }
    LOGGER.info(response.getMessagesForDisplay());
    return response;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Test
public void shouldGetRepositoryConfiguration() {
    RepositoryConfiguration configurations = pluginConfig.getRepositoryConfiguration();
    assertThat(configurations.get(RepoUrl.REPO_URL), is(notNullValue()));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(SECURE), is(false));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(REQUIRED), is(true));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(DISPLAY_NAME), is("Artifactory server API root"));
    assertThat(configurations.get(RepoUrl.REPO_URL).getOption(DISPLAY_ORDER), is(0));
    assertThat(configurations.get(RepoUrl.USERNAME), is(notNullValue()));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(SECURE), is(false));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(REQUIRED), is(false));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(DISPLAY_NAME), is("UserName"));
    assertThat(configurations.get(RepoUrl.USERNAME).getOption(DISPLAY_ORDER), is(1));
    assertThat(configurations.get(RepoUrl.PASSWORD), is(notNullValue()));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(SECURE), is(true));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(REQUIRED), is(false));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(DISPLAY_NAME), is("Password"));
    assertThat(configurations.get(RepoUrl.PASSWORD).getOption(DISPLAY_ORDER), is(2));
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.RepositoryConfiguration; //导入依赖的package包/类
@Test
public void shouldConstructPackageConfigurationFromApiRepositoryConfiguration() throws Exception {

    RepositoryConfiguration configuration = new RepositoryConfiguration();
    configuration.add(new PackageMaterialProperty("k1", "v1").with(Property.SECURE, Boolean.TRUE));

    PackageConfigurations packageConfigurations = new PackageConfigurations(configuration);
    assertThat(packageConfigurations.list().size(), is(1));
    assertThat(packageConfigurations.list().get(0).getKey(), is("k1"));
    assertThat(packageConfigurations.list().get(0).getValue(), is("v1"));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.REQUIRED), is(true));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.PART_OF_IDENTITY), is(true));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.SECURE), is(true));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.DISPLAY_NAME), is(""));
    assertThat(packageConfigurations.list().get(0).getOption(PackageConfiguration.DISPLAY_ORDER), is(0));
}