initial implement

src/main/java/org/attias/open/interactive/simulation/deployer/SimulationDeployerPlugin.java

@@ -1,9 +1,14 @@
 package org.attias.open.interactive.simulation.deployer;
 
+import org.attias.open.interactive.simulation.deployer.dsl.SimulationDeployerExtension;
+import org.attias.open.interactive.simulation.deployer.tasks.InitializeDeployerTask;
 import org.attias.open.interactive.simulation.deployer.utils.ExtensionUtils;
+import org.attias.open.interactive.simulation.deployer.utils.PluginUtils;
 import org.attias.open.interactive.simulation.deployer.utils.TaskUtils;
+import org.gradle.api.GradleException;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
+import org.gradle.api.tasks.TaskProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -12,7 +17,23 @@ public class SimulationDeployerPlugin implements Plugin<Project> {
 
     @Override
     public void apply(Project target) {
-        SimulationDeployerExtension extension = ExtensionUtils.getPluginExtensionOrCreateDefault(target);
-        TaskUtils.addRunSimulationTask(target);
+        if (!isProjectCompatible(target)) {
+            throw new GradleException("Can't apply IOS Deployer Plugin on " + target.getPath());
+        }
+        ExtensionUtils.getPluginExtensionOrCreateDefault(target);
+        TaskProvider<InitializeDeployerTask> initTask = TaskUtils.addInitializeDeployerTask(target);
+        TaskUtils.addRunDesktopTask(target, initTask);
+    }
+
+    public boolean isProjectCompatible(Project project) {
+        // not working
+//        project.getBuildscript().getRepositories().add(project.getBuildscript().getRepositories().mavenLocal());
+//        project.getBuildscript().getRepositories().add(project.getBuildscript().getRepositories().mavenCentral());
+//        project.getBuildscript().getRepositories().add(project.getBuildscript().getRepositories().gradlePluginPortal());
+//        project.getBuildscript().getRepositories().add(project.getBuildscript().getRepositories().maven(repo -> {
+//            repo.setUrl("https://oss.sonatype.org/content/repositories/snapshots/");
+//        }));
+//        project.getBuildscript().getRepositories().add(project.getBuildscript().getRepositories().google());
+        return true;
     }
 }

src/main/java/org/attias/open/interactive/simulation/deployer/backend/Deployer.java

@@ -0,0 +1,48 @@
+package org.attias.open.interactive.simulation.deployer.backend;
+
+import org.attias.open.interactive.simulation.deployer.utils.IOUtils;
+import org.gradle.tooling.BuildLauncher;
+import org.gradle.tooling.GradleConnector;
+import org.gradle.tooling.ProjectConnection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
+public class Deployer {
+    private static final Logger log = LoggerFactory.getLogger(Deployer.class);
+    public final String version;
+//    public final Path workspaceDirectory = Paths.get("C:\\Users\\Assaf Attias\\code\\test\\test-desktop");
+    public final Path workspaceDirectory =   Paths.get("C:\\Users\\Assaf Attias\\code\\OpenInteractiveSimulation\\open-interactive-simulation-runner");
+    public final Map<String, String> environmentVariables;
+
+    public Deployer(String version, Path workspaceDirectory, Map<String, String> environmentVariables) {
+        this.version = version;
+//        this.workspaceDirectory = workspaceDirectory;
+        this.environmentVariables = environmentVariables;
+    }
+
+    public void runDesktopSimulation() {
+        executeGradleCommand("clean", "run");
+    }
+
+    public void executeGradleCommand(String... gradleCommands) {
+        executeGradleCommand(this.environmentVariables, gradleCommands);
+    }
+
+    public void executeGradleCommand(Map<String, String> environmentVariables, String... gradleCommands) {
+        try (ProjectConnection connection = GradleConnector.newConnector().forProjectDirectory(workspaceDirectory.toFile()).connect()){
+            BuildLauncher launcher = connection.newBuild()
+                    .forTasks(gradleCommands);
+            // Set environment variables for the task execution
+            launcher.setEnvironmentVariables(environmentVariables);
+            // Redirect Gradle output to SLF4J logger
+            launcher.setStandardOutput(IOUtils.getRedirectOutToLogInfo(log));
+            launcher.setStandardError(IOUtils.getRedirectOutToLogErr(log));
+            // Run
+            launcher.run();
+        }
+    }
+}

src/main/java/org/attias/open/interactive/simulation/deployer/backend/DeployerManager.java

