support output directory, add dockerfile and extend readme

Author: mandoway

.dockerignore

@@ -0,0 +1,11 @@
+Dockerfile
+.dockerignore
+study
+.idea
+.github
+.goreleaser*
+*.so
+*.cue
+seru
+test.sh
+README.md

Dockerfile

@@ -0,0 +1,47 @@
+FROM eclipse-temurin:25 AS jre-build
+
+RUN $JAVA_HOME/bin/jlink \
+         --add-modules java.base,java.logging \
+         --strip-debug \
+         --no-man-pages \
+         --no-header-files \
+         --compress=2 \
+         --output /javaruntime
+
+
+FROM golang:1.23.2-bookworm AS build
+ENV CUE_VERSION=v0.12.1
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+
+RUN CGO_ENABLED=1 GOOS=linux go generate ./...
+RUN CGO_ENABLED=1 GOOS=linux go build -o seru
+RUN go install cuelang.org/go/cmd/cue@${CUE_VERSION}
+
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      ca-certificates \
+      git \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV JAVA_HOME=/opt/java/openjdk
+ENV PATH="${JAVA_HOME}/bin:${PATH}"
+COPY --from=jre-build /javaruntime $JAVA_HOME
+
+COPY --from=build /usr/local/go /usr/local/go
+COPY --from=build /go/bin/cue /usr/local/bin/cue
+ENV PATH="/usr/local/go/bin:${PATH}"
+
+WORKDIR /app
+COPY --from=build /app/seru .
+COPY --from=build /app/cue.so .
+COPY --from=build /app/cue.jar .
+COPY --from=build /app/perses_deploy.jar .
+
+ENTRYPOINT ["./seru"]

README.md

@@ -15,14 +15,29 @@ SeRu currently supports:
 - Semantic reducers for languages
     - CUE
 
