Skip to content

Commit 1332623

Browse files
WolfyScriptWolfyScript
committed
refactor: remove afterEvaluate and improve property flow
1 parent 80f1794 commit 1332623

File tree

4 files changed

+134
-112
lines changed

4 files changed

+134
-112
lines changed

‎docker-tools/src/main/kotlin/com/wolfyscript/devtools/docker/minecraft/MinecraftServersExtension.kt‎

Lines changed: 86 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,101 @@
11
package com.wolfyscript.devtools.docker.minecraft
22

3+
import com.wolfyscript.devtools.docker.Constants
4+
import com.wolfyscript.devtools.docker.run.DockerRunExtension
5+
import com.wolfyscript.devtools.docker.run.DockerRunTask
6+
import com.wolfyscript.devtools.docker.run.DockerStopTask
37
import org.gradle.api.NamedDomainObjectContainer
8+
import org.gradle.api.Project
49
import org.gradle.api.file.DirectoryProperty
10+
import org.gradle.api.file.RegularFile
11+
import org.gradle.api.model.ObjectFactory
512
import org.gradle.api.provider.Property
13+
import org.gradle.api.tasks.Copy
614
import org.gradle.api.tasks.Optional
15+
import org.gradle.kotlin.dsl.getByName
16+
import org.gradle.kotlin.dsl.register
17+
import kotlin.collections.toMutableMap
718