@@ -0,0 +1,63 @@
+package org.attias.open.interactive.simulation.deployer.backend;
+
+import org.attias.open.interactive.simulation.core.engine.AppConfiguration;
+import org.attias.open.interactive.simulation.deployer.dsl.DeployerConfig;
+import org.attias.open.interactive.simulation.deployer.utils.PluginUtils;
+import org.gradle.api.GradleException;
+import org.gradle.tooling.BuildLauncher;
+import org.gradle.tooling.GradleConnector;
+import org.gradle.tooling.ProjectConnection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
+
+public class DeployerManager {
+    private static final Logger log = LoggerFactory.getLogger(DeployerManager.class);
+
+    private DeployerConfig deployerConfig;
+
+    private Map<String, Deployer> deployerMap;
+
+    public DeployerManager(DeployerConfig deployerConfig) {
+        this.deployerConfig = deployerConfig;
+//        this.deployerMap = new HashMap<>();
+    }
+
+    public void fetchDeployer() {
+        Path deployerDirectory = PluginUtils.RUNNERS_PATH.resolve(this.deployerConfig.getVersion());
+        if (!deployerDirectory.toFile().exists()) {
+            throw new GradleException("Can't find runner directory " + deployerDirectory);
+        }
+    }
+
+    public Deployer createDeployer(String version, File dynamicJar) {
+        Path deployerDirectory = PluginUtils.RUNNERS_PATH.resolve(version);
+        if (!deployerDirectory.toFile().exists()) {
+            throw new GradleException("Can't find runner directory " + deployerDirectory);
+        }
+        if (!dynamicJar.exists()) {
+            throw new GradleException("Can't find dynamic jar " + dynamicJar.getAbsolutePath());
+        }
+        return new Deployer(version, deployerDirectory, getDeployEnvVariables(this.deployerConfig, dynamicJar.getAbsolutePath()));
+    }
+
+    public Deployer getDeployer(File dynamicJar) {
+        return createDeployer(this.deployerConfig.getVersion(), dynamicJar);
+    }
+
+    public Map<String, String> getDeployEnvVariables(DeployerConfig deployerConfig, String dynamicJarPath) {
+        Map<String, String> env = new HashMap<>();
+        env.put(AppConfiguration.ENV_PROJECT_JAR, dynamicJarPath);
+        env.put(AppConfiguration.ENV_STATE, deployerConfig.getDynamicClass());
+
+        env.put(AppConfiguration.ENV_TITLE, deployerConfig.getTitle());
+        log.info("Env: {}", env);
+        env.putAll(System.getenv());
+        return env;
+    }
+}

src/main/java/org/attias/open/interactive/simulation/deployer/dsl/DeployerConfig.java

