CodeArtifact support for pluginManagement repositories

README.md

@@ -5,7 +5,35 @@ the token.
 
 ## Usage
 
-In your build.gradle file:
+## Init script (init.gradle.kts) usage
+
+```
+import ai.clarity.codeartifact.CodeArtifactRepositoriesPlugin
+
+initscript {
+    fun pluginAsDependency(id: String, version: String): String {
+        return "${id}:${id}.gradle.plugin:${version}"
+    }
+
+    dependencies {
+        classpath(pluginAsDependency("ai.clarity.codeartifact.repositories", "0.0.13-pluginRepositoriesSupport"))
+    }
+}
+
+settingsEvaluated {
+    settings.pluginManagement {
+        repositories {
+            maven {
+                url = uri("https://SCRUBBED.codeartifact.REGION.amazonaws.com/maven/.../")
+            }
+        }
+    }
+}
+
+apply<CodeArtifactRepositoriesPlugin>()
+```
+
+## Build script  (build.gradle) usage
 
 ```
 plugins {

build.gradle

@@ -26,7 +26,8 @@ repositories {
 dependencies {
     implementation(platform('org.junit:junit-bom:5.8.1'))
     implementation(platform("software.amazon.awssdk:bom:2.17.47"))
-
+
+    implementation('org.slf4j:slf4j-api:1.7.32')
     implementation('software.amazon.awssdk:codeartifact')
     implementation('software.amazon.awssdk:sts')
     implementation('software.amazon.awssdk:sso')
@@ -41,12 +42,15 @@ test {
 }
 
 gradlePlugin {
-    // Define the plugin
     plugins {
         clarity {
             id = 'ai.clarity.codeartifact'
             implementationClass = 'ai.clarity.codeartifact.ClarityCodeartifactPlugin'
         }
+        repositories {
+            id = 'ai.clarity.codeartifact.repositories'
+            implementationClass = 'ai.clarity.codeartifact.CodeArtifactRepositoriesPlugin'
+        }
     }
 }
 
@@ -81,6 +85,9 @@ pluginBundle {
             // id is captured from java-gradle-plugin configuration
             displayName = 'Gradle Codeartifact plugin'
         }
+        repositories {
+            displayName = 'Gradle CodeArtifact repositories plugin'
+        }
     }
 }
 

gradle.properties

@@ -1 +1 @@
-version=0.0.13-SNAPSHOT
+version=0.0.13-pluginRepositoriesSupport

src/main/groovy/ai/clarity/codeartifact/ClarityCodeartifactPlugin.groovy

@@ -15,25 +15,30 @@
  */
 package ai.clarity.codeartifact
 
-
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.artifacts.repositories.MavenArtifactRepository
-import org.gradle.api.logging.Logger
+import org.gradle.api.invocation.Gradle
 import org.gradle.api.provider.Provider
+import org.slf4j.Logger
 
 class ClarityCodeartifactPlugin implements Plugin<Project> {
     private Logger logger
 
     void apply(Project project) {
-        this.logger = project.logger;
-        Provider<CodeartifactToken> serviceProvider = project
-                .getGradle()
+        this.logger = project.logger
+        def gradle = project.getGradle()
+        def tokenProvider = codeArtifactTokenProviderForGradle(gradle)
+        setupCodeartifactRepositories(project, tokenProvider)
+        setupCodeartifactRepositoriesByUrl(project, tokenProvider)
+    }
+
+    static Provider<CodeartifactToken> codeArtifactTokenProviderForGradle(Gradle gradle) {
+        Provider<CodeartifactToken> serviceProvider = gradle
                 .getSharedServices()
                 .registerIfAbsent('codeartifact-token', CodeartifactToken.class, {})
-        setupCodeartifactRepositories(project, serviceProvider)
-        setupCodeartifactRepositoriesByUrl(project, serviceProvider)
+        serviceProvider
     }
 
     private void setupCodeartifactRepositories(Project project, Provider<CodeartifactToken> serviceProvider) {
@@ -57,60 +62,62 @@ class ClarityCodeartifactPlugin implements Plugin<Project> {
         }
     }
 
-    private void setupCodeartifactRepositoriesByUrl(Project project, Provider<CodeartifactToken> serviceProvider) {
-        project.afterEvaluate({ p ->
-            configRepositories(p.repositories, serviceProvider)
+    static void setupCodeartifactRepositoriesByUrl(Project project, Provider<CodeartifactToken> serviceProvider) {
+        project.afterEvaluate({ Project p ->
+            configRepositories(p.logger, p.repositories, serviceProvider)
             p.plugins.withId('maven-publish', { publishPlugin ->
                 p.extensions.configure('publishing', { publishing ->
-                    configRepositories(publishing.getRepositories(), serviceProvider)
+                    configRepositories(p.logger, publishing.getRepositories(), serviceProvider)
                 })
             })
         })
     }
 
-    private void configRepositories(RepositoryHandler repositories, Provider<CodeartifactToken> serviceProvider) {
+    static void configRepositories(Logger logger, RepositoryHandler repositories, Provider<CodeartifactToken> serviceProvider) {
+        logger.info("configRepositories({})", Thread.currentThread().name, repositories.join(","))
         ListIterator it = repositories.listIterator()
         while (it.hasNext()) {
             def artifactRepository = it.next()
             if (artifactRepository instanceof MavenArtifactRepository) {
                 MavenArtifactRepository mavenRepo = (MavenArtifactRepository) artifactRepository;
-                URI repoUri = mavenRepo.getUrl()
-                if (isCodeArtifactUri(repoUri) && areCredentialsEmpty(mavenRepo)) {
+                def repoUri = mavenRepo.getUrl()
+                def hasCodeArtifactUri = isCodeArtifactUri(repoUri)
+                logger.info("MavenArtifactRepository {} hasCodeArtifactUri:{}", repoUri, hasCodeArtifactUri)
+                if (hasCodeArtifactUri && areCredentialsEmpty(mavenRepo)) {
                     String profile = getProfileFromUri(repoUri, getDefaultProfile())
                     logger.info('Getting token for {} in profile {}', repoUri.toString(), profile)
                     String token = serviceProvider.get().getToken(repoUri, profile)
-                    mavenRepo.credentials({
+                    mavenRepo.credentials {
                         username 'aws'
                         password token
-                    })
-
+                    }
                     mavenRepo.setUrl(removeProfile(repoUri))
                 }
             }
         }
     }
 
-    private String getDefaultProfile() {
+    private static String getDefaultProfile() {
         return System.getProperty("codeartifact.profile", System.getenv("CODEARTIFACT_PROFILE"));
     }
 
-    private URI removeProfile(URI uri) {
+    private static URI removeProfile(URI uri) {
         return URIBuilder.of(uri).removeQueryParam("profile").toURI();
     }
 
-    private boolean areCredentialsEmpty(MavenArtifactRepository mavenRepo) {
+    private static boolean areCredentialsEmpty(MavenArtifactRepository mavenRepo) {
         return mavenRepo.getCredentials().getPassword() == null && mavenRepo.getCredentials().getUsername() == null
     }
 
-    private boolean isCodeArtifactUri(URI uri) {
+    private static boolean isCodeArtifactUri(URI uri) {
         return uri.toString().matches('(?i).+\\.codeartifact\\..+\\.amazonaws\\..+')
     }
 
-    private String getProfileFromUri(URI uri, String defaultValue) {
+    private static String getProfileFromUri(URI uri, String defaultValue) {
         def value = URIBuilder.of(uri).getQueryParamValue("profile")
         if (value == null) {
             value = defaultValue;
         }
         return value;
     }
-}
+}

src/main/groovy/ai/clarity/codeartifact/CodeArtifactRepositoriesPlugin.groovy

@@ -0,0 +1,28 @@
+package ai.clarity.codeartifact
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.initialization.Settings
+import org.gradle.api.invocation.Gradle
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+import static ai.clarity.codeartifact.ClarityCodeartifactPlugin.*
+
+class CodeArtifactRepositoriesPlugin implements Plugin<Gradle> {
+    static Logger logger = LoggerFactory.getLogger(CodeArtifactRepositoriesPlugin)
+
+    @Override
+    void apply(Gradle gradle) {
+        def tokenProvider = codeArtifactTokenProviderForGradle(gradle)
+        gradle.settingsEvaluated { Settings settings ->
+            def pluginRepositories = settings.pluginManagement.repositories
+            logger.info("settingsEvaluated() block in {} (settings:{}, pluginRepositories:{})", CodeArtifactRepositoriesPlugin, settings, pluginRepositories.asMap)
+            configRepositories(logger, pluginRepositories, tokenProvider)
+        }
+        gradle.allprojects { Project project ->
+            logger.info("allprojects() block in {} (project: {})", CodeArtifactRepositoriesPlugin,  project)
+            setupCodeartifactRepositoriesByUrl(project, tokenProvider)
+        }
+    }
+}