Java BuildProgressLogger类代码示例

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@NotNull
@Override
public ProgramCommandLine makeProgramCommandLine() throws RunBuildException {
  final PowerShellInfo info = selectTool();
  final String psExecutable = info.getExecutablePath();
  final String workDir = getWorkingDirectory().getPath();
  final PowerShellExecutionMode mode = PowerShellExecutionMode.fromString(getRunnerParameters().get(RUNNER_EXECUTION_MODE));
  final BuildProgressLogger buildLogger = getBuild().getBuildLogger();
  buildLogger.message("PowerShell Executable: " + psExecutable);
  buildLogger.message("Working directory: " + workDir);
  if (PowerShellExecutionMode.STDIN == mode) {
    return getStdInCommandLine(info, getEnv(info), workDir, generateCommand(info));
  } else if (PowerShellExecutionMode.PS1 == mode) {
    return getFileCommandLine(info, getEnv(info), workDir, generateArguments(info));
  } else {
    throw new RunBuildException("Could not select PowerShell tool for mode [" + mode + "]");
  }
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@BeforeMethod
public void setUp() throws Exception {
    uploadTaskLog = "Upload to S3 bucket: ";
    noUploadErrorLog = "No files to upload have been found!";
    taskDoneLog = "Done";

    amazonS3Mock = mock(AmazonS3.class);
    loggerMock = mock(BuildProgressLogger.class);
    runnerParametersMock = new HashMap<>();
    agentCheckoutDirectoryMock = mock(File.class);
    extensionHolderMock = mock(ExtensionHolder.class);

    uploadAdapterMock = mock(AWSS3UploadAdapter.class);
    deleteAdapterMock = mock(AWSS3DeleteAdapter.class);

    awsS3AdapterMock = new AWSS3Adapter(uploadAdapterMock, deleteAdapterMock);
    processAdapterHelperMock = mock(AWSS3BuildProcessAdapterHelper.class);
    when(processAdapterHelperMock.createClient(anyString(), anyString())).thenReturn(amazonS3Mock);
    when(processAdapterHelperMock.createClientWithProxy(anyString(), anyString(), anyString())).thenReturn(amazonS3Mock);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
public int dumpPdbGuidsToFile(Collection<File> files, File output, BuildProgressLogger buildLogger) throws IOException {
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(myExePath.getPath());
  commandLine.addParameter(DUMP_SYMBOL_SIGN_CMD);
  commandLine.addParameter(String.format("/o=%s", output.getPath()));
  commandLine.addParameter(String.format("/i=%s", dumpPathsToFile(files).getPath()));
  buildLogger.message(String.format("Running command %s", commandLine.getCommandLineString()));
  final ExecResult execResult = SimpleCommandLineProcessRunner.runCommand(commandLine, null);
  final String stdout = execResult.getStdout();
  if(!stdout.isEmpty()){
    buildLogger.message("Stdout: " + stdout);
  }
  final int exitCode = execResult.getExitCode();
  if (exitCode != 0) {
    buildLogger.warning(String.format("%s ends with non-zero exit code %s.", SYMBOLS_EXE, execResult));
    buildLogger.warning("Stdout: " + stdout);
    buildLogger.warning("Stderr: " + execResult.getStderr());
    final Throwable exception = execResult.getException();
    if(exception != null){
      buildLogger.exception(exception);
    }
  }
  return exitCode;
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
public void patch(File symbolsFile, BuildProgressLogger buildLogger) throws Exception {
  final Collection<File> sourceFiles = mySrcToolExe.getReferencedSourceFiles(symbolsFile);
  final String symbolsFileCanonicalPath = symbolsFile.getCanonicalPath();
  if(sourceFiles.isEmpty()){
    final String message = "No source information found in pdb file " + symbolsFileCanonicalPath;
    buildLogger.warning(message);
    LOG.debug(message);
    return;
  }
  final File tmpFile = FileUtil.createTempFile(myWorkingDir, "pdb-", ".patch", false);
  int processedFilesCount = mySrcSrvStreamBuilder.dumpStreamToFile(tmpFile, sourceFiles);
  if(processedFilesCount == 0){
    buildLogger.warning(String.format("Sources appeared in file %s weren't actually indexed. Looks like related binary file wasn't built during current build.", symbolsFileCanonicalPath));
  } else {
    buildLogger.message(String.format("Information about %d source files was updated", processedFilesCount));
  }
  myPdbStrExe.doCommand(PdbStrExeCommands.WRITE, symbolsFile, tmpFile, PdbStrExe.SRCSRV_STREAM_NAME);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@NotNull
@Override
public ProgramCommandLine makeProgramCommandLine() throws RunBuildException {
    BuildProgressLogger buildLogger = getLogger();
    BuildRunnerContext buildRunnerContext = getRunnerContext();
    Map<String, String> programEnvironmentVariables = buildRunnerContext.getBuildParameters().getEnvironmentVariables();
    String programWorkingDirectory = getProgramWorkingDirectory();
    String programPath = getProgramPath();
    List<String> programArgs = getProgramArgs();

    buildLogger.message("Program environment variables: " + programEnvironmentVariables.toString());
    buildLogger.message("Program working directory: " + programWorkingDirectory);
    buildLogger.message("Program path: " + programPath);
    buildLogger.message("Program args: " + programArgs.toString());

    return new SimpleProgramCommandLine(buildRunnerContext.getBuildParameters().getEnvironmentVariables(), programWorkingDirectory, programPath, programArgs);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
public TodoBuildProcessAdapter(
        @NotNull ArtifactsWatcher artifactsWatcher,
        @NotNull BuildProgressLogger logger,
        @NotNull File workingRoot,
        @NotNull File reportingRoot,
        @NotNull List<String> includes,
        @NotNull List<String> excludes,
        @NotNull List<String> minors,
        @NotNull List<String> majors,
        @NotNull List<String> criticals) {
    super(logger);
    this.artifactsWatcher = artifactsWatcher;
    this.workingRoot = workingRoot;
    this.reportingRoot = reportingRoot;
    this.includes = includes;
    this.excludes = excludes;
    this.minors = minors;
    this.majors = majors;
    this.criticals = criticals;
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@NotNull
public static BuildProcess block(@NotNull final BuildProgressLogger logger,
                                 @NotNull final String blockName,
                                 @NotNull final String blockText,
                                 @NotNull final BuildProcess proc) {
  return new DelegatingBuildProcess(new DelegatingBuildProcess.Action() {
    @NotNull
    @Override
    public BuildProcess startImpl() throws RunBuildException {
      logger.activityStarted(blockName, blockText, "vm");
      return proc;
    }

    @Override
    public void finishedImpl() {
      logger.activityFinished(blockName, "vm");
    }
  });
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@NotNull
@Override
public ProgramCommandLine makeProgramCommandLine() throws RunBuildException {

    BuildProgressLogger buildLogger = getLogger();
    BuildRunnerContext buildRunnerContext = getRunnerContext();
    Map<String, String> programEnvironmentVariables = buildRunnerContext.getBuildParameters().getEnvironmentVariables();
    String programPath = getProgramPath();
    List<String> programArgs = getProgramArgs();

    buildLogger.message("Program environment variables: " + programEnvironmentVariables.toString());
    buildLogger.message("Program working directory: " + workingDirectory);
    buildLogger.message("Program path: " + programPath);
    buildLogger.message("Program args: " + programArgs.toString());

    return new SimpleProgramCommandLine(programEnvironmentVariables, workingDirectory, programPath, programArgs);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
private String getProgramPath() throws RunBuildException {

        BuildProgressLogger buildLogger = getLogger();
        String path = clientDirectory.toAbsolutePath().toString();
        String executableName = getExecutableName();

        String executableFile = path + File.separatorChar + "bin" + File.separatorChar + executableName;
        File file = new File(executableFile);

        if (!file.exists())
            throw new RunBuildException("Cannot find executable \'" + executableFile + "\'");
        if (!file.setExecutable(true))
            buildLogger.message("Cannot set file: " + executableFile + " executable.");

        return file.getAbsolutePath();

    }
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@Nullable
public URLContentRetriever getTransport(@NotNull Map<String, String> context) {

  final BuildProgressLogger buildLogger = myBuildTracker.getCurrentBuild().getBuildLogger();
  if (!shouldUseTorrentTransport()) {
    TorrentUtil.log2Build("BitTorrent artifacts transport is disabled in server settings", buildLogger);
    return null;
  }

  if (!myAgentTorrentsManager.isTransportEnabled()) {
    return null;
  }

  return new TorrentTransport(myAgentTorrentsManager.getTorrentsSeeder(),
          createHttpClient(),
          buildLogger,
          myAgentConfig.getServerUrl(),
          myAgentTorrentsManager.getTorrentsDownloadStatistic(),
          myLeechSettings,
          myTorrentFilesFactory);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
protected TorrentTransport(@NotNull final TorrentsSeeder seeder,
                           @NotNull final HttpClient httpClient,
                           @NotNull final BuildProgressLogger buildLogger,
                           @NotNull final String serverUrl,
                           @NotNull final TorrentsDownloadStatistic torrentsDownloadStatistic,
                           @NotNull final LeechSettings leechSettings,
                           @NotNull final TorrentFilesFactory torrentFilesFactory) {
  super(httpClient, serverUrl);
  mySeeder = seeder;
  myLeechSettings = leechSettings;
  myClient = mySeeder.getClient();
  myTorrentFilesFactory = torrentFilesFactory;
  myTorrentsDownloadStatistic = torrentsDownloadStatistic;
  myHttpClient = httpClient;
  myBuildLogger = buildLogger;
  myTorrentsForArtifacts = new HashMap<String, String>();
  myCurrentDownload = new AtomicReference<Thread>();
  myInterrupted = new AtomicBoolean(false);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
private SimpleProgramCommandLine executeWithWrapper(@NotNull final Map<String, String> env,
                                                    @NotNull final String workDir,
                                                    @NotNull final String argsList) throws RunBuildException {
  final File scriptFile = generateNixScriptFile(argsList);
  final BuildProgressLogger buildLogger = getBuild().getBuildLogger();
  buildLogger.message("Wrapper script: " + scriptFile);
  buildLogger.message("Command: " + argsList);
  enableExecution(scriptFile);
  return new SimpleProgramCommandLine(env, workDir, scriptFile.getAbsolutePath(), Collections.<String>emptyList());
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@Override
protected SimpleProgramCommandLine getStdInCommandLine(@NotNull final PowerShellInfo info,
                                                       @NotNull final Map<String, String> env,
                                                       @NotNull final String workDir,
                                                       @NotNull final String command) throws RunBuildException {
  final List<String> args = generateRunScriptArguments(command);
  final String executable = myCommands.getCMDWrappedCommand(info, getEnvironmentVariables());
  final BuildProgressLogger buildLogger = getBuild().getBuildLogger();
  buildLogger.message("Executable wrapper: " + executable);
  buildLogger.message("Wrapper arguments: " + Arrays.toString(args.toArray()));
  buildLogger.message("Command: " + command);
  return new SimpleProgramCommandLine(env, workDir, executable, args);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
@Override
protected SimpleProgramCommandLine getFileCommandLine(@NotNull final PowerShellInfo info,
                                                      @NotNull final Map<String, String> env,
                                                      @NotNull final String workDir,
                                                      @NotNull final List<String> args) throws RunBuildException {
  final BuildProgressLogger buildLogger = getBuild().getBuildLogger();
  final String command = myCommands.getNativeCommand(info);
  buildLogger.message("Command: " + command);
  buildLogger.message("PowerShell arguments: " + StringUtil.join(args, ", "));
  return new SimpleProgramCommandLine(env, workDir, command, args);
}
 

import jetbrains.buildServer.agent.BuildProgressLogger; //导入依赖的package包/类
private AutotoolsTestsReporter(final long timeBeforeStart, @NotNull final BuildProgressLogger logger,
                              @NotNull final String srcPath) {
  myTimeBeforeStart = timeBeforeStart;
  myLogger = logger;
  mySrcPath = srcPath;
  myTestsLogFiles = new HashMap<String, File>();
  myTestsTrsFiles = new HashMap<String, File>();
  myTestsXmlFiles = new ArrayList<File>();
  hasDejagnu = false;

}