@@ -0,0 +1,33 @@
+package org.attias.open.interactive.simulation.deployer.dsl;
+
+public class DeployerConfig {
+
+    private String version;
+    private String title;
+
+    private String dynamicClass;
+
+    public String getDynamicClass() {
+        return dynamicClass;
+    }
+
+    public void setDynamicClass(String dynamicClass) {
+        this.dynamicClass = dynamicClass;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+}

src/main/java/org/attias/open/interactive/simulation/deployer/dsl/SimulationDeployerExtension.java

@@ -0,0 +1,29 @@
+package org.attias.open.interactive.simulation.deployer.dsl;
+
+import groovy.lang.Closure;
+import org.gradle.api.Action;
+import org.gradle.api.Project;
+import org.gradle.util.internal.ConfigureUtil;
+
+public class SimulationDeployerExtension {
+    private final Project project;
+
+    private DeployerConfig deployerConfig;
+
+    public SimulationDeployerExtension(Project project) {
+        this.project = project;
+    }
+
+    public void deployer(Closure<DeployerConfig> closure) {
+        deployer(ConfigureUtil.configureUsing(closure));
+    }
+
+    public void deployer(Action<DeployerConfig> publishAction) {
+        deployerConfig = new DeployerConfig();
+        publishAction.execute(deployerConfig);
+    }
+
+    public DeployerConfig getDeployerConfig() {
+        return deployerConfig;
+    }
+}

src/main/java/org/attias/open/interactive/simulation/deployer/tasks/InitializeDeployerTask.java

@@ -0,0 +1,37 @@
+package org.attias.open.interactive.simulation.deployer.tasks;
+
+import org.attias.open.interactive.simulation.deployer.backend.Deployer;
+import org.attias.open.interactive.simulation.deployer.backend.DeployerManager;
+import org.attias.open.interactive.simulation.deployer.dsl.DeployerConfig;
+import org.attias.open.interactive.simulation.deployer.dsl.SimulationDeployerExtension;
+import org.attias.open.interactive.simulation.deployer.utils.ExtensionUtils;
+import org.attias.open.interactive.simulation.deployer.utils.PluginUtils;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.GradleException;
+import org.gradle.api.tasks.TaskAction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class InitializeDeployerTask extends DefaultTask {
+
+    private static final Logger log = LoggerFactory.getLogger(InitializeDeployerTask.class);
+
+    public static final String NAME = "initializeDeployer";
+
+    @TaskAction
+    public void initialize() {
+        log.info("{}: Prepare and initialize run environment", getPath());
+        // Initialize plugin directory
+        if (PluginUtils.createPluginDirectoryIfNotExists()){
+            log.info("{}: Created plugin directory", getPath());
+        }
+        if (PluginUtils.createRunnersDirectoryIfNotExists()){
+            log.info("{}: Created runners directory", getPath());
+        }
+        // Validate runner is ready to be used
+        DeployerConfig deployerConfig = ExtensionUtils.getDeployerConfig(getProject());
+        DeployerManager deployerManager = new DeployerManager(deployerConfig);
+        deployerManager.fetchDeployer();
+        log.info("{}: Runner environment {} is ready", getPath(), deployerConfig.getVersion());
+    }
+}

src/main/java/org/attias/open/interactive/simulation/deployer/tasks/RunDesktopSimulationTask.java

@@ -0,0 +1,30 @@
+package org.attias.open.interactive.simulation.deployer.tasks;
+
+import org.attias.open.interactive.simulation.deployer.backend.DeployerManager;
+import org.attias.open.interactive.simulation.deployer.utils.ExtensionUtils;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.TaskAction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class RunDesktopSimulationTask extends DefaultTask {
+    private static final Logger log = LoggerFactory.getLogger(RunDesktopSimulationTask.class);
+    public static final String NAME = "runDesktop";
+
+    @TaskAction
+    public void runSimulation() {
+        log.info("{} Getting project Jar file", getPath());
+        Set<File> jarFiles = getProject().getTasks().getByName("jar").getOutputs().getFiles().getFiles();
+        for (File jar : jarFiles) {
+            log.info("Using Jar: {}", jar.getAbsolutePath());
+        }
+        log.info("{} Running desktop simulation", getPath());
+        DeployerManager deployerManager = new DeployerManager(ExtensionUtils.getDeployerConfig(getProject()));
+        deployerManager.getDeployer(new ArrayList<>(jarFiles).get(0)).runDesktopSimulation();
+    }
+}

src/main/java/org/attias/open/interactive/simulation/deployer/utils/ExtensionUtils.java

@@ -1,14 +1,42 @@
 package org.attias.open.interactive.simulation.deployer.utils;
 
-import org.attias.open.interactive.simulation.deployer.SimulationDeployerExtension;
+import org.attias.open.interactive.simulation.deployer.dsl.DeployerConfig;
+import org.attias.open.interactive.simulation.deployer.dsl.SimulationDeployerExtension;
+import org.gradle.api.GradleException;
 import org.gradle.api.Project;
 
 public class ExtensionUtils {
+
+    public static final String EXTENSION_NAME = "simulationDeployer";
+
     public static SimulationDeployerExtension getPluginExtensionOrCreateDefault(Project project) {
         SimulationDeployerExtension extension = project.getExtensions().findByType(SimulationDeployerExtension.class);
         if (extension == null) {
-            extension = project.getExtensions().create("simulationDeployer", SimulationDeployerExtension.class, project);
+            extension = project.getExtensions().create(EXTENSION_NAME, SimulationDeployerExtension.class, project);
         }
         return extension;
     }
+
+    public static SimulationDeployerExtension getExtensionWithDeployer(Project project) {
+        while (project != null) {
+            SimulationDeployerExtension extension = project.getExtensions().findByType(SimulationDeployerExtension.class);
+            if (extension != null) {
+                return extension;
+            }
+            project = project.getParent();
+        }
+        return null;
+    }
+
+    public static DeployerConfig getDeployerConfig(Project project) {
+        SimulationDeployerExtension extension = getExtensionWithDeployer(project);
+        if (extension != null) {
+            DeployerConfig config = extension.getDeployerConfig();
+            if (config.getTitle() != null && !config.getTitle().isBlank() && config.getDynamicClass() != null && !config.getDynamicClass().isBlank()) {
+                return config;
+            }
+        }
+        throw new GradleException("IOS Projects must define deployer config");
+
+    }
 }

src/main/java/org/attias/open/interactive/simulation/deployer/utils/GitUtils.java

@@ -0,0 +1,23 @@
+package org.attias.open.interactive.simulation.deployer.utils;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+
+import java.io.File;
+
+public class GitUtils {
+    // https://github.com/jfrog/jfrog-vscode-extension/releases/latest/download/jfrog-vscode-extension-2.5.0.vsix
+
+//    String repositoryURL = "https://github.com/ianlapham/release-and-build.git"; // Replace with the repository URL
+//    String tag = "v1"; // Replace with the desired tag
+//    String destinationFolder = "C:\\Users\\Assaf Attias\\.ios\\runners\\1.0-SNAPSHOT";
+
+    // Folder needs to be created before clone
+    public static void cloneRepoByTag(String repositoryURL, String tag, String destinationFolder) throws GitAPIException {
+        Git.cloneRepository()
+                .setURI(repositoryURL)
+                .setDirectory(new File(destinationFolder))
+                .setBranch(tag) // Checkout the specific tag
+                .call();
+    }
+}