import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的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.response.Result; //导入依赖的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.response.Result; //导入依赖的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.response.Result; //导入依赖的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.response.Result; //导入依赖的package包/类
@Test
public void shouldPerformCheckConnectionOnPlugin() throws Exception {
    String pluginId = "yum";
    PackageRepository packageRepository = packageRepository(pluginId);
    HttpLocalizedOperationResult result = new HttpLocalizedOperationResult();

    PackageRepositoryService service = new PackageRepositoryService(pluginManager, packageRepositoryExtension, goConfigService, securityService, entityHashingService, localizer);

    ArgumentCaptor<RepositoryConfiguration> argumentCaptor = ArgumentCaptor.forClass(RepositoryConfiguration.class);
    when(packageRepositoryExtension.checkConnectionToRepository(eq(pluginId), argumentCaptor.capture())).thenReturn(new Result().withSuccessMessages("Accessed Repo File!!!"));

    service.checkConnection(packageRepository, result);

    RepositoryConfiguration packageConfigurations = argumentCaptor.getValue();
    PackageMaterialTestHelper.assertPackageConfiguration(packageConfigurations.list(), packageRepository.getConfiguration());
    assertThat(result.isSuccessful(), is(true));
    when(localizer.localize("CONNECTION_OK", "Accessed Repo File!!!")).thenReturn("success_msg");
    assertThat(result.message(localizer), is("success_msg"));
    verify(packageRepositoryExtension).checkConnectionToRepository(eq(pluginId),any(RepositoryConfiguration.class));
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldPopulateErrorsForCheckConnectionOnPlugin() throws Exception {
    String pluginId = "yum";
    PackageRepository packageRepository = packageRepository(pluginId);
    HttpLocalizedOperationResult result = new HttpLocalizedOperationResult();
    PackageRepositoryService service = new PackageRepositoryService(pluginManager, packageRepositoryExtension, goConfigService, securityService, entityHashingService, localizer);

    ArgumentCaptor<RepositoryConfiguration> argumentCaptor = ArgumentCaptor.forClass(RepositoryConfiguration.class);

    when(packageRepositoryExtension.checkConnectionToRepository(eq(pluginId),argumentCaptor.capture())).thenReturn(new Result().withErrorMessages("Repo invalid!!", "Could not connect"));
    service.checkConnection(packageRepository, result);

    RepositoryConfiguration packageConfigurations = argumentCaptor.getValue();
    PackageMaterialTestHelper.assertPackageConfiguration(packageConfigurations.list(), packageRepository.getConfiguration());
    assertThat(result.isSuccessful(), is(false));

    when(localizer.localize("CHECK_CONNECTION_FAILED", "package repository","Repo invalid!!\nCould not connect")).thenReturn("error_msg");
    assertThat(result.message(localizer), is("error_msg"));
    verify(packageRepositoryExtension).checkConnectionToRepository(eq(pluginId),any(RepositoryConfiguration.class));

}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldNotifyInterestedPluginsCorrectly() throws Exception {
    Result result = new Result();
    result.withSuccessMessages("success message");
    when(notificationPluginRegistry.getPluginsInterestedIn(PIPELINE_STATUS)).thenReturn(new LinkedHashSet<>(asList(PLUGIN_ID_1, PLUGIN_ID_2)));
    when(notificationPluginRegistry.getPluginsInterestedIn(STAGE_STATUS)).thenReturn(new LinkedHashSet<>(asList(PLUGIN_ID_3)));

    when(notificationExtension.notify(PLUGIN_ID_1, PIPELINE_STATUS, REQUEST_BODY)).thenReturn(result);
    when(notificationExtension.notify(PLUGIN_ID_2, PIPELINE_STATUS, REQUEST_BODY)).thenReturn(result);

    PluginNotificationService pluginNotificationService = new PluginNotificationService(notificationExtension, notificationPluginRegistry, serverHealthService);
    pluginNotificationService.notifyPlugins(new PluginNotificationMessage(PIPELINE_STATUS, REQUEST_BODY));

    verify(notificationExtension).notify(PLUGIN_ID_1, PIPELINE_STATUS, REQUEST_BODY);
    verify(notificationExtension).notify(PLUGIN_ID_2, PIPELINE_STATUS, REQUEST_BODY);
    verify(notificationExtension, never()).notify(PLUGIN_ID_3, PIPELINE_STATUS, REQUEST_BODY);
    verify(serverHealthService, times(2)).removeByScope(any(HealthStateScope.class));
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldHandleErrorDuringPluginNotificationCorrectly() throws Exception {
    Result result = new Result();
    result.withErrorMessages(asList(new String[]{"message 1", "message 2"}));

    when(notificationPluginRegistry.getPluginsInterestedIn(PIPELINE_STATUS)).thenReturn(new LinkedHashSet<>(asList(PLUGIN_ID_1)));

    when(notificationExtension.notify(PLUGIN_ID_1, PIPELINE_STATUS, REQUEST_BODY)).thenReturn(result);
    when(serverHealthService.update(serverHealthState.capture())).thenReturn(null);

    PluginNotificationService pluginNotificationService = new PluginNotificationService(notificationExtension, notificationPluginRegistry, serverHealthService);
    pluginNotificationService.notifyPlugins(new PluginNotificationMessage(PIPELINE_STATUS, REQUEST_BODY));

    verify(notificationExtension).notify(PLUGIN_ID_1, PIPELINE_STATUS, REQUEST_BODY);
    assertThat(serverHealthState.getValue().getMessage(), is("Notification update failed for plugin: plugin-id-1"));
    assertThat(serverHealthState.getValue().getDescription(), is("message 1, message 2"));
    verify(serverHealthService, never()).removeByScope(any(HealthStateScope.class));
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
public void checkConnection(final PackageDefinition packageDefinition, final LocalizedOperationResult result) {
    try {
        String pluginId = packageDefinition.getRepository().getPluginConfiguration().getId();


        Result checkConnectionResult = packageRepositoryExtension.checkConnectionToPackage(pluginId, buildPackageConfigurations(packageDefinition), buildRepositoryConfigurations(packageDefinition.getRepository()));
        String messages = checkConnectionResult.getMessagesForDisplay();
        if (!checkConnectionResult.isSuccessful()) {
            result.connectionError(LocalizedMessage.string("PACKAGE_CHECK_FAILED", messages));
            return;
        }
        result.setMessage(LocalizedMessage.string("PACKAGE_CHECK_OK", messages));
        return;
    } catch (Exception e) {
        result.internalServerError(LocalizedMessage.string("PACKAGE_CHECK_FAILED", e.getMessage()));
    }
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
public Result checkConnectionToPackage(PackageConfiguration packageConfigurations, RepositoryConfiguration repositoryPackageConfigurations) {
    Result checkConnectionResult = checkConnectionToRepository(repositoryPackageConfigurations);
    if (!checkConnectionResult.isSuccessful()) {
        return checkConnectionResult;
    }
    try {
        Result packageConfigurationValidationResult = packageValidation(packageConfigurations, repositoryPackageConfigurations);
        if (!packageConfigurationValidationResult.isSuccessful()) {
            return packageConfigurationValidationResult;
        }
        PackageRevision latestRevision = getLatestRevision(packageConfigurations, repositoryPackageConfigurations);
        return new Result().withSuccessMessages(String.format("Found package '%s'.", latestRevision.getRevision()));
    } catch (Exception e) {
        LOGGER.warn(String.format("[Deb Repo Check Connection] Check connection to package failed with exception - %s", e));
        return new Result().withErrorMessages("Could not find any package that matched requirements.");
    }
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的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.response.Result; //导入依赖的package包/类
@Override
public Result checkConnectionToPackage(PackageConfiguration packageConfigs, RepositoryConfiguration repoConfigs) {
    Result response = checkConnectionToRepository(repoConfigs);
    if (!response.isSuccessful()) {
        LOGGER.info(response.getMessagesForDisplay());
        return response;
    }
    PackageRevision packageRevision = getLatestRevision(packageConfigs, repoConfigs);
    response.withSuccessMessages("Found " + packageRevision.getRevision());
    return response;
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Override
@EntryPoint
public Result checkConnectionToRepository(RepositoryConfiguration repositoryConfiguration) {
    Forge forge = forgeFactory.build(repositoryConfiguration);
    LOG.info("Checking connection to forge at %s", forge);

    try {
        forge.ping();
        return success();
    } catch (Forge.PingFailure pingFailure) {
        return error(pingFailure);
    }
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Override
@EntryPoint
public Result checkConnectionToPackage(PackageConfiguration packageConfiguration, RepositoryConfiguration repositoryConfiguration) {
    ModuleSpec moduleSpec = moduleSpecFactory.build(packageConfiguration);
    Forge forge = forgeFactory.build(repositoryConfiguration);
    LOG.info("Checking connection to module %s in forge at %s", moduleSpec, forge);

    try {
        forge.ping(moduleSpec);
        return success("Found %s.", moduleSpec.getName());
    } catch (Forge.PingFailure pingFailure) {
        return error(pingFailure);
    }
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldReturnFailureWhenForgeConnectionFails() throws Exception {
    doThrow(new PingFailure("Connection refused")).when(forge).ping();

    Result result = poller.checkConnectionToRepository(repoConfig);

    assertThat(result.isSuccessful(), is(false));
    assertThat(result.getMessages(), hasItem(containsString("Connection refused")));
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldReturnFailureWhenPackageConnectionFails() throws Exception {
    doThrow(new PingFailure("Not found")).when(forge).ping(moduleSpec);

    Result result = poller.checkConnectionToPackage(packageConfig, repoConfig);

    assertThat(result.isSuccessful(), is(false));
    assertThat(result.getMessages(), hasItem(containsString("Not found")));
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
/**
 * Validate the repository configuration
 *
 * @param repositoryConfiguration
 * @return
 */
private Result validateRepository(
        final RepositoryConfiguration repositoryConfiguration) {
    
    ValidationResult validationResult = new DockerMaterialConfiguration().isRepositoryConfigurationValid(repositoryConfiguration);
    if (!validationResult.isSuccessful()) {
        return new Result().withErrorMessages(validationResult.getMessages());
    }
    return new Result();
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
/**
 * Validate the package configuration
 *
 * @param packageConfigurations
 * @param repositoryPackageConfiguration
 * @return
 */
private Result packageValidation(
        final PackageConfiguration packageConfigurations, 
        final RepositoryConfiguration repositoryPackageConfiguration) {
    
    ValidationResult validationResult = new DockerMaterialConfiguration().isPackageConfigurationValid(packageConfigurations, repositoryPackageConfiguration);
    if (!validationResult.isSuccessful()) {
        return new Result().withErrorMessages(validationResult.getMessages());
    }
    return new Result();
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldTalkToPluginToCheckRepositoryConnectionSuccessful() throws Exception {
    String expectedRequestBody = "{\"repository-configuration\":{\"key-one\":{\"value\":\"value-one\"},\"key-two\":{\"value\":\"value-two\"}}}";

    String expectedResponseBody = "{\"status\":\"success\",messages=[\"message-one\",\"message-two\"]}";

    when(pluginManager.isPluginOfType(PACKAGE_MATERIAL_EXTENSION, PLUGIN_ID)).thenReturn(true);
    when(pluginManager.submitTo(eq(PLUGIN_ID), requestArgumentCaptor.capture())).thenReturn(DefaultGoPluginApiResponse.success(expectedResponseBody));

    Result result = extension.checkConnectionToRepository(PLUGIN_ID, repositoryConfiguration);

    assertRequest(requestArgumentCaptor.getValue(), PACKAGE_MATERIAL_EXTENSION, "1.0", PackageRepositoryExtension.REQUEST_CHECK_REPOSITORY_CONNECTION, expectedRequestBody);
    assertSuccessResult(result, asList("message-one", "message-two"));
}
 

import com.thoughtworks.go.plugin.api.response.Result; //导入依赖的package包/类
@Test
public void shouldTalkToPluginToCheckRepositoryConnectionFailure() throws Exception {
    String expectedRequestBody = "{\"repository-configuration\":{\"key-one\":{\"value\":\"value-one\"},\"key-two\":{\"value\":\"value-two\"}}}";

    String expectedResponseBody = "{\"status\":\"failed\",messages=[\"message-one\",\"message-two\"]}";

    when(pluginManager.isPluginOfType(PACKAGE_MATERIAL_EXTENSION, PLUGIN_ID)).thenReturn(true);
    when(pluginManager.submitTo(eq(PLUGIN_ID), requestArgumentCaptor.capture())).thenReturn(DefaultGoPluginApiResponse.success(expectedResponseBody));

    Result result = extension.checkConnectionToRepository(PLUGIN_ID, repositoryConfiguration);

    assertRequest(requestArgumentCaptor.getValue(), PACKAGE_MATERIAL_EXTENSION, "1.0", PackageRepositoryExtension.REQUEST_CHECK_REPOSITORY_CONNECTION, expectedRequestBody);
    assertFailureResult(result, asList("message-one", "message-two"));
}