Merge branch 'main' into 2.10.x

Author: atextor

core/esmf-aspect-meta-model-java/pom.xml

@@ -63,6 +63,10 @@
          <artifactId>record-builder-processor</artifactId>
          <scope>provided</scope>
       </dependency>
+      <dependency>
+         <groupId>org.commonmark</groupId>
+         <artifactId>commonmark</artifactId>
+      </dependency>
 
       <!-- Test dependencies -->
       <dependency>
@@ -102,6 +106,26 @@
             </executions>
          </plugin>
 
+         <plugin>
+            <groupId>pl.project13.maven</groupId>
+            <artifactId>git-commit-id-plugin</artifactId>
+            <executions>
+               <execution>
+                  <id>get-the-git-infos</id>
+                  <phase>initialize</phase>
+                  <goals>
+                     <goal>revision</goal>
+                  </goals>
+               </execution>
+            </executions>
+            <configuration>
+               <dotGitDirectory>${project.basedir}/../.git</dotGitDirectory>
+               <generateGitPropertiesFile>true</generateGitPropertiesFile>
+               <generateGitPropertiesFilename>${project.build.outputDirectory}/git.properties
+               </generateGitPropertiesFilename>
+            </configuration>
+         </plugin>
+
          <plugin>
             <groupId>org.codehaus.mojo</groupId>
             <artifactId>build-helper-maven-plugin</artifactId>

core/esmf-aspect-meta-model-java/src-buildtime/main/java/org/eclipse/esmf/buildtime/BuildtimeCodeGenerator.java