8-
interface MinecraftServersExtension {
19+
abstract class MinecraftServersExtension(objects: ObjectFactory, project: Project) {
920

10-
val servers : NamedDomainObjectContainer<ServerEntry>
21+
val servers : NamedDomainObjectContainer<ServerEntry> = objects.domainObjectContainer(ServerEntry::class.java)
22+
23+
init {
24+
servers.all {
25+
serverDir.convention(serversDir)
26+
libDir.convention(this@MinecraftServersExtension.libDir)
27+
libName.convention(this@MinecraftServersExtension.libName)
28+
destFileName.convention("${project.name}.jar")
29+
}
30+
servers.all {
31+
val serverPath: String = serverDir.get().asFile.path
32+
val runExtension = project.extensions.getByName<DockerRunExtension>(Constants.EXT_MINECRAFT_RUN_NAME)
33+
34+
val copyTask = project.tasks.register<Copy>("${name}_copy") {
35+
group = Constants.TASK_MINECRAFT_RUN_GROUP_NAME
36+
37+
dependsOn(project.tasks.getByName("jar"))
38+
39+
if (project.tasks.findByName("shadowJar") != null) {
40+
dependsOn("shadowJar")
41+
}
42+
43+
val file: RegularFile = libDir.get().file(libName.get())
44+
println("copy: ${file.asFile.path} to server $serverPath/plugins")
45+
from(file)
46+
rename(".*", destFileName.get())
47+
into("$serverPath/plugins")
48+
}
49+
50+
val stopTask = project.tasks.register<DockerStopTask>("${name}_stop") {
51+
group = Constants.TASK_MINECRAFT_RUN_GROUP_NAME
52+
53+
name.convention("${runExtension.name.get()}_${this@all.name}")
54+
}
55+
56+
project.tasks.register<DockerRunTask>("${name}_run") {
57+
group = Constants.TASK_MINECRAFT_RUN_GROUP_NAME
58+
dependsOn(copyTask)
59+
dependsOn(stopTask)
60+
61+
applyExtension(runExtension)
62+
63+
name.convention("${runExtension.name.get()}_${this@all.name}")
64+
project.mkdir(serverPath)
65+
66+
// merge all the ports instead of replacing them (convention)
67+
ports.addAll(runExtension.ports)
68+
ports.addAll(this@all.ports)
69+
70+
if (imageVersion.isPresent) {
71+
image.set("${image.get()}:${imageVersion.get()}")
72+
}
73+
74+
val customEnv = env.get().toMutableMap()
75+
if (version.isPresent) {
76+
customEnv["VERSION"] = version.get()
77+
}
78+
if (type.isPresent) {
79+
customEnv["TYPE"] = type.get()
80+
}
81+
if (extraEnv.isPresent) {
82+
customEnv.putAll(extraEnv.get())
83+
}
84+
env.set(customEnv)
85+
86+
val customVolumes = volumes.get().toMutableMap()
87+
customVolumes[serverPath] = "/data"
88+
volumes.set(customVolumes)
89+
}
90+
}
91+
}
1192

1293
@get:Optional
13-
val serversDir : DirectoryProperty
94+
val serversDir : DirectoryProperty = objects.directoryProperty().convention(project.layout.projectDirectory.dir("test_servers"))
1495

15-
val libName: Property<String>
96+
val libName: Property<String> = objects.property(String::class.java).convention("${project.name}-${project.version}.jar")
1697

1798
@get:Optional
18-
val libDir: DirectoryProperty
99+
val libDir: DirectoryProperty = objects.directoryProperty().convention(project.layout.buildDirectory.dir("libs"))
19100

20101
}

‎docker-tools/src/main/kotlin/com/wolfyscript/devtools/docker/minecraft/MinecraftServersPlugin.kt‎

Lines changed: 18 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -1,100 +1,34 @@
11
package com.wolfyscript.devtools.docker.minecraft
22

3+
import com.wolfyscript.devtools.docker.Constants
34
import com.wolfyscript.devtools.docker.run.DockerRunExtension
4-
import com.wolfyscript.devtools.docker.run.DockerRunTask
5-
import com.wolfyscript.devtools.docker.run.DockerStopTask
65
import org.gradle.api.Plugin
76
import org.gradle.api.Project
8-
import org.gradle.api.file.Directory
9-
import org.gradle.api.file.RegularFile
10-
import org.gradle.api.provider.Property
11-
import org.gradle.api.tasks.Copy
127
import org.gradle.kotlin.dsl.create
13-
import org.gradle.kotlin.dsl.getByType
14-
import org.gradle.kotlin.dsl.task
158

169
class MinecraftServersPlugin : Plugin<Project> {
1710

1811
override fun apply(target: Project) {
19-
target.extensions.create<MinecraftServersExtension>("minecraftServers")
20-
21-
val defaultMCDockerRun = target.extensions.create<DockerRunExtension>("minecraftDockerRun").apply {
22-
name.set("test_mc_server");
23-
image.set("itzg/minecraft-server");
24-
daemonize.set(true);
25-
clean.set(true);
26-
27-
ports("25565:25565")
28-
29-
env(buildMap {
12+
target.extensions.create(
13+
Constants.EXT_MINECRAFT_SERVERS_NAME,
14+
MinecraftServersExtension::class,
15+
target.objects,
16+
target
17+
)
18+
19+
target.extensions.create<DockerRunExtension>(
20+
Constants.EXT_MINECRAFT_RUN_NAME,
21+
target.objects,
22+
target
23+
).apply {
24+
name.convention("test_mc_server")
25+
image.convention("itzg/minecraft-server")
26+
env.convention(buildMap {
3027
this["EULA"] = "TRUE" // Enable by default. setting it to false makes no sense
3128
this["USE_AIKAR_FLAGS"] = "TRUE" // Recommended, so gonna enable it by default
3229
})
33-
34-
arguments("-it") // Allow for console interactivity with 'docker attach'
35-
}
36-
37-
target.afterEvaluate {
38-
39-
val serversExtension: MinecraftServersExtension = target.extensions.getByType<MinecraftServersExtension>()
40-
val directory : Directory = serversExtension.serversDir.getOrElse(target.layout.projectDirectory.dir("test_servers"))
41-
val libDir: Directory = serversExtension.libDir.orElse(target.layout.buildDirectory.dir("libs")).getOrElse(target.layout.projectDirectory.dir("/build/libs"))
42-
val libName: Property<String> = serversExtension.libName
43-
44-
for (serverEntry in serversExtension.servers) {
45-
val serverName: String = serverEntry.name
46-
val serverPath: String = serverEntry.serverDir.getOrElse(directory.dir(serverName)).asFile.path
47-
48-
val copyTask = target.task<Copy>("${serverName}_copy") {
49-
dependsOn(target.tasks.getByName("jar"))
50-
dependsOn("shadowJar")
51-
52-
val file: RegularFile = serverEntry.libDir.getOrElse(libDir).file(serverEntry.libName.getOrElse(libName.getOrElse("${target.project.name}-${target.project.version}.jar")))
53-
println("Configure Copy: ${file.asFile.path} to server $serverPath/plugins")
54-
from(file)
55-
rename(".*", serverEntry.destFileName.getOrElse("${target.project.name}.jar"))
56-
into("$serverPath/plugins")
57-
}
58-
59-
val stopTask = target.task<DockerStopTask>("${serverName}_stop") {
60-
applyExtension(defaultMCDockerRun)
61-
name.set("${name.get()}_$serverName")
62-
}
63-
64-
target.task<DockerRunTask>("${serverName}_run") {
65-
dependsOn(copyTask)
66-
dependsOn(stopTask)
67-
68-
applyExtension(defaultMCDockerRun)
69-
name.set("${name.get()}_$serverName")
70-
71-
println(serverPath)
72-
mkdir(serverPath)
73-
74-
ports.set(serverEntry.ports.get())
75-
76-
val customEnv = env.get().toMutableMap()
77-
if (serverEntry.imageVersion.isPresent) {
78-
image.set("${image.get()}:${serverEntry.imageVersion.get()}")
79-
}
80-
if (serverEntry.version.isPresent) {
81-
customEnv["VERSION"] = serverEntry.version.get()
82-
}
83-
if (serverEntry.type.isPresent) {
84-
customEnv["TYPE"] = serverEntry.type.get()
85-
}
86-
if (serverEntry.extraEnv.isPresent) {
87-
customEnv.putAll(serverEntry.extraEnv.get())
88-
}
89-
env.set(customEnv)
90-
91-
val customVolumes = volumes.get().toMutableMap()
92-
customVolumes[serverPath] = "/data"
93-
volumes.set(customVolumes)
94-
}
95-
96-
}
97-
30+
ports.convention(listOf("25565:25565"))
31+
arguments.convention(listOf("-it")) // Allow for console interactivity with 'docker attach'
9832
}
9933

10034
}

‎docker-tools/src/main/kotlin/com/wolfyscript/devtools/docker/run/DockerRunExtension.kt‎

Lines changed: 22 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,40 +1,46 @@
11
package com.wolfyscript.devtools.docker.run
22

3+
import org.gradle.api.Project
4+
import org.gradle.api.model.ObjectFactory
35
import org.gradle.api.provider.ListProperty
46
import org.gradle.api.provider.MapProperty
57
import org.gradle.api.provider.Property
68
import org.gradle.api.provider.SetProperty
79
import org.gradle.api.tasks.Input
810
import org.gradle.api.tasks.Optional
11+
import org.gradle.kotlin.dsl.listProperty
12+
import org.gradle.kotlin.dsl.mapProperty
13+
import org.gradle.kotlin.dsl.property
14+
import org.gradle.kotlin.dsl.setProperty
915

10-
abstract class DockerRunExtension {
16+
abstract class DockerRunExtension(objects: ObjectFactory, project: Project) {
1117

1218
/**
1319
* The name of the container
1420
*/
1521
@get:Input
16-
abstract val name: Property<String>
22+
val name: Property<String> = objects.property<String>()
1723

1824
/**
1925
* The image of the container
2026
*/
2127
@get:Input
22-
abstract val image: Property<String>
28+
val image: Property<String> = objects.property<String>()
2329

2430
/**
2531
* The network to add the container to
2632
*/
2733
@get:Input
2834
@get:Optional
29-
abstract val network: Property<String>
35+
val network: Property<String> = objects.property<String>()
3036

3137
/**
3238
* Specifies if the container should be run as a daemon
3339
* Enabled by default, if disabled will run the container inside the task and stopping the task will stop the container.
3440
*/
3541
@get:Input
3642
@get:Optional
37-
abstract val daemonize: Property<Boolean>
43+
val daemonize: Property<Boolean> = objects.property<Boolean>().convention(true)
3844

3945
/**
4046
* Specifies if the container should be removed when stopped.
@@ -43,31 +49,31 @@ abstract class DockerRunExtension {
4349
*/
4450
@get:Input
4551
@get:Optional
46-
abstract val clean: Property<Boolean>
52+
val clean: Property<Boolean> = objects.property<Boolean>().convention(true)
4753

4854
@get:Input
4955
@get:Optional
50-
abstract val ignoreExitValue: Property<Boolean>
56+
val ignoreExitValue: Property<Boolean> = objects.property<Boolean>().convention(true)
5157

5258
@get:Input
5359
@get:Optional
54-
abstract val command: ListProperty<String>
60+
val command: ListProperty<String> = objects.listProperty<String>()
5561

5662
@get:Input
5763
@get:Optional
58-
abstract val env: MapProperty<String, String>
64+
val env: MapProperty<String, String> = objects.mapProperty<String, String>()
5965

60-
abstract val ports: SetProperty<String>
66+
val ports: SetProperty<String> = objects.setProperty<String>()
6167

62-
abstract val arguments: ListProperty<String>
68+
val arguments: ListProperty<String> = objects.listProperty<String>()
6369

6470
/**
6571
* Volume mappings and bindings of the container
6672
*/
67-
abstract val volumes: MapProperty<Any, String>
73+
val volumes: MapProperty<Any, String> = objects.mapProperty<Any, String>().empty()
6874

6975
fun arguments(vararg arguments: String) {
70-
this.arguments.set(listOf(elements = arguments))
76+
this.arguments.addAll(*arguments)
7177
}
7278

7379
/**
@@ -80,7 +86,7 @@ abstract class DockerRunExtension {
8086
* @param ports List of port mappings
8187
*/
8288
fun ports(vararg ports: String) {
83-
this.ports.set(buildSet {
89+
this.ports.addAll(buildSet {
8490
for (port in ports) {
8591
val mapping = port.split(":", limit = 2)
8692
if (mapping.size == 1) {
@@ -102,11 +108,11 @@ abstract class DockerRunExtension {
102108
}
103109

104110
fun volumes(volumes: Map<Any, String>) {
105-
this.volumes.set(volumes.toMap())
111+
this.volumes.putAll(volumes)
106112
}
107113

108114
fun env(env: Map<String, String>) {
109-
this.env.set(env.toMap())
115+
this.env.putAll(env)
110116
}
111117

112118
}

‎docker-tools/src/main/kotlin/com/wolfyscript/devtools/docker/run/DockerRunPlugin.kt‎

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,26 @@
11
package com.wolfyscript.devtools.docker.run
22

3+
import com.wolfyscript.devtools.docker.Constants
34
import org.gradle.api.Plugin
45
import org.gradle.api.Project
56
import org.gradle.kotlin.dsl.*
67

78
class DockerRunPlugin : Plugin<Project> {
89

910
override fun apply(target: Project) {
10-
val extension = target.extensions.create<DockerRunExtension>("DockerRunExtension")
11-
target.extensions.add("dockerRun", extension)
11+
val extension = target.extensions.create<DockerRunExtension>(Constants.EXT_DOCKER_RUN_NAME)
1212

13-
target.tasks.register<DockerRunTask>("dockerRun") {
13+
target.tasks.register<DockerRunTask>(Constants.TASK_DOCKER_RUN_NAME) {
14+
group = Constants.TASK_DOCKER_RUN_GROUP_NAME
1415
applyExtension(extension)
1516
}
1617

17-
target.tasks.register("dockerStatus") {
18-
19-
18+
target.tasks.register(Constants.TASK_DOCKER_STATUS_NAME) {
19+
group = Constants.TASK_DOCKER_RUN_GROUP_NAME
2020
}
2121

22-
target.tasks.register<DockerStopTask>("dockerStop") {
22+
target.tasks.register<DockerStopTask>(Constants.TASK_DOCKER_STOP_NAME) {
23+
group = Constants.TASK_DOCKER_RUN_GROUP_NAME
2324
applyExtension(extension)
2425
}
2526

0 commit comments

Comments
 (0)