added wildfly plugin

build.gradle

@@ -1,7 +1,10 @@
-allprojects {
+subprojects {
     apply plugin: 'java-library'
+    apply plugin: 'maven-publish'
     repositories {
-        mavenLocal()
+        maven {
+            url = woggioniMavenRepositoryUrl
+        }
         mavenCentral()
         jcenter()
     }
@@ -20,10 +23,23 @@ allprojects {
     tasks.named("test", Test) {
         useJUnitPlatform()
     }
+
+    publishing {
+        repositories {
+            maven {
+                url = woggioniMavenRepositoryUrl
+            }
+        }
+        publications {
+            maven(MavenPublication) {
+                from(components["java"])
+            }
+        }
+    }
 }
 
 wrapper {
-    gradleVersion = "6.8"
+    gradleVersion = "7.0.2"
     distributionType = Wrapper.DistributionType.ALL
 }
 

gradle.properties

@@ -1,6 +1,9 @@
+woggioniMavenRepositoryUrl=https://mvn.woggioni.net/
+
+
 version.kotlin=1.3.72
 version.gradlePublish=0.10.1
 version.lombok=1.18.16
 version.slf4j=1.7.30
-version.junitJupiter=5.7.0
+version.junitJupiter=5.7.2
 version.junitPlatform=1.7.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle

@@ -10,6 +10,8 @@ pluginManagement {
 }
 
 rootProject.name = "my-gradle-plugins"
+
 include("dependency-export")
 include("jpms-check")
 include("multi-release-jar")
+include("wildfly")

wildfly/build.gradle

@@ -0,0 +1,13 @@
+plugins {
+    id 'maven-publish'
+    id 'java-gradle-plugin'
+}
+
+gradlePlugin {
+    plugins {
+        create("WildflyPlugin") {
+            id = "net.woggioni.gradle.wildfly"
+            implementationClass = "net.woggioni.gradle.wildfly.WildflyPlugin"
+        }
+    }
+}

wildfly/src/main/java/net/woggioni/gradle/wildfly/Deploy2WildflyTask.java

@@ -0,0 +1,76 @@
+package net.woggioni.gradle.wildfly;
+
+import lombok.Getter;
+import org.gradle.api.file.RegularFileProperty;
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.provider.Property;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.Exec;
+import org.gradle.api.tasks.Input;
+
+import javax.annotation.Nonnull;
+import javax.inject.Inject;
+import java.util.Arrays;
+
+public class Deploy2WildflyTask extends Exec {
+    private static final String PROPERTY_PREFIX = "net.woggioni.gradle.wildfly.";
+    private static final String HOST_PROPERTY_KEY = PROPERTY_PREFIX + "rpcHost";
+    private static final String PORT_PROPERTY_KEY = PROPERTY_PREFIX + "rpcPort";
+    private static final String USER_NAME_PROPERTY_KEY = PROPERTY_PREFIX + "rpcUsername";
+    private static final String PASSWORD_PROPERTY_KEY = PROPERTY_PREFIX + "rpcPassword";
+
+    @Input
+    @Getter
+    private final Property<String> rpcHost;
+
+    @Input
+    @Getter
+    private final Property<Integer> rpcPort;
+
+    @Input
+    @Getter
+    private final Property<String> rpcUsername;
+
+    @Input
+    @Getter
+    private final Property<String> rpcPassword;
+
+    @Input
+    @Getter
+    private final RegularFileProperty artifact;
+
+    private String projectProperty(String key, String defaultValue) {
+        String result = (String) getProject().findProperty(key);
+        return result == null ? defaultValue : result;
+    }
+
+    @Inject
+    public Deploy2WildflyTask(@Nonnull ObjectFactory objectFactory) {
+        setGroup("deploy");
+        setDescription("Deploy this project artifact to Wildfly application server");
+        Provider<String> defaultHostProvider = getProject()
+                .provider(() -> projectProperty(HOST_PROPERTY_KEY, "localhost"));
+        Provider<Integer> defaultPortProvider = getProject()
+                .provider(() -> Integer.parseInt(projectProperty(PORT_PROPERTY_KEY, "9990")));
+        Provider<String> defaultUsernameProvider = getProject()
+                .provider(() -> projectProperty(USER_NAME_PROPERTY_KEY, "admin"));
+        Provider<String> defaultPasswordProvider = getProject()
+                .provider(() -> projectProperty(PASSWORD_PROPERTY_KEY, "password"));
+
+        executable("/opt/wildfly/bin/jboss-cli.sh");
+        rpcHost = objectFactory.property(String.class).convention(defaultHostProvider);
+        rpcPort = objectFactory.property(Integer.class).convention(defaultPortProvider);
+        rpcUsername = objectFactory.property(String.class).convention(defaultUsernameProvider);
+        rpcPassword = objectFactory.property(String.class).convention(defaultPasswordProvider);
+        artifact = objectFactory.fileProperty();
+
+        getArgumentProviders().add(() ->
+            Arrays.asList(
+                    "--controller=" + rpcHost.get() + ":" + rpcPort.get(),
+                    "--connect",
+                    "--user=" + rpcUsername.get(),
+                    "--password=" + rpcPassword.get(),
+                    "--command=deploy "  + artifact.getAsFile().get().getPath() + " --force")
+        );
+    }
+}

wildfly/src/main/java/net/woggioni/gradle/wildfly/WildflyPlugin.java

@@ -0,0 +1,32 @@
+package net.woggioni.gradle.wildfly;
+
+import org.gradle.api.GradleException;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.TaskCollection;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.tasks.bundling.AbstractArchiveTask;
+
+public class WildflyPlugin implements Plugin<Project> {
+    @Override
+    public void apply(Project project) {
+        project.getTasks().register("deploy2Wildfly", Deploy2WildflyTask.class, deploy2WildflyTask -> {
+            TaskCollection<AbstractArchiveTask> candidates = project.getTasks().withType(AbstractArchiveTask.class);
+            TaskProvider<AbstractArchiveTask> warTask = candidates.named("war", AbstractArchiveTask.class);
+            TaskProvider<AbstractArchiveTask> selected;
+            if(warTask.isPresent()) {
+                selected = warTask;
+            } else {
+                TaskProvider<AbstractArchiveTask> jarTask = candidates.named("jar", AbstractArchiveTask.class);
+                if(jarTask.isPresent()) {
+                    selected = jarTask;
+                } else {
+                    throw new GradleException("No suitable archiving task found in the current project");
+                }
+            }
+            deploy2WildflyTask.getInputs().files(selected);
+            deploy2WildflyTask.getArtifact()
+                .fileProvider(selected.map(t -> t.getOutputs().getFiles().getSingleFile()));
+        });
+    }
+}