public SymbolsIndexer()

in teamcity-symbol-agent/src/main/java/jetbrains/buildServer/symbols/SymbolsIndexer.java [69:203]


  public SymbolsIndexer(@NotNull final PluginDescriptor pluginDescriptor,
                        @NotNull final EventDispatcher<AgentLifeCycleListener> agentDispatcher,
                        @NotNull final ArtifactsWatcher artifactsWatcher,
                        @NotNull final ArtifactPathHelper artifactPathHelper) {
    myArtifactsWatcher = artifactsWatcher;
    myJetSymbolsExe = new JetSymbolsExe(new File(pluginDescriptor.getPluginRoot(), "bin"));
    myArtifactPathHelper = artifactPathHelper;

    agentDispatcher.addListener(new AgentLifeCycleAdapter() {
      @Override
      public void buildStarted(@NotNull final AgentRunningBuild runningBuild) {
        final long buildId = runningBuild.getBuildId();
        myBuildHasIndexerFeature = !runningBuild.getBuildFeaturesOfType(SymbolsConstants.BUILD_FEATURE_TYPE).isEmpty();

        if(!myBuildHasIndexerFeature) {
          LOG.debug(SymbolsConstants.BUILD_FEATURE_TYPE + " build feature disabled. No indexing will be performed for build with id " + buildId);
          return;
        }
        LOG.debug(SymbolsConstants.BUILD_FEATURE_TYPE + " build feature enabled for build with id " + buildId);

        final String indexingEnabled = runningBuild.getSharedConfigParameters().get(SymbolsConstants.INDEXING_ENABLED_PARAM_NAME);
        myIndexingEnabledByProperty = StringUtil.isEmpty(indexingEnabled) || StringUtil.isTrue(indexingEnabled);
        if (!myIndexingEnabledByProperty) {
          LOG.debug(SymbolsConstants.BUILD_FEATURE_TYPE + " build feature disabled by param. No indexing will be performed for build with id " + buildId);
          return;
        }

        myProgressLogger = runningBuild.getBuildLogger();
        myBuildTempDirectory = runningBuild.getBuildTempDirectory();

        checkAndReportRuntimeRequirements(runningBuild.getAgentConfiguration(), myProgressLogger);

        mySrcSrvHomeDir = getSrcSrvHomeDir(runningBuild.getAgentConfiguration());
        if (mySrcSrvHomeDir == null) {
          LOG.error("Failed to find Source Server tools home directory. No symbol and source indexing will be performed for build with id " + buildId);
          myProgressLogger.error("Failed to find Source Server tools home directory. No symbol and source indexing will be performed.");
          return;
        }
        LOG.debug("Source Server tools home directory located. " + mySrcSrvHomeDir.getAbsolutePath());
        myProgressLogger.message("Source Server tools home directory located. " + mySrcSrvHomeDir.getAbsolutePath());

        myFileUrlProvider = FileUrlProviderFactory.getProvider(runningBuild, myProgressLogger);
      }

      @Override
      public void afterAtrifactsPublished(@NotNull AgentRunningBuild build, @NotNull BuildFinishedStatus buildStatus) {
        super.afterAtrifactsPublished(build, buildStatus);
        if (isIndexingDisabled()) return;

        final String blockName = "Publishing symbol sources";
        try {
          myProgressLogger.logMessage(DefaultMessagesInfo.createBlockStart(blockName, "symbol-server"));

          final List<File> filesToPublish = new ArrayList<>();

          if (myPdbFileToArtifactMap.isEmpty()) {
            myProgressLogger.message("Symbols weren't found in artifacts to be published.");
            LOG.info("Symbols weren't found in artifacts to be published for build with id " + build.getBuildId());
          } else if (myPdbFileSignatures.isEmpty()){
            LOG.warn("No information was collected about symbol files signatures");
            myProgressLogger.warning("No information was collected about symbol files signatures");
          } else {
            try {
              final File localIndexDataFile = FileUtil.createTempFile(myBuildTempDirectory, "symbol-signatures-local-", ".xml", false);
              PdbSignatureIndexUtil.write(new FileOutputStream(localIndexDataFile), myPdbFileSignatures);

              final Set<PdbSignatureIndexEntry> transformedIndexData = getSignatureIndexEntries(myPdbFileSignatures, myPdbFileToArtifactMap);
              final File transformedIndexDataFile = FileUtil.createTempFile(myBuildTempDirectory, SymbolsConstants.SYMBOL_SIGNATURES_FILE_NAME_PREFIX, ".xml", false);
              PdbSignatureIndexUtil.write(new FileOutputStream(transformedIndexDataFile), transformedIndexData);

              filesToPublish.add(localIndexDataFile);
              filesToPublish.add(transformedIndexDataFile);
            } catch (Exception e) {
              LOG.error("Error while dumping symbols/binaries signatures for build with id " + build.getBuildId(), e);
              myProgressLogger.error("Error while dumping symbols/binaries signatures.");
              myProgressLogger.exception(e);
            }
          }
          myPdbFileToArtifactMap.clear();
          myPdbFileSignatures.clear();

          if (myBinaryFileToArtifactMap.isEmpty()) {
            myProgressLogger.message("Binaries weren't found in artifacts to be published.");
            LOG.debug("Binaries weren't found in artifacts to be published for build with id " + build.getBuildId());
          } else if (myBinaryFileSignatures.isEmpty()) {
            LOG.warn("No information was collected about binary files signatures");
            myProgressLogger.warning("No information was collected about binary files signatures");
          } else {
            try {
              final File localIndexDataFile = FileUtil.createTempFile(myBuildTempDirectory, "binary-signatures-local-", ".xml", false);
              PdbSignatureIndexUtil.write(new FileOutputStream(localIndexDataFile), myBinaryFileSignatures);

              final Set<PdbSignatureIndexEntry> transformedIndexData = getSignatureIndexEntries(myBinaryFileSignatures, myBinaryFileToArtifactMap);
              final File transformedIndexDataFile = FileUtil.createTempFile(myBuildTempDirectory, SymbolsConstants.BINARY_SIGNATURES_FILE_NAME_PREFIX, ".xml", false);
              PdbSignatureIndexUtil.write(new FileOutputStream(transformedIndexDataFile), transformedIndexData);

              filesToPublish.add(localIndexDataFile);
              filesToPublish.add(transformedIndexDataFile);
            } catch (Exception e) {
              LOG.error("Error while dumping symbols/binaries signatures for build with id " + build.getBuildId(), e);
              myProgressLogger.error("Error while dumping symbols/binaries signatures.");
              myProgressLogger.exception(e);
            }
          }
          myBinaryFileToArtifactMap.clear();
          myBinaryFileSignatures.clear();

          if (!filesToPublish.isEmpty()) {
            myProgressLogger.message("Publishing details about symbol and binary files.");
            final StringBuilder pathsBuilder = new StringBuilder();
            for (File file : filesToPublish) {
              pathsBuilder.append(file).append("=>").append(".teamcity/symbols").append("\n");
            }
            myArtifactsWatcher.addNewArtifactsPath(pathsBuilder.toString());
          }
        } finally {
          myProgressLogger.logMessage(DefaultMessagesInfo.createBlockEnd(blockName, "symbol-server"));
        }
      }

      @NotNull
      private Set<PdbSignatureIndexEntry> getSignatureIndexEntries(Set<PdbSignatureIndexEntry> signatureLocalFilesData, Map<File, String> artifactMap) {
        final Set<PdbSignatureIndexEntry> indexData = new HashSet<>();
        for(PdbSignatureIndexEntry signatureIndexEntry : signatureLocalFilesData){
          final String artifactPath = signatureIndexEntry.getArtifactPath();
          if(artifactPath == null) continue;
          final File targetFile = new File(artifactPath);
          if(artifactMap.containsKey(targetFile)) {
            indexData.add(new PdbSignatureIndexEntry(signatureIndexEntry.getGuid(), targetFile.getName(), artifactMap.get(targetFile)));
          }
        }
        return indexData;
      }
    });
  }