Java PackageConfiguration类代码示例

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的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.PackageConfiguration; //导入依赖的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.PackageConfiguration; //导入依赖的package包/类
@Override
@EntryPoint
public PackageConfiguration getPackageConfiguration() {
    PackageConfiguration packageConfig = new PackageConfiguration();
    packageConfig.add(property(MODULE_NAME)
            .withDisplayName("Module Name")
            .withPartOfIdentity(true)
            .withDisplayOrder(0)
            .build());
    packageConfig.add(property(LOWER_VERSION_BOUND_INCLUSIVE)
            .withRequired(false)
            .withDisplayName("Version to poll >=")
            .withPartOfIdentity(false)
            .withDisplayOrder(1)
            .build());
    packageConfig.add(property(UPPER_VERSION_BOUND_EXCLUSIVE)
            .withRequired(false)
            .withDisplayName("Version to poll <")
            .withPartOfIdentity(false)
            .withDisplayOrder(2)
            .build());
    return packageConfig;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的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.PackageConfiguration; //导入依赖的package包/类
private JSONArray jsonForTagsForRepository(PackageConfiguration packageConfiguration) {
    DefaultHttpClient client = new DefaultHttpClient();

    try {
        String urlForTags = MessageFormat.format("https://{0}/v1/repositories/{1}/tags",
                repositoryConfiguration.get("REGISTRY_URL").getValue(),
                packageConfiguration.get("REPOSITORY_NAME").getValue());
        HttpGet google = new HttpGet(urlForTags);
        HttpResponse response = client.execute(google);
        String jsonString = EntityUtils.toString(response.getEntity());
        return new JSONObject("{\"tags\":" + jsonString + "}").getJSONArray("tags");
    } catch (IOException e) {
        e.printStackTrace();
    }

    return null;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的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.PackageConfiguration; //导入依赖的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.PackageConfiguration; //导入依赖的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.PackageConfiguration; //导入依赖的package包/类
@Test
public void shouldGetPackageConfiguration() {
    PackageConfiguration configurations = pluginConfig.getPackageConfiguration();
    assertNotNull(configurations.get(PACKAGE_PATH));
    assertThat(configurations.get(PACKAGE_PATH).getOption(DISPLAY_NAME), is("Package Path"));
    assertThat(configurations.get(PACKAGE_PATH).getOption(DISPLAY_ORDER), is(1));
    assertNotNull(configurations.get(PACKAGE_ID));
    assertThat(configurations.get(PACKAGE_ID).getOption(DISPLAY_NAME), is("Package Id"));
    assertThat(configurations.get(PACKAGE_ID).getOption(DISPLAY_ORDER), is(2));
    assertNotNull(configurations.get(POLL_VERSION_FROM));
    assertThat(configurations.get(POLL_VERSION_FROM).getOption(DISPLAY_NAME), is("Version to poll >="));
    assertThat(configurations.get(POLL_VERSION_FROM).getOption(DISPLAY_ORDER), is(3));
    assertThat(configurations.get(POLL_VERSION_FROM).getOption(REQUIRED), is(false));
    assertNotNull(configurations.get(POLL_VERSION_TO));
    assertThat(configurations.get(POLL_VERSION_TO).getOption(DISPLAY_NAME), is("Version to poll <"));
    assertThat(configurations.get(POLL_VERSION_TO).getOption(DISPLAY_ORDER), is(4));
    assertThat(configurations.get(POLL_VERSION_TO).getOption(REQUIRED), is(false));
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的package包/类
@Test
public void shouldGetPackageConfiguration() {
    PackageConfiguration configurations = debRepositoryConfiguration.getPackageConfiguration();
    assertThat(configurations.get(PACKAGE_NAME), is(notNullValue()));
    assertThat(configurations.get(Constants.PACKAGE_NAME).getOption(Property.SECURE), is(false));
    assertThat(configurations.get(Constants.PACKAGE_NAME).getOption(Property.PART_OF_IDENTITY), is(true));
    assertThat(configurations.get(Constants.PACKAGE_NAME).getOption(Property.REQUIRED), is(true));
    assertThat(configurations.get(Constants.PACKAGE_NAME).getOption(Property.DISPLAY_NAME), is("Debian Package Name"));
    assertThat(configurations.get(Constants.PACKAGE_NAME).getOption(Property.DISPLAY_ORDER), is(0));
    assertThat(configurations.get(VERSION_SPEC), is(notNullValue()));
    assertThat(configurations.get(Constants.VERSION_SPEC).getOption(Property.SECURE), is(false));
    assertThat(configurations.get(Constants.VERSION_SPEC).getOption(Property.PART_OF_IDENTITY), is(true));
    assertThat(configurations.get(Constants.VERSION_SPEC).getOption(Property.REQUIRED), is(false));
    assertThat(configurations.get(Constants.VERSION_SPEC).getOption(Property.DISPLAY_NAME), is("Version Spec"));
    assertThat(configurations.get(Constants.VERSION_SPEC).getOption(Property.DISPLAY_ORDER), is(1));
    assertThat(configurations.get(ARCHITECTURE), is(notNullValue()));
    assertThat(configurations.get(Constants.ARCHITECTURE).getOption(Property.SECURE), is(false));
    assertThat(configurations.get(Constants.ARCHITECTURE).getOption(Property.PART_OF_IDENTITY), is(true));
    assertThat(configurations.get(Constants.ARCHITECTURE).getOption(Property.REQUIRED), is(false));
    assertThat(configurations.get(Constants.ARCHITECTURE).getOption(Property.DISPLAY_NAME), is("Architecture"));
    assertThat(configurations.get(Constants.ARCHITECTURE).getOption(Property.DISPLAY_ORDER), is(2));
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的package包/类
@Test
public void shouldFailValidationIfSpuriousPropertiesAreConfigured() {
    ValidationResult validationResult = new ValidationResult();
    PackageConfiguration packageConfigurations = new PackageConfiguration();
    RepositoryConfiguration repositoryConfiguration = new RepositoryConfiguration();
    packageConfigurations.add(new PackageMaterialProperty("PACKAGE_NAME", "foo"));
    packageConfigurations.add(new PackageMaterialProperty("foo1", "foo"));
    packageConfigurations.add(new PackageMaterialProperty("foo2", "foo"));
    repositoryConfiguration.add(new PackageMaterialProperty("bar1", "bar"));
    repositoryConfiguration.add(new PackageMaterialProperty("bar2", "bar"));
    repositoryConfiguration.add(new PackageMaterialProperty("REPO_URL", "http://asdsa"));
    new DebRepositoryConfiguration().validate(packageConfigurations, repositoryConfiguration, validationResult);
    assertThat(validationResult.isSuccessful(), is(false));
    assertThat(validationResult.getErrors().contains(new ValidationError("", "Unsupported key(s) found : bar1, bar2. Allowed key(s) are : REPO_URL")), is(true));
    assertThat(validationResult.getErrors().contains(new ValidationError("", "Unsupported key(s) found : foo1, foo2. Allowed key(s) are : PACKAGE_NAME, VERSION_SPEC, ARCHITECTURE")), is(true));
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的package包/类
@Test
public void shouldThrowExceptionGivenEmptyRepo_getLatestRevision() throws Exception {
    RepositoryConfiguration repositoryPackageConfigurations = new RepositoryConfiguration();
    File emptyRepo = new File(getClass().getResource("/repos/emptyrepo").toURI());
    repositoryPackageConfigurations.add(new PackageMaterialProperty(Constants.REPO_URL, "file://" + emptyRepo.getAbsolutePath()));
    PackageConfiguration packagePackageConfigurations = new PackageConfiguration();
    packagePackageConfigurations.add(new PackageMaterialProperty(Constants.PACKAGE_NAME, "crap-artifact"));
    try {
        poller.getLatestRevision(packagePackageConfigurations, repositoryPackageConfigurations);
        fail("");
    } catch (RuntimeException e) {
        String expectedMessage = "Invalid file path.";
        String actualMessage = e.getMessage();
        assertThat(actualMessage.startsWith(expectedMessage), is((true)));
    }
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的package包/类
@Override
public PackageConfiguration getPackageConfiguration() {
    LOGGER.debug("getPackageConfiguration called.");
    PackageConfiguration packageConfig = new PackageConfiguration();

    packageConfig.add(space);
    packageConfig.add(appName);
    packageConfig.add(orgName);
    return packageConfig;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的package包/类
@Override
public Result checkConnectionToPackage(PackageConfiguration packageConfiguration, RepositoryConfiguration repositoryConfiguration) {
    CloudFoundryClient client = getClient(repositoryConfiguration);

    Result result = new Result();

    final String appNamePrefix = packageConfiguration.get("APP_NAME").getValue();
        if (lookupAppNames(client, appNamePrefix).isEmpty()) {
            LOGGER.warn("No app found.");
            result = ExecutionResult.failure("No such app found in CloudFoundry.");
        }

    return result;
}
 

import com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration; //导入依赖的package包/类
public PackageRevision getLatestRevision(PackageConfiguration packageConfig, RepositoryConfiguration repoConfig) {
    LOGGER.info(String.format("getLatestRevision called with packageId %s, for repo: %s",
            packageConfig.get(NpmPackageConfig.PACKAGE_ID).getValue(), repoConfig.get(RepoUrl.REPO_URL).getValue()));
    validateConfig(repoConfig, packageConfig);
    NpmPackageConfig npm = new NpmPackageConfig(packageConfig);
    NpmParams params = new NpmParams(
            new NpmRepoConfig(repoConfig).getRepoUrl(),
            npm.getPackageId(),
            npm.getPollVersionFrom(),
            npm.getPollVersionTo(), null);
    PackageRevision packageRevision = poll(params);
    LOGGER.info(String.format("getLatestRevision returning with %s, %s",
            packageRevision.getRevision(), packageRevision.getTimestamp()));
    return packageRevision;
}