+## Docker
+
+You can use SeRu with our docker image.
+Use the following command to run a reduction with docker:
+```bash
+WORKDIR=/data docker run --rm -it -v $(pwd):${WORKDIR} mando9/seru -o ${WORKDIR} -i ${WORKDIR}/<input file> -t ${WORKDIR}/<test script>
+# e.g. to use in.cue and test.sh in the current working dir, run
+WORKDIR=/data docker run --rm -it -v $(pwd):${WORKDIR} mando9/seru -o ${WORKDIR} -i ${WORKDIR}/in.cue -t ${WORKDIR}/test.sh
+```
+
+This will create a result directory with the prefix "seru_reduction" in your working directory.
+It contains the final result as well as the intermediate steps in subdirectories.
+
 ## Pre-requisites
 
 > Steps 1 & 2 are only necessary while the repository are private  
 > SeRu will download such dependencies automatically
 
 1. Download Perses & CUE-specific extension (latest from the release page)
     1. [perses_deploy.jar](https://github.com/mandoway/seru/releases/download/v0.0.1-alpha/perses_deploy.jar)
+        1. Compiled Perses & Vulcan as a executable JAR file
     2. [cue.jar](https://github.com/mandoway/seru/releases/download/v0.0.1-alpha/cue.jar)
+        1. The CUE grammar in the form of a Perses language plugin
 2. Compile CUE-specific semantic reduction strategies
     1. Run
    ```bash
@@ -31,7 +46,9 @@ SeRu currently supports:
 3. Make sure you have Java installed (for Perses)
 
 ## Run seru
-Run SeRu using Go or standalone  
+
+Run SeRu using Go or standalone
+
 - `go run .`
 - `go build && ./seru`
 - Install from the release page
@@ -43,6 +60,7 @@ Run SeRu using Go or standalone
 | `--input <path>`             | `-i`      | ✅        | path to input file                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `--test <path>`              | `-t`      | ✅        | path to property testscript, a test script **must return 0** when the property holds and 1 (or any code) if the property is invalid                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `--lang <string>`            | `-l`      |          | language of file, e.g. cue. Will be inferred from the file extension if omitted.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `--out <string>`             | `-o`      |          | define the output directory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `--reducer <perses\|vulcan>` | `-r`      |          | either 'perses' OR 'vulcan' (default "perses"). Perses is faster, Vulcan can be more effective.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `--enable-metrics`           | `-m`      |          | store metrics as a json file                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `--strategy-isolation`       | `-s`      |          | (*untested*) Activates strategy isolation.<br/> Modes: <br/>- Isolation (many candidates, slow): only one strategy will be applied before next iteration. This mode will apply only one semantic strategy and try to reduce all returned candidates using the syntactic reducer. <br/>- Strategy combination (**default**, much faster, less calls to syntactic reducer). In strategy combination, all strategies are applied and combined to one "best candidate". Then this single candidate will be reduced by the syntactic reducer. |

cmd/root.go

@@ -15,7 +15,7 @@ var rootCmd = &cobra.Command{
 	Short: "A tool to reduce a program while maintaining a property",
 	Long:  `TODO`,
 	Run: func(cmd *cobra.Command, args []string) {
-		err := reduction.StartReductionProcess(flags.InputFile, flags.TestScript, flags.GivenLanguage, flags.UseStrategyIsolation, flags.EnableMetrics, flags.GetReducer(), flags.GetActiveStrategies())
+		err := reduction.StartReductionProcess(flags.WorkDir, flags.InputFile, flags.TestScript, flags.GivenLanguage, flags.UseStrategyIsolation, flags.EnableMetrics, flags.GetReducer(), flags.GetActiveStrategies())
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -31,6 +31,9 @@ func init() {
 	_ = rootCmd.MarkPersistentFlagRequired("test")
 	_ = rootCmd.MarkPersistentFlagFilename("test")
 
+	rootCmd.PersistentFlags().StringVarP(&flags.WorkDir, "out", "o", "", "output directory")
+	_ = rootCmd.MarkPersistentFlagFilename("out")
+
 	rootCmd.PersistentFlags().StringVarP(&flags.GivenLanguage, "lang", "l", "", "language of file, e.g. cue")
 	rootCmd.PersistentFlags().StringVarP(&flags.SyntacticReducer, "reducer", "r", PersesReducer, "either 'perses' OR 'vulcan'")
 

cmd/types.go

@@ -14,10 +14,10 @@ const (
 )
 
 type Flags struct {
-	InputFile, TestScript, GivenLanguage string
-	UseStrategyIsolation, EnableMetrics  bool
-	SyntacticReducer                     reductionType
-	ActiveStrategies                     []int
+	InputFile, TestScript, GivenLanguage, WorkDir string
+	UseStrategyIsolation, EnableMetrics           bool
+	SyntacticReducer                              reductionType
+	ActiveStrategies                              []int
 }
 
 func (f Flags) GetReducer() syntactic.Reducer {

reduction/context/run_context.go

@@ -4,17 +4,18 @@ import (
 	"crypto/md5"
 	"errors"
 	"fmt"
+	"os"
+	"path"
+	"strconv"
+	"time"
+
 	"github.com/google/uuid"
 	"github.com/mandoway/seru/files"
 	"github.com/mandoway/seru/reduction/candidate"
 	"github.com/mandoway/seru/reduction/logging"
 	"github.com/mandoway/seru/reduction/metrics"
 	"github.com/mandoway/seru/reduction/plugin"
 	"github.com/mandoway/seru/reduction/syntactic"
-	"os"
-	"path"
-	"strconv"
-	"time"
 )
 
 const RunContextFolderPrefix = "seru_reduction_"
@@ -210,11 +211,14 @@ func (ctx *RunContext) GetHash() [16]byte {
 	return ctx.hashOfBest
 }
 
-func NewRunContext(givenLanguage, inputFilePath, testScriptPath string, algorithmConfig AlgorithmConfig) (*RunContext, error) {
+func NewRunContext(givenLanguage, inputFilePath, testScriptPath, workDir string, algorithmConfig AlgorithmConfig) (*RunContext, error) {
 	// Copy input files
 	randId, _ := uuid.NewRandom()
 	startTimeFormatted := time.Now().Format(time.RFC3339)
 	reductionDir := fmt.Sprintf("%s%s_%s", RunContextFolderPrefix, startTimeFormatted, randId)
+	if len(workDir) != 0 {
+		reductionDir = path.Join(workDir, reductionDir)
+	}
 	err := os.Mkdir(reductionDir, 0750)
 	if err != nil {
 		return nil, NewRunContextErr(err)

reduction/entry.go

@@ -7,14 +7,14 @@ import (
 	"github.com/mandoway/seru/util/collection"
 )
 
-func StartReductionProcess(inputFile, testScript, givenLanguage string, isolation, enableMetrics bool, reducer syntactic.Reducer, activeStrategies *collection.Set) error {
+func StartReductionProcess(workDir, inputFile, testScript, givenLanguage string, isolation, enableMetrics bool, reducer syntactic.Reducer, activeStrategies *collection.Set) error {
 	logging.Default.Println("SeRu - Syntactic & Semantic Reduction")
 	logging.Default.Println()
 	logging.Default.Printf("Creating new run context with (input=%s, test=%s, lang=%s)\n", inputFile, testScript, givenLanguage)
 	algorithmConfig := context.NewAlgorithmConfig(isolation, reducer, activeStrategies)
 	logging.Default.Printf("Running algorithm with config %s\n", algorithmConfig)
 
-	runCtx, err := context.NewRunContext(givenLanguage, inputFile, testScript, *algorithmConfig)
+	runCtx, err := context.NewRunContext(givenLanguage, inputFile, testScript, workDir, *algorithmConfig)
 	if err != nil {
 		return err
 	}