feat(analyzer)!: Migrate package managers to new plugin API

As part of this refactoring the `analzyerConfig` argument is moved from
the constructor to the `beforeResolution` and `resolveDependencies`
functions. This was not done in a separate commit because it would have
required a lot of code changes that would have been removed again as
part of the migration.

Resolves #9403.

Signed-off-by: Martin Nonnenmacher <[email protected]>

Author: mnonnenmacher

analyzer/build.gradle.kts

@@ -27,6 +27,7 @@ plugins {
 
 dependencies {
     api(projects.model)
+    api(projects.plugins.api)
 
     implementation(projects.downloader)
     implementation(projects.utils.configUtils)

analyzer/src/funTest/kotlin/PackageManagerFunTest.kt

@@ -32,10 +32,10 @@ import io.kotest.matchers.should
 
 import java.io.File
 
-import org.ossreviewtoolkit.model.config.AnalyzerConfiguration
 import org.ossreviewtoolkit.model.config.Excludes
 import org.ossreviewtoolkit.model.config.PathExclude
 import org.ossreviewtoolkit.model.config.PathExcludeReason
+import org.ossreviewtoolkit.plugins.api.PluginConfig
 
 class PackageManagerFunTest : WordSpec({
     val definitionFiles = listOf(
@@ -73,7 +73,7 @@ class PackageManagerFunTest : WordSpec({
     )
 
     val projectDir = tempdir()
-    val packageManagers = PackageManagerFactory.ALL.values.map { it.create(AnalyzerConfiguration()) }
+    val packageManagers = PackageManagerFactory.ALL.values.map { it.create(PluginConfig()) }
 
     beforeSpec {
         definitionFiles.writeFiles(projectDir)
@@ -85,75 +85,75 @@ class PackageManagerFunTest : WordSpec({
 
             // The test project contains at least one file per package manager, so the result should also contain an
             // entry for each package manager.
-            managedFiles.keys.map { it.managerName } shouldContainExactlyInAnyOrder
-                PackageManagerFactory.ALL.values.map { it.type }.filterNot { it == "Unmanaged" }
+            managedFiles.keys.map { it.descriptor.id } shouldContainExactlyInAnyOrder
+                PackageManagerFactory.ALL.values.map { it.descriptor.id }.filterNot { it == "Unmanaged" }
 
-            val managedFilesByName = managedFiles.groupByName(projectDir)
+            val managedFilesById = managedFiles.groupById(projectDir)
 
             assertSoftly {
-                managedFilesByName["Bazel"] should containExactly("bazel/MODULE.bazel")
-                managedFilesByName["Bower"] should containExactly("bower/bower.json")
-                managedFilesByName["Bundler"] should containExactly("bundler/Gemfile")
-                managedFilesByName["Cargo"] should containExactly("cargo/Cargo.toml")
-                managedFilesByName["Carthage"] should containExactly("carthage/Cartfile.resolved")
-                managedFilesByName["CocoaPods"] should containExactly("cocoapods/Podfile")
-                managedFilesByName["Composer"] should containExactly("composer/composer.json")
-                managedFilesByName["Conan"] should containExactlyInAnyOrder(
+                managedFilesById["Bazel"] should containExactly("bazel/MODULE.bazel")
+                managedFilesById["Bower"] should containExactly("bower/bower.json")
+                managedFilesById["Bundler"] should containExactly("bundler/Gemfile")
+                managedFilesById["Cargo"] should containExactly("cargo/Cargo.toml")
+                managedFilesById["Carthage"] should containExactly("carthage/Cartfile.resolved")
+                managedFilesById["CocoaPods"] should containExactly("cocoapods/Podfile")
+                managedFilesById["Composer"] should containExactly("composer/composer.json")
+                managedFilesById["Conan"] should containExactlyInAnyOrder(
                     "conan-py/conanfile.py",
                     "conan-txt/conanfile.txt"
                 )
-                managedFilesByName["GoMod"] should containExactly("gomod/go.mod")
-                managedFilesByName["GradleInspector"] should containExactlyInAnyOrder(
+                managedFilesById["GoMod"] should containExactly("gomod/go.mod")
+                managedFilesById["GradleInspector"] should containExactlyInAnyOrder(
                     "gradle-groovy/build.gradle",
                     "gradle-kotlin/build.gradle.kts"
                 )
-                managedFilesByName["Maven"] should containExactly("maven/pom.xml")
-                managedFilesByName["NPM"] should containExactly("npm-pnpm-and-yarn/package.json")
-                managedFilesByName["NuGet"] should containExactlyInAnyOrder(
+                managedFilesById["Maven"] should containExactly("maven/pom.xml")
+                managedFilesById["NPM"] should containExactly("npm-pnpm-and-yarn/package.json")
+                managedFilesById["NuGet"] should containExactlyInAnyOrder(
                     "dotnet/test.csproj",
                     "nuget/packages.config"
                 )
-                managedFilesByName["PIP"] should containExactlyInAnyOrder(
+                managedFilesById["PIP"] should containExactlyInAnyOrder(
                     "pip-requirements/requirements.txt",
                     "pip-setup/setup.py"
                 )
-                managedFilesByName["Pipenv"] should containExactly("pipenv/Pipfile.lock")
-                managedFilesByName["PNPM"] should containExactly("npm-pnpm-and-yarn/package.json")
-                managedFilesByName["Poetry"] should containExactly("poetry/poetry.lock")
-                managedFilesByName["Pub"] should containExactly("pub/pubspec.yaml")
-                managedFilesByName["SBT"] should containExactly("sbt/build.sbt")
-                managedFilesByName["SpdxDocumentFile"] should containExactlyInAnyOrder(
+                managedFilesById["Pipenv"] should containExactly("pipenv/Pipfile.lock")
+                managedFilesById["PNPM"] should containExactly("npm-pnpm-and-yarn/package.json")
+                managedFilesById["Poetry"] should containExactly("poetry/poetry.lock")
+                managedFilesById["Pub"] should containExactly("pub/pubspec.yaml")
+                managedFilesById["SBT"] should containExactly("sbt/build.sbt")
+                managedFilesById["SpdxDocumentFile"] should containExactlyInAnyOrder(
                     "spdx-package/package.spdx.yml",
                     "spdx-project/project.spdx.yml"
                 )
-                managedFilesByName["SwiftPM"] should containExactlyInAnyOrder(
+                managedFilesById["SwiftPM"] should containExactlyInAnyOrder(
                     "spm-app/Package.resolved",
                     "spm-lib/Package.swift"
                 )
-                managedFilesByName["Stack"] should containExactly("stack/stack.yaml")
-                managedFilesByName["Yarn"] should containExactly("npm-pnpm-and-yarn/package.json")
+                managedFilesById["Stack"] should containExactly("stack/stack.yaml")
+                managedFilesById["Yarn"] should containExactly("npm-pnpm-and-yarn/package.json")
             }
         }
 
         "find only files for active package managers" {
             val managedFiles = PackageManager.findManagedFiles(
                 projectDir,
-                packageManagers.filter { it.managerName in listOf("GradleInspector", "PIP", "SBT") }
+                packageManagers.filter { it.descriptor.id in setOf("GradleInspector", "PIP", "SBT") }
             )
 
             managedFiles shouldHaveSize 3
 
-            val managedFilesByName = managedFiles.groupByName(projectDir)
+            val managedFilesById = managedFiles.groupById(projectDir)
 
-            managedFilesByName["GradleInspector"] should containExactlyInAnyOrder(
+            managedFilesById["GradleInspector"] should containExactlyInAnyOrder(
                 "gradle-groovy/build.gradle",
                 "gradle-kotlin/build.gradle.kts"
             )
-            managedFilesByName["PIP"] should containExactlyInAnyOrder(
+            managedFilesById["PIP"] should containExactlyInAnyOrder(
                 "pip-requirements/requirements.txt",
                 "pip-setup/setup.py"
             )
-            managedFilesByName["SBT"] should containExactly("sbt/build.sbt")
+            managedFilesById["SBT"] should containExactly("sbt/build.sbt")
         }
 
         "find no files if no package managers are active" {
@@ -172,25 +172,25 @@ class PackageManagerFunTest : WordSpec({
             val pathExclude = PathExclude("$tempDir**", PathExcludeReason.TEST_OF)
             val excludes = Excludes(paths = listOf(pathExclude))
 
-            val managedFilesByName = PackageManager.findManagedFiles(rootDir, packageManagers, excludes = excludes)
-                .groupByName(rootDir)
+            val managedFilesById = PackageManager.findManagedFiles(rootDir, packageManagers, excludes = excludes)
+                .groupById(rootDir)
 
-            managedFilesByName["GradleInspector"] should containExactlyInAnyOrder(
+            managedFilesById["GradleInspector"] should containExactlyInAnyOrder(
                 "gradle-groovy/build.gradle",
                 "gradle-kotlin/build.gradle.kts"
             )
-            managedFilesByName["Maven"] should containExactly("maven/pom.xml")
-            managedFilesByName["SBT"] should containExactly("sbt/build.sbt")
+            managedFilesById["Maven"] should containExactly("maven/pom.xml")
+            managedFilesById["SBT"] should containExactly("sbt/build.sbt")
         }
 
         "handle specific excluded definition files" {
             val pathExclude = PathExclude("gradle-groovy/build.gradle", PathExcludeReason.OTHER)
             val excludes = Excludes(paths = listOf(pathExclude))
 
             val managedFiles = PackageManager.findManagedFiles(projectDir, packageManagers, excludes = excludes)
-            val managedFilesByName = managedFiles.groupByName(projectDir)
+            val managedFilesById = managedFiles.groupById(projectDir)
 
-            managedFilesByName["GradleInspector"] should containExactly(
+            managedFilesById["GradleInspector"] should containExactly(
                 "gradle-kotlin/build.gradle.kts"
             )
         }
@@ -208,9 +208,9 @@ class PackageManagerFunTest : WordSpec({
  * package managers can be easily accessed. The keys in expected and actual maps of definition files are different
  * instances of package manager factories. So to compare values use the package manager types as keys instead.
  */
-private fun ManagedProjectFiles.groupByName(projectDir: File) =
+private fun ManagedProjectFiles.groupById(projectDir: File) =
     map { (manager, files) ->
-        manager.managerName to files.map { it.relativeTo(projectDir).invariantSeparatorsPath }
+        manager.descriptor.id to files.map { it.relativeTo(projectDir).invariantSeparatorsPath }
     }.toMap()
 
 /**

analyzer/src/main/kotlin/Analyzer.kt

@@ -46,6 +46,7 @@ import org.ossreviewtoolkit.model.config.Excludes
 import org.ossreviewtoolkit.model.config.RepositoryConfiguration
 import org.ossreviewtoolkit.model.orEmpty
 import org.ossreviewtoolkit.model.toYaml
+import org.ossreviewtoolkit.plugins.api.PluginConfig
 import org.ossreviewtoolkit.plugins.packagecurationproviders.api.PackageCurationProvider
 import org.ossreviewtoolkit.utils.common.CommandLineTool
 import org.ossreviewtoolkit.utils.common.VCS_DIRECTORIES
@@ -80,7 +81,10 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
             "Using the following configuration settings:\n${repositoryConfiguration.toYaml()}"
         }
 
-        val distinctPackageManagers = packageManagers.distinct().map { it.create(config) }
+        val distinctPackageManagers = packageManagers.distinct().map {
+            val pluginOptions = config.getPackageManagerConfiguration(it.descriptor.id)?.options.orEmpty()
+            it.create(PluginConfig(pluginOptions))
+        }
 
         // Associate files by the package manager factory that manages them.
         val managedFiles = if (distinctPackageManagers.size == 1 && absoluteProjectPath.isFile) {
@@ -101,7 +105,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
 
         // Fail early if multiple managers for the same project type are enabled.
         managedFiles.keys.groupBy { it.projectType }.forEach { (projectType, managers) ->
-            val managerNames = managers.map { it.managerName }
+            val managerNames = managers.map { it.descriptor.displayName }
             requireNotNull(managers.singleOrNull()) {
                 "All of the $managerNames managers are able to manage '$projectType' projects. Please enable only " +
                     "one of them."
@@ -115,7 +119,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
             .all { it.isDirectory && (it in managedDirs || it.name in VCS_DIRECTORIES) }
 
         if (!hasOnlyManagedDirs) {
-            distinctPackageManagers.find { it.managerName == "Unmanaged" }
+            distinctPackageManagers.find { it.descriptor.id == "Unmanaged" }
                 ?.also { managedFiles[it] = listOf(absoluteProjectPath) }
         }
 
@@ -150,7 +154,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
 
         info.managedFiles.keys.forEach { manager ->
             if (manager is CommandLineTool) {
-                toolVersions[manager.managerName] = manager.getVersion()
+                toolVersions[manager.descriptor.id] = manager.getVersion()
             }
         }
 
@@ -163,7 +167,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
         logger.info { "Calling before resolution hooks for ${info.managedFiles.size} manager(s)." }
 
         info.managedFiles.forEach { (manager, definitionFiles) ->
-            manager.beforeResolution(info.absoluteProjectPath, definitionFiles)
+            manager.beforeResolution(info.absoluteProjectPath, definitionFiles, config)
         }
 
         val state = AnalyzerState()
@@ -177,6 +181,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
                     definitionFiles = files,
                     analysisRoot = info.absoluteProjectPath,
                     excludes = excludes,
+                    analyzerConfig = config,
                     labels = labels,
                     mustRunAfter = packageManagerDependencies[manager].orEmpty(),
                     finishedPackageManagersState = state.finishedPackageManagersState,
@@ -185,7 +190,7 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
             }.forEach { launch { it.start() } }
 
             state.finishedPackageManagersState.first { finishedPackageManagers ->
-                finishedPackageManagers.containsAll(info.managedFiles.keys.map { it.managerName })
+                finishedPackageManagers.containsAll(info.managedFiles.keys.map { it.descriptor.id })
             }
         }
 
@@ -201,15 +206,15 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
     private fun determinePackageManagerDependencies(info: ManagedFileInfo): Map<PackageManager, Set<String>> {
         val packageManagersWithFiles =
             info.managedFiles.keys.associateByTo(sortedMapOf(String.CASE_INSENSITIVE_ORDER)) {
-                it.managerName
+                it.descriptor.id
             }
 
         val result = mutableMapOf<PackageManager, MutableSet<String>>()
 
         info.managedFiles.keys.forEach { packageManager ->
             val dependencies =
-                packageManager.findPackageManagerDependencies(info.absoluteProjectPath, info.managedFiles)
-            val mustRunAfterConfig = config.getPackageManagerConfiguration(packageManager.managerName)?.mustRunAfter
+                packageManager.findPackageManagerDependencies(info.absoluteProjectPath, info.managedFiles, config)
+            val mustRunAfterConfig = config.getPackageManagerConfiguration(packageManager.descriptor.id)?.mustRunAfter
 
             // Configured mustRunAfter dependencies override programmatic mustRunAfter dependencies.
             val mustRunAfter = mustRunAfterConfig?.toSet() ?: dependencies.mustRunAfter
@@ -219,8 +224,8 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
 
                 if (managerForName == null) {
                     logger.debug {
-                        "Ignoring that ${packageManager.managerName} must run after $name, because there are no " +
-                            "definition files for $name."
+                        "Ignoring that ${packageManager.descriptor.displayName} must run after $name, because there " +
+                            "are no definition files for $name."
                     }
                 } else {
                     result.getOrPut(packageManager) { mutableSetOf() } += name
@@ -235,11 +240,11 @@ class Analyzer(private val config: AnalyzerConfiguration, private val labels: Ma
 
                 if (managerForName == null) {
                     logger.debug {
-                        "Ignoring that ${packageManager.managerName} must run before $name, because there are no " +
-                            "definition files for $name."
+                        "Ignoring that ${packageManager.descriptor.displayName} must run before $name, because there " +
+                            "are no definition files for $name."
                     }
                 } else {
-                    result.getOrPut(managerForName) { mutableSetOf() } += packageManager.managerName
+                    result.getOrPut(managerForName) { mutableSetOf() } += packageManager.descriptor.id
                 }
             }
         }
@@ -261,10 +266,10 @@ private class AnalyzerState {
             addMutex.withLock {
                 result.projectResults.values.flatten().forEach { builder.addResult(it) }
                 result.dependencyGraph?.let {
-                    builder.addDependencyGraph(manager.managerName, it).addPackages(result.sharedPackages)
+                    builder.addDependencyGraph(manager.descriptor.id, it).addPackages(result.sharedPackages)
                 }
 
-                _finishedPackageManagersState.value = (_finishedPackageManagersState.value + manager.managerName)
+                _finishedPackageManagersState.value = (_finishedPackageManagersState.value + manager.descriptor.id)
                     .toSortedSet(String.CASE_INSENSITIVE_ORDER)
             }
         }
@@ -297,6 +302,11 @@ private class PackageManagerRunner(
      */
     val excludes: Excludes,
 
+    /**
+     * The [AnalyzerConfiguration] to use.
+     */
+    val analyzerConfig: AnalyzerConfiguration,
+
     /**
      * The labels passed to ORT.
      */
@@ -328,8 +338,8 @@ private class PackageManagerRunner(
 
                 if (remaining.isNotEmpty()) {
                     logger.info {
-                        "${manager.managerName} is waiting for the following package managers to complete: " +
-                            remaining.joinToString(postfix = ".")
+                        "${manager.descriptor.displayName} is waiting for the following package managers to " +
+                            "complete: ${remaining.joinToString(postfix = ".")}"
                     }
                 }
 
@@ -341,12 +351,12 @@ private class PackageManagerRunner(
     }
 
     private suspend fun run() {
-        logger.info { "Starting ${manager.managerName} analysis." }
+        logger.info { "Starting ${manager.descriptor.displayName} analysis." }
 
         withContext(Dispatchers.IO.limitedParallelism(20)) {
-            val result = manager.resolveDependencies(analysisRoot, definitionFiles, excludes, labels)
+            val result = manager.resolveDependencies(analysisRoot, definitionFiles, excludes, analyzerConfig, labels)
 
-            logger.info { "Finished ${manager.managerName} analysis." }
+            logger.info { "Finished ${manager.descriptor.displayName} analysis." }
 
             onResult(result)
         }