jetbrains.buildServer.agent.AgentRunningBuild Java Examples

@NotNull
private static Map<String, URL> fetchUploadUrlFromServer(@NotNull final HttpClient httpClient,
                                                         @NotNull final AgentRunningBuild build,
                                                         @NotNull final Collection<String> s3ObjectKeys) throws IOException {
  try {
    final PostMethod post = new PostMethod(targetUrl(build));
    post.addRequestHeader("User-Agent", "TeamCity Agent");
    post.setRequestEntity(new StringRequestEntity(S3PreSignUrlHelper.writeS3ObjectKeys(s3ObjectKeys), APPLICATION_XML, UTF_8));
    post.setDoAuthentication(true);
    final String responseBody = HttpClientCloseUtil.executeReleasingConnectionAndReadResponseBody(httpClient, post);
    return S3PreSignUrlHelper.readPreSignUrlMapping(responseBody);
  } catch (HttpClientCloseUtil.HttpErrorCodeException e) {
    LOG.debug("Failed resolving S3 pre-signed URL for build " + build.describe(false) + " . Response code " + e.getResponseCode());
    return Collections.emptyMap();
  }
}
 

public void beforeBuildFinish(@NotNull final AgentRunningBuild build, @NotNull final BuildFinishedStatus buildStatus) {
    String tmpDirPath = build.getSharedConfigParameters().get(AnsibleRunnerConstants.ARTIFACTS_TMP_DIR_KEY);
    if (tmpDirPath == null) {
        return;
    }
    File tmpDir = new File(tmpDirPath);
    if (tmpDir.exists() && tmpDir.isDirectory()) {
        File[] rawFiles = tmpDir.listFiles();
        if (rawFiles == null || rawFiles.length == 0) {
            build.getBuildLogger().warning("Build defines ansible-run tmp directory but it doesn't contain any files");
        } else {
            generateReport(build, rawFiles);
        }
    } else {
        build.getBuildLogger().warning("Build defines ansible-run tmp directory but it doesn't exist");
    }
}
 

public AnsibleOutputListener(AgentRunningBuild build, BuildRunnerContext buildRunnerContext, ArtifactsWatcher artifactsWatcher) {
    this.artifactsWatcher = artifactsWatcher;
    this.buildRunnerContext = buildRunnerContext;
    File tmpDir = new File(build.getBuildTempDirectory(), "ansible-run");
    boolean exists = tmpDir.exists(); 
    if (!exists) {
        exists = tmpDir.mkdir();
    }
    if (!exists) {
        LOG.error("Cannot create a directory " + tmpDir.getAbsolutePath() + " for ansible run raw output storage");
        build.getBuildLogger().warning("Cannot create a directory for ansible run raw output storage. Ansible report will not be generated");
    } else {
        String rawFileName = "ansible-run-raw-" + buildRunnerContext.getId() + ".log";
        rawFile = new File(tmpDir, rawFileName);
        try {
            rawFile.createNewFile();
        } catch (IOException e) {
            LOG.error("Cannot create a file " + rawFileName + " for ansible run raw output writing ", e);
            build.getBuildLogger().warning("Cannot create a file for ansible run raw output writing. Ansible report will not be generated");
        }
        build.addSharedConfigParameter(AnsibleRunnerConstants.ARTIFACTS_TMP_DIR_KEY, tmpDir.getAbsolutePath());
    }
}
 

@Nullable
private static URL fetchUploadUrlFromServer(@NotNull final HttpClient httpClient, @NotNull final AgentRunningBuild build, @NotNull final String s3ObjectKey) {
  try {
    return fetchUploadUrlFromServer(httpClient, build, Collections.singleton(s3ObjectKey)).get(s3ObjectKey);
  } catch (IOException e) {
    throw new ArtifactPublishingFailedException(e.getMessage(), false, e);
  }
}
 

@NotNull
private HttpClient createPooledHttpClient(final AgentRunningBuild build) {
  final int connectionTimeout = build.getAgentConfiguration().getServerConnectionTimeout();
  final HttpClient httpClient = HttpUtil.createHttpClient(connectionTimeout);
  final HttpConnectionManager httpConnectionManager = createMultiThreadedHttpConnectionManager(connectionTimeout);
  httpClient.setHttpConnectionManager(httpConnectionManager);
  return httpClient;
}
 

@NotNull
private HttpClient createPooledHttpClientToTCServer(@NotNull final AgentRunningBuild build) {
  final int connectionTimeout = build.getAgentConfiguration().getServerConnectionTimeout();
  final HttpClient httpClient;
  try {
    httpClient = HttpUtil.createHttpClient(connectionTimeout, new URL(targetUrl(build)), new UsernamePasswordCredentials(build.getAccessUser(), build.getAccessCode()));
  } catch (MalformedURLException e) {
    throw new RuntimeException(e);
  }
  final HttpConnectionManager httpConnectionManager = createMultiThreadedHttpConnectionManager(connectionTimeout);
  httpClient.setHttpConnectionManager(httpConnectionManager);
  return httpClient;
}
 

private void provideArtifacts(List<Playbook> playbooks, AgentRunningBuild build) {
    File tmpReport = new File(build.getBuildTempDirectory(), AnsibleRunnerConstants.ARTIFACTS_JSON_REPORT);
    try {
        tmpReport.createNewFile();
        ReportBuilder.buildJsonReport(playbooks, tmpReport);
        build.getBuildLogger().message("Uploading artifact...");
        artifactsWatcher.addNewArtifactsPath(tmpReport.getAbsolutePath() + "=>" + AnsibleRunnerConstants.ARTIFACTS_BASE_DIR);
    } catch (Exception e) {
        LOG.error("Failed to create a file to write ansible run report", e);
        build.getBuildLogger().warning("Failed to generate report. Check agent logs for more details");
    }
}
 

/**
 * {@inheritDoc}
 */
@NotNull
@Override
public String getPath(@NotNull final String toolName,
                      @NotNull final AgentRunningBuild build,
                      @NotNull final BuildRunnerContext runner) {
    return runner.getRunnerParameters().get(AllureConstants.ALLURE_TOOL_VERSION);
}
 

@NotNull
Collection<ArtifactDataInstance> publishFiles(@NotNull final AgentRunningBuild build,
                                              @NotNull final String pathPrefix,
                                              @NotNull final Map<File, String> filesToPublish);
 

@NotNull
private static String targetUrl(@NotNull final AgentRunningBuild build) {
  return build.getAgentConfiguration().getServerUrl() + HTTP_AUTH + ARTEFACTS_S3_UPLOAD_PRESIGN_URLS_HTML;
}