Centralize smoke app Gradle proxy setup

build-logic/smoke-test/src/main/kotlin/datadog/buildlogic/smoketest/NestedGradleBuild.kt

@@ -54,6 +54,8 @@ abstract class NestedGradleBuild @Inject constructor(
     gradleDistributionBaseUrl.convention(
       project.providers.environmentVariable(MASS_READ_URL_ENV),
     )
+    initScripts.convention(emptyList())
+    gradleProperties.convention(emptyMap())
     javaLauncher.convention(
       javaToolchains.launcherFor {
         languageVersion.set(JavaLanguageVersion.of(DEFAULT_NESTED_JAVA_VERSION))
@@ -84,6 +86,12 @@ abstract class NestedGradleBuild @Inject constructor(
   @get:Optional
   abstract val gradleDistributionBaseUrl: Property<String>
 
+  @get:Input
+  abstract val initScripts: ListProperty<String>
+
+  @get:Input
+  abstract val gradleProperties: MapProperty<String, String>
+
   @get:Nested
   abstract val javaLauncher: Property<JavaLauncher>
 
@@ -143,10 +151,18 @@ abstract class NestedGradleBuild @Inject constructor(
     val appBuildDirFile = applicationBuildDir.get().asFile
     val daemonJavaHome = javaLauncher.get().metadata.installationPath.asFile
     val gradleUserHomeDir = createGradleUserHome()
+    val initScriptFiles = writeInitScripts()
 
     val args = buildList {
+      initScriptFiles.forEach { script ->
+        add("--init-script")
+        add(script.absolutePath)
+      }
       add(if (buildCacheEnabled.get()) "--build-cache" else "--no-build-cache")
       add("-PappBuildDir=${appBuildDirFile.absolutePath}")
+      gradleProperties.get().forEach { (name, value) ->
+        addGradleProperty(name, value)
+      }
       projectJars.get().forEach { entry ->
         add("-P${entry.propertyName.get()}=${entry.file.get().asFile.absolutePath}")
       }
@@ -240,6 +256,13 @@ abstract class NestedGradleBuild @Inject constructor(
     }
   }
 
+  private fun writeInitScripts(): List<File> =
+    initScripts.get().mapIndexed { index, script ->
+      temporaryDir.resolve("init-$index.init.gradle.kts").also { file ->
+        file.writeText(script)
+      }
+    }
+
   private fun findGradleExecutable(gradleUserHomeDir: File): File? =
     gradleUserHomeDir.walkTopDown().firstOrNull { file ->
       file.isFile &&
@@ -275,3 +298,14 @@ abstract class NestedGradleBuild @Inject constructor(
     const val GRADLE_STOP_TIMEOUT_SECONDS = 30L
   }
 }
+
+private fun MutableList<String>.addGradleProperty(name: String, value: String?) {
+  if (!value.isNullOrBlank()) {
+    add("-P$name=$value")
+  }
+}
+
+internal val PROXY_REPOSITORIES_INIT_SCRIPT: String =
+  NestedGradleBuild::class.java.getResource("proxy-repositories.init.gradle.kts")
+    ?.readText()
+    ?: error("Missing proxy-repositories.init.gradle.kts resource")

build-logic/smoke-test/src/main/kotlin/datadog/buildlogic/smoketest/SmokeTestAppExtension.kt

@@ -65,6 +65,10 @@ abstract class SmokeTestAppExtension @Inject constructor(
 
   internal abstract val projectJars: ListProperty<NestedBuildProjectJar>
 
+  internal abstract val initScripts: ListProperty<String>
+
+  internal abstract val gradleProperties: MapProperty<String, String>
+
   init {
     applicationDir.convention(project.layout.projectDirectory.dir("application"))
     applicationBuildDir.convention(project.layout.buildDirectory.dir("application"))
@@ -77,6 +81,28 @@ abstract class SmokeTestAppExtension @Inject constructor(
         languageVersion.set(JavaLanguageVersion.of(DEFAULT_NESTED_JAVA_VERSION))
       },
     )
+
+    val isCi = project.providers.environmentVariable("CI")
+      .map { it.equals("true", ignoreCase = true) }
+      .orElse(false)
+    initScripts.convention(
+      isCi.map {
+        if (it) {
+          listOf(PROXY_REPOSITORIES_INIT_SCRIPT)
+        } else {
+          emptyList()
+        }
+      },
+    )
+    gradleProperties.convention(
+      isCi.map {
+        if (it) {
+          proxyGradleProperties()
+        } else {
+          emptyMap()
+        }
+      },
+    )
   }
 
   /**
@@ -189,6 +215,20 @@ abstract class SmokeTestAppExtension @Inject constructor(
       },
     )
   }
+
+  private fun proxyGradleProperties(): Map<String, String> {
+    val properties = mutableMapOf<String, String>()
+    addGradleProperty(properties, "gradlePluginProxy")
+    addGradleProperty(properties, "mavenRepositoryProxy")
+    return properties
+  }
+
+  private fun addGradleProperty(properties: MutableMap<String, String>, name: String) {
+    val value = project.providers.gradleProperty(name).orNull
+    if (!value.isNullOrBlank()) {
+      properties[name] = value
+    }
+  }
 }
 
 /** DSL describing the nested-build invocation for one smoke-test application. */

build-logic/smoke-test/src/main/kotlin/datadog/buildlogic/smoketest/SmokeTestAppPlugin.kt

@@ -3,6 +3,7 @@ package datadog.buildlogic.smoketest
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.withType
 
 /**
  * Exposes the [NestedGradleBuild] task type plus a `smokeTestApp` extension that wires the
@@ -16,6 +17,10 @@ import org.gradle.kotlin.dsl.create
  */
 class SmokeTestAppPlugin : Plugin<Project> {
   override fun apply(project: Project) {
-    project.extensions.create<SmokeTestAppExtension>("smokeTestApp")
+    val extension = project.extensions.create<SmokeTestAppExtension>("smokeTestApp")
+    project.tasks.withType<NestedGradleBuild>().configureEach {
+      initScripts.convention(extension.initScripts)
+      gradleProperties.convention(extension.gradleProperties)
+    }
   }
 }

build-logic/smoke-test/src/main/resources/datadog/buildlogic/smoketest/proxy-repositories.init.gradle.kts

@@ -0,0 +1,41 @@
+import org.gradle.api.Action
+import org.gradle.api.Project
+import org.gradle.api.initialization.Settings
+
+gradle.beforeSettings(Action<Settings> {
+  val gradlePluginProxy = providers.gradleProperty("gradlePluginProxy").orNull
+  val mavenRepositoryProxy = providers.gradleProperty("mavenRepositoryProxy").orNull
+
+  pluginManagement {
+    repositories {
+      mavenLocal()
+      gradlePluginProxy?.takeIf { it.isNotBlank() }?.let { proxy ->
+        maven {
+          url = java.net.URI(proxy)
+          isAllowInsecureProtocol = true
+        }
+      }
+      mavenRepositoryProxy?.takeIf { it.isNotBlank() }?.let { proxy ->
+        maven {
+          url = java.net.URI(proxy)
+          isAllowInsecureProtocol = true
+        }
+      }
+      gradlePluginPortal()
+      mavenCentral()
+    }
+  }
+
+  gradle.beforeProject(Action<Project> {
+    repositories {
+      mavenLocal()
+      mavenRepositoryProxy?.takeIf { it.isNotBlank() }?.let { proxy ->
+        maven {
+          url = java.net.URI(proxy)
+          isAllowInsecureProtocol = true
+        }
+      }
+      mavenCentral()
+    }
+  })
+})