gradle-oci/build.gradle.kts at main · SgtSilvio/gradle-oci · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
import org.gradle.plugin.compatibility.compatibility
import org.jetbrains.kotlin.gradle.dsl.KotlinVersion

plugins {
    `kotlin-dsl`
    signing
    alias(libs.plugins.pluginPublish)
    alias(libs.plugins.defaults)
    alias(libs.plugins.metadata)
}

group = "io.github.sgtsilvio.gradle"

metadata {
    readableName = "Gradle OCI Plugin"
    description = "Gradle plugin to ease using and producing (multi-arch) OCI images without requiring external tools"
    license {
        apache2()
    }
    developers {
        register("SgtSilvio") {
            fullName = "Silvio Giebl"
        }
    }
    github {
        org = "SgtSilvio"
        issues()
    }
}

kotlin {
    jvmToolchain(11)
}

tasks.compileKotlin {
    compilerOptions {
        apiVersion = KotlinVersion.KOTLIN_2_0
        languageVersion = KotlinVersion.KOTLIN_2_0
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(libs.caffeine)
    implementation(libs.commons.codec)
    implementation(libs.commons.compress)
    implementation(libs.commons.io)
    implementation(libs.commons.lang)
    implementation(libs.json)
    implementation(libs.reactor.kotlin)
    implementation(libs.reactor.netty) {
        exclude("io.netty", "netty-transport-native-epoll")
        exclude("io.netty.incubator", "netty-incubator-codec-native-quic")
    }
    implementation(platform(libs.netty.bom))
    runtimeOnly(variantOf(libs.netty.resolver.dns.native.macos) { classifier("osx-aarch_64") })
    runtimeOnly(variantOf(libs.netty.resolver.dns.native.macos) { classifier("osx-x86_64") })
    implementation(libs.oci.registry)
}

gradlePlugin {
    plugins {
        create("oci") {
            id = "$group.$name"
            implementationClass = "$group.$name.OciPlugin"
            tags = listOf("oci", "oci-image", "docker", "docker-image", "multi-arch")
            compatibility {
                features {
                    configurationCache = true
                }
            }
        }
    }
}

signing {
    val signingKey = providers.gradleProperty("signingKey").orNull
    val signingPassword = providers.gradleProperty("signingPassword").orNull
    useInMemoryPgpKeys(signingKey, signingPassword)
}

testing {
    suites {
        withType<JvmTestSuite> {
            useJUnitJupiter(libs.versions.junit.jupiter)
        }
        register<JvmTestSuite>("functionalTest") {
            dependencies {
                implementation(libs.json)
            }
            targets.configureEach {
                testTask {
                    javaLauncher = javaToolchains.launcherFor {
                        languageVersion = JavaLanguageVersion.of(17)
                    }
                    environment(
                        "ORG_GRADLE_PROJECT_dockerHubUsername" to ToStringProvider(providers.gradleProperty("dockerHubUsername")),
                        "ORG_GRADLE_PROJECT_dockerHubPassword" to ToStringProvider(providers.gradleProperty("dockerHubPassword")),
                    )
                }
            }
        }
    }

    tasks.check {
        dependsOn(suites)
    }

    gradlePlugin {
        testSourceSets(sourceSets["functionalTest"])
    }
}

class ToStringProvider(private val provider: Provider<String>) {
    override fun toString() = provider.get()
}