import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
private ExecutionResult runCommand(TaskExecutionContext taskContext, TaskConfig taskConfig) throws IOException, InterruptedException {
    ProcessBuilder curl = createCurlCommandWithOptions(taskContext, taskConfig);

    Console console = taskContext.console();
    console.printLine("Launching command: " + curl.command());

    EnvironmentVariables environment = taskContext.environment();
    curl.environment().putAll(environment.asMap());
    console.printEnvironment(curl.environment(), environment.secureEnvSpecifier());

    Process curlProcess = curl.start();
    console.readErrorOf(curlProcess.getErrorStream());
    console.readOutputOf(curlProcess.getInputStream());

    int exitCode = curlProcess.waitFor();
    curlProcess.destroy();

    if (exitCode != 0) {
        return ExecutionResult.failure("Failed downloading file. Please check the output");
    }

    return ExecutionResult.success("Downloaded file: " + CURLED_FILE);
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Override
public ExecutionResult execute(TaskConfig config, TaskExecutionContext context) {
    Collection<GoArtifact> artifacts = artifactFactory.createArtifacts(config, context);

    EnvironmentVariables environment = context.environment();
    GoBuildDetails details = buildDetailsFactory.createBuildDetails(environment, artifacts);

    try (ArtifactoryClient client = createClient(environment)) {
        UploadMetadata uploadMetadata = client.uploadArtifacts(artifacts);
        client.uploadBuildDetails(details);

        buildArtifactPublisher.publish(context, uploadMetadata);

        context.console()
                .printLine(format("Successfully published artifacts:\n%s", asString(artifacts)));
        return success("");
    }
    catch (RuntimeException e) {
        String message = format("Failed to publish one or more artifact [%s]", artifacts);
        logger.error(message, e);
        return failure(format("%s: %s", message, e.getMessage()));
    }
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Override
public ExecutionResult toExecutionResult(String responseBody) {
    ExecutionResult executionResult = new ExecutionResult();
    ArrayList<String> exceptions = new ArrayList<>();
    try {
        Map result = (Map) new GsonBuilder().create().fromJson(responseBody, Object.class);
        if (!(result.containsKey("success") && result.get("success") instanceof Boolean)) {
            exceptions.add("The Json for Execution Result must contain a not-null 'success' field of type Boolean");
        }
        if (result.containsKey("message") && (!(result.get("message") instanceof String))) {
            exceptions.add("If the 'message' key is present in the Json for Execution Result, it must contain a not-null message of type String");
        }
        if (!exceptions.isEmpty()) {
            throw new RuntimeException(StringUtils.join(exceptions, ", "));
        }
        if ((Boolean) result.get("success")) {
            executionResult.withSuccessMessages((String) result.get("message"));
        } else {
            executionResult.withErrorMessages((String) result.get("message"));
        }
        return executionResult;
    } catch (Exception e) {
        LOGGER.error("Error occurred while converting the Json to Execution Result. Error: {}. The Json received was '{}'.", e.getMessage(), responseBody);
        throw new RuntimeException(String.format("Error occurred while converting the Json to Execution Result. Error: %s.", e.getMessage()));
    }
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldExecuteAndReturnSuccessfulExecutionResultTaskThroughPlugin() {
    when(pluginManager.submitTo(eq(pluginId), any(GoPluginApiRequest.class))).thenReturn(response);
    when(handler.toExecutionResult(response.responseBody())).thenReturn(ExecutionResult.success("message1"));

    ExecutionResult result = new JsonBasedTaskExecutor(pluginId, pluginRequestHelper, handlerHashMap).execute(config(), context);

    assertThat(result.isSuccessful(), is(true));
    assertThat(result.getMessagesForDisplay(), is("message1"));

    ArgumentCaptor<GoPluginApiRequest> argument = ArgumentCaptor.forClass(GoPluginApiRequest.class);
    verify(pluginManager).submitTo(eq(pluginId), argument.capture());
    assertThat(argument.getValue().extension(), is(PLUGGABLE_TASK_EXTENSION));
    assertThat(argument.getValue().extensionVersion(), is(extensionVersion));
    assertThat(argument.getValue().requestName(), is(TaskExtension.EXECUTION_REQUEST));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Override
public void build(final DefaultGoPublisher publisher,
                  final EnvironmentVariableContext environmentVariableContext, TaskExtension taskExtension, ArtifactExtension artifactExtension, PluginRequestProcessorRegistry pluginRequestProcessorRegistry, String consoleLogCharset) throws CruiseControlException {
    ExecutionResult executionResult = null;
    try {
        executionResult = taskExtension.execute(pluginId, new ActionWithReturn<Task, ExecutionResult>() {
            @Override
            public ExecutionResult execute(Task task, GoPluginDescriptor pluginDescriptor) {
                return executeTask(task, publisher, environmentVariableContext, consoleLogCharset);
            }
        });
    } catch (Exception e) {
        logException(publisher, e);
    } finally {
        JobConsoleLoggerInternal.unsetContext();
    }
    if (executionResult == null) {
        logError(publisher, "ExecutionResult cannot be null. Please return a success or a failure response.");
    }
    if (!executionResult.isSuccessful()) {
        logError(publisher, executionResult.getMessagesForDisplay());
    }
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的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.execution.ExecutionResult; //导入依赖的package包/类
@Override
public ExecutionResult execute(TaskConfig taskConfig, TaskExecutionContext taskExecutionContext) {
    ProcessBuilder powershell = createPowershellCommand(taskExecutionContext, taskConfig);

    Console console = taskExecutionContext.console();
    console.printLine("Launching command: " + StringUtils.join(powershell.command(), " "));

    try {
        Process process = powershell.start();

        PutScriptIntoPowershellStdin(taskExecutionContext, taskConfig, process);

        console.readErrorOf(process.getErrorStream());
        console.readOutputOf(process.getInputStream());

        int exitCode = process.waitFor();
        process.destroy();

        if (exitCode != 0) {
            return ExecutionResult.failure("Build Failure");
        }
    }
    catch(Exception e) {
        console.printLine(e.getMessage());
        return ExecutionResult.failure("Failed while running Powershell task ", e);
    }

    return ExecutionResult.success("Build Success");
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Override
public ExecutionResult execute(TaskConfig tc, TaskExecutionContext tec) {
    Console console = tec.console();
    
    ProcessBuilder mvn = createMavenCommand(tc, tec);

    try {
        Process process = mvn.start();

        console.readErrorOf(process.getErrorStream());
        console.readOutputOf(process.getInputStream());

        int exitCode = process.waitFor();
        process.destroy();
        if (exitCode != 0) {
            return ExecutionResult.failure("Build failure");
        }
    } catch (Exception t) {
        console.printLine(t.getMessage());
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        t.printStackTrace(pw);
        console.printLine(sw.toString());
        return ExecutionResult.failure("Build failure: " + t.getMessage(), t);
    }

    return ExecutionResult.success("Build success");
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Override
public ExecutionResult execute(TaskConfig config, TaskExecutionContext taskEnvironment) {
    try {
        return runCommand(taskEnvironment, config);
    } catch (Exception e) {
        return ExecutionResult.failure("Failed to download file from URL: " + config.getValue(CurlTask.URL_PROPERTY), e);
    }
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldUploadArtifactAndBuildDetails() throws IOException {
    TaskConfig config = new TaskConfigBuilder()
            .uri("test-repo/path/to/artifact.ext")
            .path("src/test/resources/artifact.txt")
            .property("a", "b")
            .build();

    TaskExecutionContext executionContext =
            new TaskExecutionContextBuilder()
                    .withWorkingDir(System.getProperty("java.io.tmpdir"))
                    .withEnvVars(map("ARTIFACTORY_URL", "http://localhost:8888")
                            .and("ARTIFACTORY_USER", "admin")
                            .and("ARTIFACTORY_PASSWORD", "password")
                            .and("GO_SERVER_URL", "http://localhost:8153/go")
                            .and("GO_PIPELINE_NAME", "pipeline")
                            .and("GO_PIPELINE_COUNTER", "1")
                            .and("GO_STAGE_COUNTER", "3"))
                    .build();

    File testResponse = new File(path("src", "test", "resources", "uploadResponse.json"));
    artifactoryStub.put("/test-repo/path/to/artifact.ext").withContent("content")
            .returns(response(201).withContent(read(testResponse)));

    artifactoryStub.put("/test-repo/path/to/artifact.ext.sha1").withContent("040f06fd774092478d450774f5ba30c5da78acc8").returns(response(201));
    artifactoryStub.put("/test-repo/path/to/artifact.ext.md5").withContent("9a0364b9e99bb480dd25e1f0284c8555").returns(response(201));
    artifactoryStub.put("/api/build").withHeader("Content-Type", "application/vnd.org.jfrog.artifactory+json").returns(response(204));

    ExecutionResult result = executor.execute(config, executionContext);

    ASSERT.that(result.isSuccessful()).isTrue();
    ASSERT.that(new File(pluginDirectory, "uploadMetadata.json").exists()).isTrue();
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldExecuteAndReturnFailureExecutionResultTaskThroughPlugin() {
    when(pluginManager.submitTo(eq(pluginId), any(GoPluginApiRequest.class))).thenReturn(response);
    when(handler.toExecutionResult(response.responseBody())).thenReturn(ExecutionResult.failure("error1"));

    ExecutionResult result = new JsonBasedTaskExecutor(pluginId, pluginRequestHelper, handlerHashMap).execute(config(), context);

    assertThat(result.isSuccessful(), is(false));
    assertThat(result.getMessagesForDisplay(), is("error1"));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldExecuteTheTask() {
    ActionWithReturn actionWithReturn = mock(ActionWithReturn.class);
    when(actionWithReturn.execute(any(JsonBasedPluggableTask.class), any(GoPluginDescriptor.class))).thenReturn(ExecutionResult.success("yay"));

    ExecutionResult executionResult = extension.execute(pluginId, actionWithReturn);

    verify(actionWithReturn).execute(any(JsonBasedPluggableTask.class), any(GoPluginDescriptor.class));
    assertThat(executionResult.getMessagesForDisplay(), is("yay"));
    assertTrue(executionResult.isSuccessful());
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldConstructExecutionResultFromSuccessfulExecutionResponse() {
    GoPluginApiResponse response = mock(GoPluginApiResponse.class);
    when(response.responseBody()).thenReturn("{\"success\":true,\"message\":\"message1\"}");

    ExecutionResult result = new JsonBasedTaskExtensionHandler_V1().toExecutionResult(response.responseBody());
    assertThat(result.isSuccessful(), is(true));
    assertThat(result.getMessagesForDisplay(), is("message1"));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldConstructExecutionResultFromFailureExecutionResponse() {
    GoPluginApiResponse response = mock(GoPluginApiResponse.class);
    when(response.responseBody()).thenReturn("{\"success\":false,\"message\":\"error1\"}");

    ExecutionResult result = new JsonBasedTaskExtensionHandler_V1().toExecutionResult(response.responseBody());
    assertThat(result.isSuccessful(), is(false));
    assertThat(result.getMessagesForDisplay(), is("error1"));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
protected ExecutionResult executeTask(Task task,
                                      DefaultGoPublisher publisher,
                                      EnvironmentVariableContext environmentVariableContext, String consoleLogCharset) {
    final TaskExecutionContext taskExecutionContext = buildTaskContext(publisher, environmentVariableContext, consoleLogCharset);
    JobConsoleLoggerInternal.setContext(taskExecutionContext);

    TaskConfig config = buildTaskConfig(task.config());
    return task.executor().execute(config, taskExecutionContext);
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldInvokeTheTaskExecutorOfThePlugin() throws Exception {
    final int[] executeTaskCalled = new int[1];
    PluggableTaskBuilder taskBuilder = new PluggableTaskBuilder(runIfConfigs, cancelBuilder, pluggableTask, TEST_PLUGIN_ID, "test-directory") {
        @Override
        protected ExecutionResult executeTask(Task task, DefaultGoPublisher publisher, EnvironmentVariableContext environmentVariableContext, String consoleLogCharset) {
            executeTaskCalled[0]++;
            return ExecutionResult.success("Test succeeded");
        }
    };

    taskBuilder.build(goPublisher, variableContext, taskExtension, null, null, "utf-8");

    assertThat(executeTaskCalled[0], is(1));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldRegisterTaskConfigDuringExecutionAndUnregisterOnSuccessfulCompletion() throws CruiseControlException {
    final PluggableTaskBuilder builder = spy(new PluggableTaskBuilder(runIfConfigs, cancelBuilder, pluggableTask, "", ""));
    taskExtension = mock(TaskExtension.class);
    when(taskExtension.execute(eq(TEST_PLUGIN_ID), any(ActionWithReturn.class))).thenReturn(ExecutionResult.success("yay"));

    builder.build(goPublisher, variableContext, taskExtension, null, null, "utf-8");
    assertThat(ReflectionUtil.getStaticField(JobConsoleLogger.class, "context"), is(nullValue()));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Test
public void shouldUnsetTaskExecutionContextFromJobConsoleLoggerWhenTaskExecutionFails() throws CruiseControlException {
    final PluggableTaskBuilder builder = spy(new PluggableTaskBuilder(runIfConfigs, cancelBuilder, pluggableTask, "", ""));

    taskExtension = mock(TaskExtension.class);
    when(taskExtension.execute(eq(TEST_PLUGIN_ID), any(ActionWithReturn.class))).thenReturn(ExecutionResult.failure("oh no"));

    try {
        builder.build(goPublisher, variableContext, taskExtension, null, null, "utf-8");
        fail("should throw exception");
    } catch (Exception e) {
        assertThat(ReflectionUtil.getStaticField(JobConsoleLogger.class, "context"), is(nullValue()));
    }
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
public ExecutionResult execute(String pluginId, ActionWithReturn<Task, ExecutionResult> actionWithReturn) {
    JsonBasedPluggableTask task = new JsonBasedPluggableTask(pluginId, pluginRequestHelper, messageHandlerMap);
    return actionWithReturn.execute(task, pluginManager.getPluginDescriptorFor(pluginId));
}
 

import com.thoughtworks.go.plugin.api.response.execution.ExecutionResult; //导入依赖的package包/类
@Override
public Result checkConnectionToRepository(RepositoryConfiguration repositoryConfiguration) {
    LOGGER.debug("checkConnectionToRepository called");

    CloudFoundryClient client = getClient(repositoryConfiguration);

    GetInfoResponse response = client.info().get(GetInfoRequest.builder().build()).block(Duration.ofSeconds(5));

    String apiVersion = response.getApiVersion();

    return ExecutionResult.success("Connected with supplied credentials, apiVersion: " + apiVersion);
}