@@ -82,7 +82,11 @@ private String generateClassContent() {
             final Matcher singleVariableMatcher = replaceSingleVariablePattern.matcher( line );
             if ( singleVariableMatcher.matches() ) {
                final String variableName = singleVariableMatcher.group( 1 );
-               lineToAdd = line.replace( "${" + variableName + "}", interpolateVariable( variableName ) );
+               final String targetValue = interpolateVariable( variableName );
+               if ( targetValue == null ) {
+                  throw new RuntimeException( "Build-time code generation failed: Value for " + variableName + " could not be determined" );
+               }
+               lineToAdd = line.replace( "${" + variableName + "}", targetValue );
             } else {
                lineToAdd = line;
             }

core/esmf-aspect-meta-model-java/src-buildtime/main/java/org/eclipse/esmf/buildtime/GenerateVersionInfo.java

@@ -15,23 +15,32 @@
 
 import java.io.InputStream;
 import java.nio.file.Path;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.Properties;
 
 /**
  * Generates the static version info class
  */
 public class GenerateVersionInfo extends BuildtimeCodeGenerator {
-   private final Properties properties;
+   private final Properties appProperties;
+   private final Properties gitProperties;
 
    protected GenerateVersionInfo( final Path srcBuildTimePath, final Path srcGenPath ) {
       super( srcBuildTimePath, srcGenPath, "VersionInfo", "org.eclipse.esmf.aspectmodel" );
 
-      try ( final InputStream stream = GenerateVersionInfo.class.getClassLoader().getResourceAsStream( "app.properties" ) ) {
+      appProperties = loadProperties( "app.properties" );
+      gitProperties = loadProperties( "git.properties" );
+   }
+
+   private Properties loadProperties( final String filename ) {
+      try ( final InputStream stream = GenerateVersionInfo.class.getClassLoader().getResourceAsStream( filename ) ) {
          if ( stream == null ) {
             throw new RuntimeException();
          }
-         properties = new Properties();
+         final Properties properties = new Properties();
          properties.load( stream );
+         return properties;
       } catch ( final Exception exception ) {
          throw new RuntimeException( "Could not load app.properties" );
       }
@@ -40,8 +49,10 @@ protected GenerateVersionInfo( final Path srcBuildTimePath, final Path srcGenPat
    @Override
    protected String interpolateVariable( final String variableName ) {
       return switch ( variableName ) {
-         case "esmfSdkVersion" -> properties.getProperty( "project-version" );
-         case "aspectMetaModelVersion" -> properties.getProperty( "aspect-meta-model-version" );
+         case "esmfSdkVersion" -> appProperties.getProperty( "project-version" );
+         case "aspectMetaModelVersion" -> appProperties.getProperty( "aspect-meta-model-version" );
+         case "buildDate" -> new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" ).format( new Date() );
+         case "commitId" -> gitProperties.getProperty( "git.commit.id" );
          case "generator" -> getClass().getCanonicalName();
          default -> throw new RuntimeException( "Unexpected variable in template: " + variableName );
       };

core/esmf-aspect-meta-model-java/src-buildtime/main/java/org/eclipse/esmf/buildtime/template/VersionInfo.java

@@ -19,4 +19,6 @@
 public class VersionInfo {
    public static final String ESMF_SDK_VERSION = "${esmfSdkVersion}";
    public static final String ASPECT_META_MODEL_VERSION = "${aspectMetaModelVersion}";
+   public static final String BUILD_DATE = "${buildDate}";
+   public static final String COMMIT_ID = "${commitId}";
 }

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/aspectmodel/resolver/CommandExecutor.java

@@ -30,13 +30,13 @@ public class CommandExecutor {
    public static String executeCommand( final String command ) {
       final List<String> parts = Arrays.asList( command.split( " " ) );
       final String executableOrJar = parts.get( 0 );
-      final ProcessLauncher processLauncher = executableOrJar.toLowerCase().endsWith( ".jar" )
+      final ProcessLauncher<Process> processLauncher = executableOrJar.toLowerCase().endsWith( ".jar" )
             ? new ExecutableJarLauncher( new File( executableOrJar ) )
             : new BinaryLauncher( new File( executableOrJar ) );
       final List<String> arguments = parts.size() == 1
             ? List.of()
             : parts.subList( 1, parts.size() );
-      final ProcessLauncher.ExecutionContext context = new ProcessLauncher.ExecutionContext(
+      final ProcessLauncher<Process>.ExecutionContext context = processLauncher.new ExecutionContext(
             arguments, Optional.empty(), new File( System.getProperty( "user.dir" ) ) );
       final ProcessLauncher.ExecutionResult result = processLauncher.apply( context );
 

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/aspectmodel/resolver/process/OsProcessLauncher.java

@@ -37,7 +37,7 @@
 /**
  * A {@link ProcessLauncher} that spawns an external operating system process
  */
-public class OsProcessLauncher extends ProcessLauncher {
+public class OsProcessLauncher extends ProcessLauncher<Process> {
    private static final Logger LOG = LoggerFactory.getLogger( OsProcessLauncher.class );
    private final List<String> commandWithArguments;
 
@@ -74,6 +74,7 @@ public ExecutionResult apply( final ExecutionContext context ) {
          final Future<ByteArrayOutputStream> stderrFuture = executor.submit( new StreamAccumulator( process.getErrorStream() ) );
 
          LOG.debug( "Waiting for process {} to finish", process.pid() );
+         context.processConsumer().ifPresent( consumer -> consumer.accept( process ) );
          process.waitFor();
 
          final byte[] stdoutRaw;

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/aspectmodel/resolver/process/ProcessLauncher.java

@@ -16,18 +16,22 @@
 import java.io.File;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.eclipse.esmf.aspectmodel.resolver.exceptions.ProcessExecutionException;
 
 /**
  * This class abstracts running a "process", i.e. running a program by providing its arguments, optional stdin and its working directory,
  * and representing the output using exit status and stdout and stderr streams.
+ *
+ * @param <T> the type of "process" that is created (such as {@link Process} or {@link Thread})
  */
-public abstract class ProcessLauncher implements Function<ProcessLauncher.ExecutionContext, ProcessLauncher.ExecutionResult> {
+public abstract class ProcessLauncher<T> implements Function<ProcessLauncher<T>.ExecutionContext, ProcessLauncher.ExecutionResult> {
    /**
-    * Convenience constructor that to apply the launcher to a list of arguments with empty stdin and default working directory
+    * Convenience method to apply the launcher to a list of arguments with empty stdin and default working directory
     */
    public ExecutionResult apply( final String... arguments ) {
       return apply( new ExecutionContext( Arrays.asList( arguments ), Optional.empty(), new File( System.getProperty( "user.dir" ) ) ) );
@@ -37,20 +41,95 @@ public ExecutionResult runAndExpectSuccess( final String... arguments ) {
       final ExecutionResult result = apply( arguments );
       if ( result.exitStatus() != 0 ) {
          throw new ProcessExecutionException(
-               "Execution failed (status " + result.exitStatus + "):\n"
-                     + "stdout:"
-                     + result.stdout()
-                     + "\n"
-                     + "stderr:"
-                     + result.stderr()
-         );
+               "Execution failed (status %d):\nstdout:%s\nstderr:%s".formatted( result.exitStatus, result.stdout(), result.stderr() ) );
       }
       return result;
    }
 
-   public record ExecutionContext( List<String> arguments, Optional<byte[]> stdin, File workingDirectory ) {
+   public ExecutionResult apply( final List<String> arguments, final Optional<byte[]> stdin, final File workingDirectory,
+         final Consumer<T> processConsumer ) {
+      return apply( new ExecutionContext( arguments, stdin, workingDirectory, Optional.of( processConsumer ) ) );
+   }
+
+   public ExecutionResult apply( final List<String> arguments, final Optional<byte[]> stdin, final File workingDirectory ) {
+      return apply( new ExecutionContext( arguments, stdin, workingDirectory ) );
    }
 
-   public record ExecutionResult( int exitStatus, String stdout, String stderr, byte[] stdoutRaw, byte[] stderrRaw ) {
+   /**
+    * The execution context determines inputs for the new process: arguments, stdin and working directory
+    */
+   public final class ExecutionContext {
+      private final List<String> arguments;
+      private final Optional<byte[]> stdin;
+      private final File workingDirectory;
+      private final Optional<Consumer<T>> processConsumer;
+
+      public ExecutionContext( final List<String> arguments, final Optional<byte[]> stdin, final File workingDirectory,
+            final Optional<Consumer<T>> processConsumer ) {
+         this.arguments = arguments;
+         this.stdin = stdin;
+         this.workingDirectory = workingDirectory;
+         this.processConsumer = processConsumer;
+      }
+
+      public ExecutionContext( final List<String> arguments, final Optional<byte[]> stdin, final File workingDirectory ) {
+         this( arguments, stdin, workingDirectory, Optional.empty() );
+      }
+
+      public List<String> arguments() {
+         return arguments;
+      }
+
+      public Optional<byte[]> stdin() {
+         return stdin;
+      }
+
+      public File workingDirectory() {
+         return workingDirectory;
+      }
+
+      public Optional<Consumer<T>> processConsumer() {
+         return processConsumer;
+      }
+
+      @Override
+      public boolean equals( final Object obj ) {
+         if ( obj == this ) {
+            return true;
+         }
+         if ( obj == null || obj.getClass() != getClass() ) {
+            return false;
+         }
+         @SuppressWarnings( "unchecked" ) final ExecutionContext that = (ExecutionContext) obj;
+         return Objects.equals( arguments, that.arguments )
+               && Objects.equals( stdin, that.stdin )
+               && Objects.equals( workingDirectory, that.workingDirectory )
+               && Objects.equals( processConsumer, that.processConsumer );
+      }
+
+      @Override
+      public int hashCode() {
+         return Objects.hash( arguments, stdin, workingDirectory, processConsumer );
+      }
+
+      @Override
+      public String toString() {
+         return "ExecutionContext["
+               + "arguments=" + arguments + ", "
+               + "stdin=" + stdin + ", "
+               + "workingDirectory=" + workingDirectory + ", "
+               + "processConsumer=" + processConsumer + ']';
+      }
    }
+
+   /**
+    * The execution result provides the process' status and stderr and stdout results
+    */
+   public record ExecutionResult(
+         int exitStatus,
+         String stdout,
+         String stderr,
+         byte[] stdoutRaw,
+         byte[] stderrRaw
+   ) {}
 }