Enabled C federated tests with Rust RTI

- At first, thirty-four C federated tests are evaluated with Rust RTI

core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java

@@ -142,6 +142,18 @@ public void runFederatedTests() {
         false);
   }
 
+  @Test
+  public void runFederatedTestsWithRustRti() {
+    Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT);
+    runTestsForTargetsWithRustRti(
+        Message.DESC_FEDERATED_WITH_RUST_RTI,
+        TestCategory.FEDERATED::equals,
+        Transformers::noChanges,
+        Configurators::noChanges,
+        TestLevel.EXECUTION,
+        false);
+  }
+
   /** Run the tests for modal reactors. */
   @Test
   public void runModalTests() {

core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java

@@ -112,6 +112,12 @@ public void runFederatedTests() {
     super.runFederatedTests();
   }
 
+  @Test
+  public void runFederatedTestsWithRustRti() {
+    Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT);
+    super.runFederatedTestsWithRustRti();
+  }
+
   @Test
   public void runModalTests() {
     super.runModalTests();

core/src/main/java/org/lflang/federated/generator/FedGenerator.java

@@ -201,6 +201,97 @@ public boolean doGenerate(Resource resource, LFGeneratorContext context) throws
     return false;
   }
 
+  /**
+   * Produce LF code for each federate in a separate file, then invoke a target-specific code
+   * generator for each of those files.
+   *
+   * @param resource The resource that has the federated main reactor in it
+   * @param context The context in which to carry out the code generation.
+   * @return False if no errors have occurred, true otherwise.
+   */
+  public boolean doGenerateForRustRTI(Resource resource, LFGeneratorContext context)
+      throws IOException {
+    if (!federatedExecutionIsSupported(resource)) return true;
+    cleanIfNeeded(context);
+
+    // In a federated execution, we need keepalive to be true,
+    // otherwise a federate could exit simply because it hasn't received
+    // any messages.
+    KeepaliveProperty.INSTANCE.override(targetConfig, true);
+
+    // Process command-line arguments
+    processCLIArguments(context);
+
+    // Find the federated reactor
+    Reactor federation = FedASTUtils.findFederatedReactor(resource);
+
+    // Make sure the RTI host is set correctly.
+    setRTIHost(federation);
+
+    // Create the FederateInstance objects.
+    ReactorInstance main = createFederateInstances(federation, context);
+
+    // Insert reactors that split multiports into many ports.
+    insertIndexers(main, resource);
+
+    // Clear banks so that each bank member becomes a single federate.
+    for (Instantiation instantiation : ASTUtils.allInstantiations(federation)) {
+      instantiation.setWidthSpec(null);
+      instantiation.setWidthSpec(null);
+    }
+
+    // Find all the connections between federates.
+    // For each connection between federates, replace it in the
+    // AST with an action (which inherits the delay) and three reactions.
+    // The action will be physical for physical connections and logical
+    // for logical connections.
+    replaceFederateConnectionsWithProxies(federation, main, resource);
+
+    FedEmitter fedEmitter =
+        new FedEmitter(
+            fileConfig,
+            ASTUtils.toDefinition(mainDef.getReactorClass()),
+            messageReporter,
+            rtiConfig);
+
+    // Generate LF code for each federate.
+    Map<Path, CodeMap> lf2lfCodeMapMap = new HashMap<>();
+    for (FederateInstance federate : federates) {
+      lf2lfCodeMapMap.putAll(fedEmitter.generateFederate(context, federate, federates.size()));
+    }
+
+    // Do not invoke target code generators if --no-compile flag is used.
+    if (context.getTargetConfig().get(NoCompileProperty.INSTANCE)) {
+      context.finish(Status.GENERATED, lf2lfCodeMapMap);
+      return false;
+    }
+
+    // If the RTI is to be built locally, set up a build environment for it.
+    prepareRtiBuildEnvironment(context);
+
+    Map<Path, CodeMap> codeMapMap =
+        compileFederates(
+            context,
+            lf2lfCodeMapMap,
+            subContexts -> {
+              createDockerFiles(context, subContexts);
+              generateLaunchScriptForRustRti();
+              // If an error has occurred during codegen of any federate, report it.
+              subContexts.forEach(
+                  c -> {
+                    if (c.getErrorReporter().getErrorsOccurred()) {
+                      context
+                          .getErrorReporter()
+                          .at(c.getFileConfig().srcFile)
+                          .error("Failure during code generation of " + c.getFileConfig().srcFile);
+                    }
+                  });
+            });
+
+    context.finish(Status.COMPILED, codeMapMap);
+    return false;
+  }
+
   /**
    * Prepare a build environment for the rti alongside the generated sources of the federates.
    *
@@ -229,6 +320,11 @@ private void generateLaunchScript() {
         .doGenerate(federates, rtiConfig);
   }
 
+  private void generateLaunchScriptForRustRti() {
+    new FedLauncherGenerator(this.targetConfig, this.fileConfig, this.messageReporter)
+        .doGenerateForRustRTI(federates, new RtiConfig());
+  }
+
   /**
    * Generate a Dockerfile for each federate and a docker-compose.yml for the federation.
    *

core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java

@@ -265,6 +265,169 @@ public void doGenerate(List<FederateInstance> federates, RtiConfig rtiConfig) {
     }
   }
 
+  /**
+   * Create the launcher shell scripts. This will create one or two files in the output path (bin
+   * directory). The first has name equal to the filename of the source file without the ".lf"
+   * extension. This will be a shell script that launches the RTI and the federates. If, in
+   * addition, either the RTI or any federate is mapped to a particular machine (anything other than
+   * the default "localhost" or "0.0.0.0"), then this will generate a shell script in the bin
+   * directory with name filename_distribute.sh that copies the relevant source files to the remote
+   * host and compiles them so that they are ready to execute using the launcher.
+   *
+   * <p>A precondition for this to work is that the user invoking this code generator can log into
+   * the remote host without supplying a password. Specifically, you have to have installed your
+   * public key (typically found in ~/.ssh/id_rsa.pub) in ~/.ssh/authorized_keys on the remote host.
+   * In addition, the remote host must be running an ssh service. On an Arch Linux system using
+   * systemd, for example, this means running:
+   *
+   * <p>sudo systemctl <start|enable> ssh.service
+   *
+   * <p>Enable means to always start the service at startup, whereas start means to just start it
+   * this once.
+   *
+   * @param federates A list of federate instances in the federation
+   * @param rtiConfig Can have values for 'host', 'dir', and 'user'
+   */
+  public void doGenerateForRustRTI(List<FederateInstance> federates, RtiConfig rtiConfig) {
+    // NOTE: It might be good to use screen when invoking the RTI
+    // or federates remotely, so you can detach and the process keeps running.
+    // However, I was unable to get it working properly.
+    // What this means is that the shell that invokes the launcher
+    // needs to remain live for the duration of the federation.
+    // If that shell is killed, the federation will die.
+    // Hence, it is reasonable to launch the federation on a
+    // machine that participates in the federation, for example,
+    // on the machine that runs the RTI.  The command I tried
+    // to get screen to work looks like this:
+    // ssh -t «target» cd «path»; screen -S «filename»_«federate.name» -L
+    // bin/«filename»_«federate.name» 2>&1
+    // var outPath = binGenPath
+    StringBuilder shCode = new StringBuilder();
+    StringBuilder distCode = new StringBuilder();
+    shCode.append(getSetupCode()).append("\n");
+    String distHeader = getDistHeader();
+    String host = rtiConfig.getHost();
+    String target = host;
+
+    String user = rtiConfig.getUser();
+    if (user != null) {
+      target = user + "@" + host;
+    }
+
+    shCode.append("#### Host is ").append(host);
+
+    // Launch the RTI in the foreground.
+    if (host.equals("localhost") || host.equals("0.0.0.0")) {
+      // FIXME: the paths below will not work on Windows
+      shCode.append(getLaunchCodeForRustRti(Integer.toString(federates.size()))).append("\n");
+    } else {
+      // Start the RTI on the remote machine - Not supported yet for Rust RTI.
+    }
+
+    // Index used for storing pids of federates
+    int federateIndex = 0;
+    for (FederateInstance federate : federates) {
+      var buildConfig = getBuildConfig(federate, fileConfig, messageReporter);
+      if (federate.isRemote) {
+        if (distCode.isEmpty()) distCode.append(distHeader).append("\n");
+        distCode.append(getDistCode(rtiConfig.getDirectory(), federate)).append("\n");
+        shCode
+            .append(getFedRemoteLaunchCode(rtiConfig.getDirectory(), federate, federateIndex++))
+            .append("\n");
+      } else {
+        String executeCommand = buildConfig.localExecuteCommand();
+        shCode
+            .append(getFedLocalLaunchCode(federate, executeCommand, federateIndex++))
+            .append("\n");
+      }
+    }
+    if (host.equals("localhost") || host.equals("0.0.0.0")) {
+      // Local PID managements
+      shCode.append(
+          "echo \"#### Bringing the RTI back to foreground so it can receive Control-C.\"" + "\n");
+      shCode.append("fg %1" + "\n");
+    }
+    // Wait for launched processes to finish
+    shCode
+        .append(
+            String.join(
+                "\n",
+                "echo \"RTI has exited. Wait for federates to exit.\"",
+                "# Wait for launched processes to finish.",
+                "# The errors are handled separately via trap.",
+                "for pid in \"${pids[@]}\"",
+                "do",
+                "    wait $pid || exit $?",
+                "done",
+                "echo \"All done.\"",
+                "EXITED_SUCCESSFULLY=true"))
+        .append("\n");
+
+    // Create bin directory for the script.
+    if (!Files.exists(fileConfig.binPath)) {
+      try {
+        Files.createDirectories(fileConfig.binPath);
+      } catch (IOException e) {
+        messageReporter.nowhere().error("Unable to create directory: " + fileConfig.binPath);
+      }
+    }
+
+    // Write the launcher file.
+    File file = fileConfig.binPath.resolve(fileConfig.name).toFile();
+    messageReporter.nowhere().info("Script for launching the federation: " + file);
+
+    // Delete file previously produced, if any.
+    if (file.exists()) {
+      if (!file.delete())
+        messageReporter
+            .nowhere()
+            .error("Failed to delete existing federated launch script \"" + file + "\"");
+    }
+
+    FileOutputStream fOut = null;
+    try {
+      fOut = new FileOutputStream(file);
+    } catch (FileNotFoundException e) {
+      messageReporter.nowhere().error("Unable to find file: " + file);
+    }
+    if (fOut != null) {
+      try {
+        fOut.write(shCode.toString().getBytes());
+        fOut.close();
+      } catch (IOException e) {
+        messageReporter.nowhere().error("Unable to write to file: " + file);
+      }
+    }
+
+    if (!file.setExecutable(true, false)) {
+      messageReporter.nowhere().warning("Unable to make launcher script executable.");
+    }
+
+    // Write the distributor file.
+    // Delete the file even if it does not get generated.
+    file = fileConfig.binPath.resolve(fileConfig.name + "_distribute.sh").toFile();
+    if (file.exists()) {
+      if (!file.delete())
+        messageReporter
+            .nowhere()
+            .error("Failed to delete existing federated distributor script \"" + file + "\"");
+    }
+    if (distCode.length() > 0) {
+      try {
+        fOut = new FileOutputStream(file);
+        fOut.write(distCode.toString().getBytes());
+        fOut.close();
+        if (!file.setExecutable(true, false)) {
+          messageReporter.nowhere().warning("Unable to make file executable: " + file);
+        }
+      } catch (FileNotFoundException e) {
+        messageReporter.nowhere().error("Unable to find file: " + file);
+      } catch (IOException e) {
+        messageReporter.nowhere().error("Unable to write to file " + file);
+      }
+    }
+  }
+
   private String getSetupCode() {
     return String.join(
         "\n",
@@ -377,6 +540,35 @@ private String getLaunchCode(String rtiLaunchCode) {
         "sleep 1");
   }
 
+  private String getLaunchCodeForRustRti(String numberOfFederates) {
+    String launchCodeWithoutLogging =
+        new String("cargo run -- -i ${FEDERATION_ID} -n " + numberOfFederates + " -c init &");
+    return String.join(
+        "\n",
+        "echo \"#### Launching the Rust runtime infrastructure (RTI).\"",
+        "# The Rust RTI is started first to allow proper boot-up",
+        "# before federates will try to connect.",
+        "# The RTI will be brought back to foreground",
+        "# to be responsive to user inputs after all federates",
+        "# are launched.",
+        "RUST_RTI_REMOTE_PATHS=`find ~/ -name rti_remote.rs`",
+        "if [ \"${RUST_RTI_REMOTE_PATHS}\" = \"\" ]; then",
+        "    git clone https://github.com/hokeun/lf-rust-rti.git",
+        "    cd lf-rust-rti/rust/rti",
+        "else",
+        "    FIRST_RUST_RTI_REMOTE_PATH=($RUST_RTI_REMOTE_PATHS)",
+        "    FIRST_RUST_RTI_PATH=${FIRST_RUST_RTI_REMOTE_PATH[0]%/*}",
+        "    cd ${FIRST_RUST_RTI_PATH}; cd ../",
+        "fi",
+        launchCodeWithoutLogging,
+        "# Store the PID of the RTI",
+        "RTI=$!",
+        "# Wait for the RTI to boot up before",
+        "# starting federates (this could be done by waiting for a specific output",
+        "# from the RTI, but here we use sleep)",
+        "sleep 1");
+  }
+
   private String getRemoteLaunchCode(
       Object host, Object target, String logFileName, String rtiLaunchString) {
     return String.join(
@@ -590,7 +782,7 @@ private String getFedLocalLaunchCode(
   private BuildConfig getBuildConfig(
       FederateInstance federate, FederationFileConfig fileConfig, MessageReporter messageReporter) {
     return switch (federate.targetConfig.target) {
-      case C, CCPP -> new CBuildConfig(federate, fileConfig, messageReporter);
+      case C, CCPP, RustRti -> new CBuildConfig(federate, fileConfig, messageReporter);
       case Python -> new PyBuildConfig(federate, fileConfig, messageReporter);
       case TS -> new TsBuildConfig(federate, fileConfig, messageReporter);
       case CPP, Rust -> throw new UnsupportedOperationException();

core/src/main/java/org/lflang/generator/LFGenerator.java

@@ -121,6 +121,42 @@ public void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorCont
     }
   }
 
+  public void doGenerateForRustRTI(
+      Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
+    assert injector != null;
+    final LFGeneratorContext lfContext;
+    if (context instanceof LFGeneratorContext) {
+      lfContext = (LFGeneratorContext) context;
+    } else {
+      lfContext = LFGeneratorContext.lfGeneratorContextOf(resource, fsa, context);
+    }
+
+    // The fastest way to generate code is to not generate any code.
+    if (lfContext.getMode() == LFGeneratorContext.Mode.LSP_FAST) return;
+
+    if (FedASTUtils.findFederatedReactor(resource) != null) {
+      try {
+        FedGenerator fedGenerator = new FedGenerator(lfContext);
+        injector.injectMembers(fedGenerator);
+        generatorErrorsOccurred = fedGenerator.doGenerateForRustRTI(resource, lfContext);
+      } catch (IOException e) {
+        throw new RuntimeIOException("Error during federated code generation", e);
+      }
+
+    } else {
+      final GeneratorBase generator = createGenerator(lfContext);
+
+      if (generator != null) {
+        generator.doGenerate(resource, lfContext);
+        generatorErrorsOccurred = generator.errorsOccurred();
+      }
+    }
+    final MessageReporter messageReporter = lfContext.getErrorReporter();
+    if (messageReporter instanceof LanguageServerMessageReporter) {
+      ((LanguageServerMessageReporter) messageReporter).publishDiagnostics();
+    }
+  }
+
   /** Return true if errors occurred in the last call to doGenerate(). */
   public boolean errorsOccurred() {
     return generatorErrorsOccurred;