Light, fluffy, and always free - The AWS Local Emulator alternative
feat(glue): start, read and stop job runs, and list and batch get jobs (#4382)
David14ae1dfbdb56
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/GlueJobRunTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/GlueJobRunTest.javanew file mode 100644index 0000000000..8276f28679--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/GlueJobRunTest.java@@ -0,0 +1,108 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.glue.GlueClient;+import software.amazon.awssdk.services.glue.model.BatchGetJobsResponse;+import software.amazon.awssdk.services.glue.model.BatchStopJobRunResponse;+import software.amazon.awssdk.services.glue.model.EntityNotFoundException;+import software.amazon.awssdk.services.glue.model.JobRun;+import software.amazon.awssdk.services.glue.model.JobRunState;+import software.amazon.awssdk.services.glue.model.WorkerType;++import java.util.Map;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("Glue job runs")+class GlueJobRunTest {++ private static final String JOB_NAME = TestFixtures.uniqueName("run_job");+ private static final String ROLE = "arn:aws:iam::000000000000:role/glue";++ private static GlueClient glue;++ @BeforeAll+ static void setup() {+ glue = TestFixtures.glueClient();+ glue.createJob(r -> r+ .name(JOB_NAME)+ .role(ROLE)+ .command(c -> c.name("glueetl").scriptLocation("s3://scripts/etl.py"))+ .workerType(WorkerType.G_1_X)+ .numberOfWorkers(2)+ .tags(Map.of("team", "data")));+ }++ @AfterAll+ static void cleanup() {+ if (glue == null) {+ return;+ }+ try {+ glue.deleteJob(r -> r.jobName(JOB_NAME));+ }+ catch (Exception ignored) {+ // Cleanup is best effort: the job name is unique to this run and the emulator is disposable.+ }+ glue.close();+ }++ @Test+ @DisplayName("StartJobRun, GetJobRun and GetJobRuns parse with the SDK")+ void startAndReadARun() {+ String runId = glue.startJobRun(r -> r+ .jobName(JOB_NAME)+ .arguments(Map.of("--day", "2026-09-25"))+ .numberOfWorkers(4)).jobRunId();++ assertThat(runId).matches("jr_[0-9a-f]{64}");++ JobRun run = glue.getJobRun(r -> r.jobName(JOB_NAME).runId(runId)).jobRun();+ assertThat(run.id()).isEqualTo(runId);+ assertThat(run.jobName()).isEqualTo(JOB_NAME);+ assertThat(run.jobRunState()).isEqualTo(JobRunState.SUCCEEDED);+ assertThat(run.arguments()).containsEntry("--day", "2026-09-25");+ assertThat(run.workerType()).isEqualTo(WorkerType.G_1_X);+ assertThat(run.numberOfWorkers()).isEqualTo(4);+ assertThat(run.startedOn()).isNotNull();+ assertThat(run.completedOn()).isNotNull();++ assertThat(glue.getJobRuns(r -> r.jobName(JOB_NAME)).jobRuns())+ .extracting(JobRun::id)+ .contains(runId);+ }++ @Test+ @DisplayName("BatchStopJobRun reports a finished run under Errors")+ void stopAFinishedRun() {+ String runId = glue.startJobRun(r -> r.jobName(JOB_NAME)).jobRunId();++ BatchStopJobRunResponse response = glue.batchStopJobRun(r -> r.jobName(JOB_NAME).jobRunIds(runId));++ assertThat(response.successfulSubmissions()).isEmpty();+ assertThat(response.errors()).hasSize(1);+ assertThat(response.errors().get(0).jobRunId()).isEqualTo(runId);+ assertThat(response.errors().get(0).errorDetail().errorCode()).isEqualTo("InvalidInputException");+ }++ @Test+ @DisplayName("ListJobs filters on tags and BatchGetJobs reports missing names")+ void listAndBatchGetJobs() {+ assertThat(glue.listJobs(r -> r.tags(Map.of("team", "data"))).jobNames()).contains(JOB_NAME);++ BatchGetJobsResponse response = glue.batchGetJobs(r -> r.jobNames(JOB_NAME, "absent_job"));+ assertThat(response.jobs()).extracting(job -> job.name()).containsExactly(JOB_NAME);+ assertThat(response.jobsNotFound()).containsExactly("absent_job");+ }++ @Test+ @DisplayName("GetJobRun on an unknown run is EntityNotFoundException")+ void unknownRun() {+ assertThatThrownBy(() -> glue.getJobRun(r -> r.jobName(JOB_NAME).runId("jr_missing")))+ .isInstanceOf(EntityNotFoundException.class);+ }+}diff --git a/docs/services/glue.md b/docs/services/glue.mdindex 4cf4b50c78..9c49f183e9 100644--- a/docs/services/glue.md+++ b/docs/services/glue.md@@ -140,8 +140,23 @@ retroactively.| CreateJob | Creates a new job definition. || GetJob | Retrieves an existing job definition. || GetJobs | Retrieves all current job definitions. |+| ListJobs | Lists job names, optionally only those carrying every given tag. |+| BatchGetJobs | Retrieves several job definitions by name and reports the names not found. || UpdateJob | Updates an existing job definition. |-| DeleteJob | Deletes a specified job definition. |+| DeleteJob | Deletes a specified job definition and its runs. |+| StartJobRun | Starts a run of a job, with per-run arguments and capacity overrides. |+| GetJobRun | Retrieves one run of a job. |+| GetJobRuns | Lists a job's runs, newest first. |+| BatchStopJobRun | Stops running runs of a job and reports the rest in `Errors`. |++Job runs do not execute the job's script. A run follows Glue's state machine and response shape: it+takes the job's worker type, worker count, timeout and Glue version unless the request overrides them,+and `MaxConcurrentRuns` (1 when unset) rejects a start with `ConcurrentRunsExceededException` unless+`JobRunQueuingEnabled` is set. With the default `job-run-duration-seconds` of 0 a run is `SUCCEEDED` as+soon as it starts. A positive value keeps each run `RUNNING` for that many seconds, so a test can observe+`BatchStopJobRun` (the run ends `STOPPED`) and the concurrency limit; a run whose duration exceeds the job+timeout ends `TIMEOUT` when the timeout is reached. Queued runs are admitted straight away rather than+waiting in `WAITING`.#### Crawlers@@ -215,6 +230,7 @@ Supported schema formats are `AVRO`, `JSON`, and `PROTOBUF`. Compatibility modes| Variable | Default | Description ||---|---|---|| `FLOCI_SERVICES_GLUE_ENABLED` | `true` | Enable or disable the service |+| `FLOCI_SERVICES_GLUE_JOB_RUN_DURATION_SECONDS` | `0` | Seconds a job run stays `RUNNING` before it succeeds; `0` finishes it as soon as it starts |## Integration with Athenadiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 0856df3f9f..d2842ea2d7 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1957,6 +1957,10 @@ public interface EmulatorConfig {interface GlueServiceConfig {@WithDefault("true")boolean enabled();++ /** How long a job run stays RUNNING before it succeeds; 0 = a run succeeds as soon as it starts. */+ @WithDefault("0")+ int jobRunDurationSeconds();}interface SesServiceConfig {diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJobRunService.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJobRunService.javanew file mode 100644index 0000000000..f08df58860--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJobRunService.java@@ -0,0 +1,264 @@+package io.github.hectorvent.floci.services.glue;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.glue.model.ExecutionProperty;+import io.github.hectorvent.floci.services.glue.model.Job;+import io.github.hectorvent.floci.services.glue.model.JobRun;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.time.Clock;+import java.time.Duration;+import java.time.Instant;+import java.util.ArrayList;+import java.util.Comparator;+import java.util.List;+import java.util.Set;+import java.util.UUID;++/**+ * Glue job runs. No script executes: a run follows Glue's state machine and its response shape,+ * and settles lazily when read. With the default {@code job-run-duration-seconds} of 0 a run is+ * SUCCEEDED as soon as it starts; a positive duration keeps it RUNNING until that much time has+ * passed, which is what makes BatchStopJobRun and MaxConcurrentRuns observable.+ *+ * <p>Every public method is synchronized: the store has no atomic compare and set, so admitting a+ * run (count the live runs, check the limit, write the run), stopping one, settling one and+ * removing a deleted job's runs must not interleave.+ */+@ApplicationScoped+public class GlueJobRunService {++ private static final Logger LOG = Logger.getLogger(GlueJobRunService.class);++ static final String STATE_RUNNING = "RUNNING";+ static final String STATE_SUCCEEDED = "SUCCEEDED";+ static final String STATE_STOPPED = "STOPPED";+ static final String STATE_TIMEOUT = "TIMEOUT";++ private static final Set<String> TERMINAL_STATES =+ Set.of(STATE_SUCCEEDED, STATE_STOPPED, "FAILED", STATE_TIMEOUT, "ERROR", "EXPIRED");++ // ExecutionProperty.MaxConcurrentRuns defaults to 1 when a job does not set it.+ private static final int DEFAULT_MAX_CONCURRENT_RUNS = 1;+ private static final int MAX_JOB_RUNS_PAGE_SIZE = 200;+ private static final String LOG_GROUP_NAME = "/aws-glue/jobs";++ private final StorageBackend<String, JobRun> runStore;+ private final GlueService glueService;+ private final int runDurationSeconds;+ private final Clock clock;++ @Inject+ public GlueJobRunService(StorageFactory storageFactory, GlueService glueService, EmulatorConfig config) {+ this(storageFactory.create("glue", "job_runs.json", new TypeReference<>() {}),+ glueService, config.services().glue().jobRunDurationSeconds(), Clock.systemUTC());+ }++ GlueJobRunService(StorageBackend<String, JobRun> runStore, GlueService glueService,+ int runDurationSeconds, Clock clock) {+ if (runDurationSeconds < 0) {+ throw new IllegalArgumentException(+ "floci.services.glue.job-run-duration-seconds must not be negative: " + runDurationSeconds);+ }+ this.runStore = runStore;+ this.glueService = glueService;+ this.runDurationSeconds = runDurationSeconds;+ this.clock = clock;+ }++ /**+ * Starts a run of {@code jobName}. {@code overrides} carries the per-run request fields+ * (Arguments, Timeout, WorkerType, NumberOfWorkers, MaxCapacity, AllocatedCapacity,+ * SecurityConfiguration, NotificationProperty, ExecutionClass, JobRunQueuingEnabled); an+ * unset field falls back to the job definition.+ */+ public synchronized JobRun startJobRun(String jobName, String previousRunId, JobRun overrides) {+ Job job = glueService.getJob(jobName);+ // The job's own Timeout is stored as given by CreateJob/UpdateJob, so check what the run inherits.+ Integer timeout = firstNonNull(overrides.getTimeout(), job.getTimeout());+ if (timeout != null && timeout < 1) {+ throw new AwsException("InvalidInputException", "Timeout must be at least 1 minute.", 400);+ }+ if (previousRunId != null) {+ findRun(jobName, previousRunId);+ }++ boolean queuingEnabled = Boolean.TRUE.equals(firstNonNull(+ overrides.getJobRunQueuingEnabled(), job.getJobRunQueuingEnabled()));+ long active = runsOf(jobName).stream().filter(run -> !isTerminal(settle(run))).count();+ if (!queuingEnabled && active >= maxConcurrentRuns(job)) {+ throw new AwsException("ConcurrentRunsExceededException",+ "Concurrent runs exceeded for " + jobName, 400);+ }++ Instant now = clock.instant();+ JobRun run = new JobRun();+ run.setId(newRunId());+ run.setAttempt(0);+ run.setPreviousRunId(previousRunId);+ run.setJobName(job.getName());+ run.setJobMode(job.getJobMode());+ run.setJobRunQueuingEnabled(queuingEnabled);+ run.setStartedOn(now);+ run.setLastModifiedOn(now);+ run.setJobRunState(STATE_RUNNING);+ run.setArguments(overrides.getArguments());+ run.setAllocatedCapacity(firstNonNull(overrides.getAllocatedCapacity(), job.getAllocatedCapacity()));+ run.setTimeout(timeout);+ run.setMaxCapacity(firstNonNull(overrides.getMaxCapacity(), job.getMaxCapacity()));+ run.setWorkerType(firstNonNull(overrides.getWorkerType(), job.getWorkerType()));+ run.setNumberOfWorkers(firstNonNull(overrides.getNumberOfWorkers(), job.getNumberOfWorkers()));+ run.setSecurityConfiguration(+ firstNonNull(overrides.getSecurityConfiguration(), job.getSecurityConfiguration()));+ run.setNotificationProperty(+ firstNonNull(overrides.getNotificationProperty(), job.getNotificationProperty()));+ run.setExecutionClass(firstNonNull(overrides.getExecutionClass(), job.getExecutionClass()));+ run.setGlueVersion(job.getGlueVersion());+ run.setLogGroupName(LOG_GROUP_NAME);+ run.setExecutionTime(0);+ runStore.put(run.getId(), run);+ LOG.infov("Started Glue job run {0} for job {1}", run.getId(), jobName);+ return settle(run);+ }++ public synchronized JobRun getJobRun(String jobName, String runId) {+ glueService.getJob(jobName);+ if (runId == null) {+ throw new AwsException("InvalidInputException", "RunId is required.", 400);+ }+ return settle(findRun(jobName, runId));+ }++ public synchronized GlueService.Page<JobRun> getJobRuns(String jobName, Integer maxResults,+ String nextToken) {+ glueService.getJob(jobName);+ if (maxResults != null && (maxResults < 1 || maxResults > MAX_JOB_RUNS_PAGE_SIZE)) {+ throw new AwsException("InvalidInputException",+ "MaxResults must be between 1 and " + MAX_JOB_RUNS_PAGE_SIZE, 400);+ }+ List<JobRun> runs = new ArrayList<>();+ for (JobRun run : runsOf(jobName)) {+ runs.add(settle(run));+ }+ runs.sort(Comparator.comparing(JobRun::getStartedOn).reversed().thenComparing(JobRun::getId));+ return glueService.paginate(runs, maxResults, nextToken);+ }++ public synchronized StopResult batchStopJobRun(String jobName, List<String> runIds) {+ if (jobName == null) {+ throw new AwsException("InvalidInputException", "JobName is required.", 400);+ }+ if (runIds == null || runIds.isEmpty()) {+ throw new AwsException("InvalidInputException", "JobRunIds is required.", 400);+ }+ List<StoppedRun> stopped = new ArrayList<>();+ List<StopError> errors = new ArrayList<>();+ for (String runId : runIds) {+ JobRun run = runStore.get(runId)+ .filter(candidate -> jobName.equals(candidate.getJobName()))+ .orElse(null);+ if (run == null) {+ errors.add(new StopError(jobName, runId, "EntityNotFoundException",+ "Job run " + runId + " not found for job " + jobName));+ continue;+ }+ settle(run);+ if (isTerminal(run)) {+ errors.add(new StopError(jobName, runId, "InvalidInputException",+ "Job run " + runId + " is not running; its state is " + run.getJobRunState()));+ continue;+ }+ complete(run, STATE_STOPPED, clock.instant(), null);+ stopped.add(new StoppedRun(jobName, runId));+ }+ return new StopResult(stopped, errors);+ }++ /** Runs belong to their job: deleting the job removes them, as it does on AWS. */+ public synchronized void deleteRuns(String jobName) {+ for (JobRun run : runsOf(jobName)) {+ runStore.delete(run.getId());+ }+ }++ private JobRun settle(JobRun run) {+ if (isTerminal(run)) {+ return run;+ }+ Instant startedOn = run.getStartedOn();+ long timeoutSeconds = run.getTimeout() == null ? Long.MAX_VALUE : run.getTimeout() * 60L;+ if (runDurationSeconds >= timeoutSeconds) {+ Instant timedOutAt = startedOn.plusSeconds(timeoutSeconds);+ if (!clock.instant().isBefore(timedOutAt)) {+ complete(run, STATE_TIMEOUT, timedOutAt,+ "Job run exceeded the timeout of " + run.getTimeout() + " minutes");+ }+ return run;+ }+ Instant finishedAt = startedOn.plusSeconds(runDurationSeconds);+ if (!clock.instant().isBefore(finishedAt)) {+ complete(run, STATE_SUCCEEDED, finishedAt, null);+ }+ return run;+ }++ private void complete(JobRun run, String state, Instant completedOn, String errorMessage) {+ run.setJobRunState(state);+ run.setCompletedOn(completedOn);+ run.setLastModifiedOn(completedOn);+ run.setExecutionTime((int) Duration.between(run.getStartedOn(), completedOn).toSeconds());+ run.setErrorMessage(errorMessage);+ runStore.put(run.getId(), run);+ }++ private JobRun findRun(String jobName, String runId) {+ return runStore.get(runId)+ .filter(run -> jobName.equals(run.getJobName()))+ .orElseThrow(() -> new AwsException("EntityNotFoundException",+ "Job run " + runId + " not found for job " + jobName, 400));+ }++ private List<JobRun> runsOf(String jobName) {+ List<JobRun> runs = new ArrayList<>();+ for (JobRun run : runStore.scan(key -> true)) {+ if (jobName.equals(run.getJobName())) {+ runs.add(run);+ }+ }+ return runs;+ }++ private static boolean isTerminal(JobRun run) {+ return TERMINAL_STATES.contains(run.getJobRunState());+ }++ private static int maxConcurrentRuns(Job job) {+ ExecutionProperty property = job.getExecutionProperty();+ if (property == null || property.getMaxConcurrentRuns() == null) {+ return DEFAULT_MAX_CONCURRENT_RUNS;+ }+ return property.getMaxConcurrentRuns();+ }++ // Glue job run ids are "jr_" followed by 64 hex characters.+ private static String newRunId() {+ return "jr_" + UUID.randomUUID().toString().replace("-", "")+ + UUID.randomUUID().toString().replace("-", "");+ }++ private static <T> T firstNonNull(T preferred, T fallback) {+ return preferred != null ? preferred : fallback;+ }++ public record StoppedRun(String jobName, String jobRunId) {}++ public record StopError(String jobName, String jobRunId, String errorCode, String errorMessage) {}++ public record StopResult(List<StoppedRun> stopped, List<StopError> errors) {}+}diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.javaindex 7adc50be74..670b124714 100644--- a/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueJsonHandler.java@@ -31,14 +31,17 @@ public class GlueJsonHandler {private static final TypeReference<List<Partition>> PARTITION_LIST = new TypeReference<>() {};private final GlueService glueService;+ private final GlueJobRunService jobRunService;private final GlueSchemaRegistryService schemaRegistryService;private final ObjectMapper mapper;@Injectpublic GlueJsonHandler(GlueService glueService,+ GlueJobRunService jobRunService,GlueSchemaRegistryService schemaRegistryService,ObjectMapper mapper) {this.glueService = glueService;+ this.jobRunService = jobRunService;this.schemaRegistryService = schemaRegistryService;this.mapper = mapper;}@@ -233,9 +236,43 @@ public class GlueJsonHandler {}case "DeleteJob" -> {DeleteJobRequest req = mapper.treeToValue(request, DeleteJobRequest.class);+ // Job first, runs second: a StartJobRun that checked the job before it was deleted has+ // stored its run by the time deleteRuns takes the run service's lock.glueService.deleteJob(req.getJobName(), region);+ jobRunService.deleteRuns(req.getJobName());yield Response.ok(new DeleteJobResponse(req.getJobName())).build();}+ case "ListJobs" -> {+ Map<String, String> tags = request.hasNonNull("Tags")+ ? mapper.convertValue(request.get("Tags"), STRING_MAP)+ : null;+ GlueService.Page<String> page = glueService.listJobs(+ readMaxResults(request), readNextToken(request), tags, region);+ yield Response.ok(pageResponse("JobNames", page.items(), page.nextToken())).build();+ }+ case "BatchGetJobs" -> {+ List<String> names = request.hasNonNull("JobNames")+ ? mapper.convertValue(request.get("JobNames"), STRING_LIST)+ : null;+ GlueService.BatchGetJobsResult result = glueService.batchGetJobs(names);+ Map<String, Object> response = new LinkedHashMap<>();+ response.put("Jobs", result.jobs());+ response.put("JobsNotFound", result.jobsNotFound());+ yield Response.ok(response).build();+ }+ case "StartJobRun" -> {+ JobRun run = jobRunService.startJobRun(request.path("JobName").asText(null),+ request.path("JobRunId").asText(null), jobRunOverrides(request));+ yield Response.ok(Map.of("JobRunId", run.getId())).build();+ }+ case "GetJobRun" -> Response.ok(Map.of("JobRun", jobRunService.getJobRun(+ request.path("JobName").asText(null), request.path("RunId").asText(null)))).build();+ case "GetJobRuns" -> {+ GlueService.Page<JobRun> page = jobRunService.getJobRuns(+ request.path("JobName").asText(null), readMaxResults(request), readNextToken(request));+ yield Response.ok(pageResponse("JobRuns", page.items(), page.nextToken())).build();+ }+ case "BatchStopJobRun" -> handleBatchStopJobRun(request);case "CreateClassifier" -> {Classifier classifier = mapper.treeToValue(request, Classifier.class);glueService.createClassifier(classifier);@@ -971,6 +1008,72 @@ public class GlueJsonHandler {return Response.ok(Map.of()).build();}+ private JobRun jobRunOverrides(JsonNode request) throws Exception {+ JobRun overrides = new JobRun();+ if (request.hasNonNull("Arguments")) {+ overrides.setArguments(mapper.convertValue(request.get("Arguments"), STRING_MAP));+ }+ if (request.hasNonNull("AllocatedCapacity")) {+ overrides.setAllocatedCapacity(request.get("AllocatedCapacity").asInt());+ }+ if (request.hasNonNull("Timeout")) {+ overrides.setTimeout(request.get("Timeout").asInt());+ }+ if (request.hasNonNull("MaxCapacity")) {+ overrides.setMaxCapacity(request.get("MaxCapacity").asDouble());+ }+ if (request.hasNonNull("WorkerType")) {+ overrides.setWorkerType(request.get("WorkerType").asText());+ }+ if (request.hasNonNull("NumberOfWorkers")) {+ overrides.setNumberOfWorkers(request.get("NumberOfWorkers").asInt());+ }+ if (request.hasNonNull("SecurityConfiguration")) {+ overrides.setSecurityConfiguration(request.get("SecurityConfiguration").asText());+ }+ if (request.hasNonNull("NotificationProperty")) {+ overrides.setNotificationProperty(+ mapper.treeToValue(request.get("NotificationProperty"), NotificationProperty.class));+ }+ if (request.hasNonNull("ExecutionClass")) {+ overrides.setExecutionClass(request.get("ExecutionClass").asText());+ }+ if (request.hasNonNull("JobRunQueuingEnabled")) {+ overrides.setJobRunQueuingEnabled(request.get("JobRunQueuingEnabled").asBoolean());+ }+ return overrides;+ }++ private Response handleBatchStopJobRun(JsonNode request) {+ List<String> runIds = request.hasNonNull("JobRunIds")+ ? mapper.convertValue(request.get("JobRunIds"), STRING_LIST)+ : null;+ GlueJobRunService.StopResult result =+ jobRunService.batchStopJobRun(request.path("JobName").asText(null), runIds);+ List<Map<String, Object>> submissions = new ArrayList<>();+ for (GlueJobRunService.StoppedRun stopped : result.stopped()) {+ Map<String, Object> entry = new LinkedHashMap<>();+ entry.put("JobName", stopped.jobName());+ entry.put("JobRunId", stopped.jobRunId());+ submissions.add(entry);+ }+ List<Map<String, Object>> errors = new ArrayList<>();+ for (GlueJobRunService.StopError error : result.errors()) {+ Map<String, Object> detail = new LinkedHashMap<>();+ detail.put("ErrorCode", error.errorCode());+ detail.put("ErrorMessage", error.errorMessage());+ Map<String, Object> entry = new LinkedHashMap<>();+ entry.put("JobName", error.jobName());+ entry.put("JobRunId", error.jobRunId());+ entry.put("ErrorDetail", detail);+ errors.add(entry);+ }+ Map<String, Object> response = new LinkedHashMap<>();+ response.put("SuccessfulSubmissions", submissions);+ response.put("Errors", errors);+ return Response.ok(response).build();+ }+private Response handleGetTags(JsonNode request, String region) {String arn = request.path("ResourceArn").asText(null);Map<String, String> tags = glueService.getTags(arn, region);diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java b/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.javaindex faec21a00e..14277b5803 100644--- a/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java+++ b/src/main/java/io/github/hectorvent/floci/services/glue/GlueService.java@@ -54,6 +54,7 @@ import java.util.LinkedHashMap;import java.util.List;import java.util.Locale;import java.util.Map;+import java.util.Objects;import java.util.Optional;import java.util.Set;import java.util.regex.Matcher;@@ -1728,6 +1729,46 @@ public class GlueService {return paginate(all, maxResults, nextToken);}+ public Page<String> listJobs(Integer maxResults, String nextToken, Map<String, String> tags, String region) {+ List<String> names = new ArrayList<>();+ for (Job job : jobStore.scan(k -> true)) {+ if (tags == null || tags.isEmpty() || hasTags(jobArn(region, job.getName()), tags, region)) {+ names.add(job.getName());+ }+ }+ names.sort(Comparator.naturalOrder());+ return paginate(names, maxResults, nextToken);+ }++ public BatchGetJobsResult batchGetJobs(List<String> names) {+ if (names == null || names.isEmpty()) {+ throw new AwsException("InvalidInputException", "JobNames is required.", 400);+ }+ List<Job> jobs = new ArrayList<>();+ List<String> notFound = new ArrayList<>();+ for (String name : names) {+ Optional<Job> job = name == null ? Optional.empty() : jobStore.get(name);+ if (job.isPresent()) {+ jobs.add(job.get());+ } else {+ notFound.add(name);+ }+ }+ return new BatchGetJobsResult(jobs, notFound);+ }++ public record BatchGetJobsResult(List<Job> jobs, List<String> jobsNotFound) {}++ private boolean hasTags(String arn, Map<String, String> wanted, String region) {+ Map<String, String> actual = resourceGroupsTaggingService.getTagsForResource(region, arn);+ for (Map.Entry<String, String> tag : wanted.entrySet()) {+ if (!Objects.equals(actual.get(tag.getKey()), tag.getValue())) {+ return false;+ }+ }+ return true;+ }+public void updateJob(String name, JobUpdate update) {validateRequired(name, "JobName");validateRequired(update, "JobUpdate");@@ -2476,7 +2517,7 @@ public class GlueService {public record Page<T>(List<T> items, String nextToken) {}- private <T> Page<T> paginate(List<T> all, Integer maxResults, String nextToken) {+ <T> Page<T> paginate(List<T> all, Integer maxResults, String nextToken) {if (maxResults != null && (maxResults < 1 || maxResults > 1000)) {throw new AwsException("InvalidInputException", "MaxResults must be between 1 and 1000", 400);}diff --git a/src/main/java/io/github/hectorvent/floci/services/glue/model/JobRun.java b/src/main/java/io/github/hectorvent/floci/services/glue/model/JobRun.javanew file mode 100644index 0000000000..2a8affdc25--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/glue/model/JobRun.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.glue.model;++import com.fasterxml.jackson.annotation.JsonFormat;+import com.fasterxml.jackson.annotation.JsonInclude;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.Map;++@RegisterForReflection+@JsonInclude(JsonInclude.Include.NON_NULL)+public class JobRun {+ @JsonProperty("Id")+ private String id;++ @JsonProperty("Attempt")+ private Integer attempt;++ @JsonProperty("PreviousRunId")+ private String previousRunId;++ @JsonProperty("JobName")+ private String jobName;++ @JsonProperty("JobMode")+ private String jobMode;++ @JsonProperty("JobRunQueuingEnabled")+ private Boolean jobRunQueuingEnabled;++ @JsonProperty("StartedOn")+ @JsonFormat(shape = JsonFormat.Shape.NUMBER)+ private Instant startedOn;++ @JsonProperty("LastModifiedOn")+ @JsonFormat(shape = JsonFormat.Shape.NUMBER)+ private Instant lastModifiedOn;++ @JsonProperty("CompletedOn")+ @JsonFormat(shape = JsonFormat.Shape.NUMBER)+ private Instant completedOn;++ @JsonProperty("JobRunState")+ private String jobRunState;++ @JsonProperty("Arguments")+ private Map<String, String> arguments;++ @JsonProperty("ErrorMessage")+ private String errorMessage;++ @JsonProperty("AllocatedCapacity")+ private Integer allocatedCapacity;++ @JsonProperty("ExecutionTime")+ private Integer executionTime;++ @JsonProperty("Timeout")+ private Integer timeout;++ @JsonProperty("MaxCapacity")+ private Double maxCapacity;++ @JsonProperty("WorkerType")+ private String workerType;++ @JsonProperty("NumberOfWorkers")+ private Integer numberOfWorkers;++ @JsonProperty("SecurityConfiguration")+ private String securityConfiguration;++ @JsonProperty("LogGroupName")+ private String logGroupName;++ @JsonProperty("NotificationProperty")+ private NotificationProperty notificationProperty;++ @JsonProperty("GlueVersion")+ private String glueVersion;++ @JsonProperty("ExecutionClass")+ private String executionClass;++ public JobRun() {}++ public String getId() { return id; }+ public void setId(String id) { this.id = id; }++ public Integer getAttempt() { return attempt; }+ public void setAttempt(Integer attempt) { this.attempt = attempt; }++ public String getPreviousRunId() { return previousRunId; }+ public void setPreviousRunId(String previousRunId) { this.previousRunId = previousRunId; }++ public String getJobName() { return jobName; }+ public void setJobName(String jobName) { this.jobName = jobName; }++ public String getJobMode() { return jobMode; }+ public void setJobMode(String jobMode) { this.jobMode = jobMode; }++ public Boolean getJobRunQueuingEnabled() { return jobRunQueuingEnabled; }+ public void setJobRunQueuingEnabled(Boolean jobRunQueuingEnabled) { this.jobRunQueuingEnabled = jobRunQueuingEnabled; }++ public Instant getStartedOn() { return startedOn; }+ public void setStartedOn(Instant startedOn) { this.startedOn = startedOn; }++ public Instant getLastModifiedOn() { return lastModifiedOn; }+ public void setLastModifiedOn(Instant lastModifiedOn) { this.lastModifiedOn = lastModifiedOn; }++ public Instant getCompletedOn() { return completedOn; }+ public void setCompletedOn(Instant completedOn) { this.completedOn = completedOn; }++ public String getJobRunState() { return jobRunState; }+ public void setJobRunState(String jobRunState) { this.jobRunState = jobRunState; }++ public Map<String, String> getArguments() { return arguments; }+ public void setArguments(Map<String, String> arguments) { this.arguments = arguments; }++ public String getErrorMessage() { return errorMessage; }+ public void setErrorMessage(String errorMessage) { this.errorMessage = errorMessage; }++ public Integer getAllocatedCapacity() { return allocatedCapacity; }+ public void setAllocatedCapacity(Integer allocatedCapacity) { this.allocatedCapacity = allocatedCapacity; }++ public Integer getExecutionTime() { return executionTime; }+ public void setExecutionTime(Integer executionTime) { this.executionTime = executionTime; }++ public Integer getTimeout() { return timeout; }+ public void setTimeout(Integer timeout) { this.timeout = timeout; }++ public Double getMaxCapacity() { return maxCapacity; }+ public void setMaxCapacity(Double maxCapacity) { this.maxCapacity = maxCapacity; }++ public String getWorkerType() { return workerType; }+ public void setWorkerType(String workerType) { this.workerType = workerType; }++ public Integer getNumberOfWorkers() { return numberOfWorkers; }+ public void setNumberOfWorkers(Integer numberOfWorkers) { this.numberOfWorkers = numberOfWorkers; }++ public String getSecurityConfiguration() { return securityConfiguration; }+ public void setSecurityConfiguration(String securityConfiguration) { this.securityConfiguration = securityConfiguration; }++ public String getLogGroupName() { return logGroupName; }+ public void setLogGroupName(String logGroupName) { this.logGroupName = logGroupName; }++ public NotificationProperty getNotificationProperty() { return notificationProperty; }+ public void setNotificationProperty(NotificationProperty notificationProperty) { this.notificationProperty = notificationProperty; }++ public String getGlueVersion() { return glueVersion; }+ public void setGlueVersion(String glueVersion) { this.glueVersion = glueVersion; }++ public String getExecutionClass() { return executionClass; }+ public void setExecutionClass(String executionClass) { this.executionClass = executionClass; }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex e351066351..882d7bcd02 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -509,6 +509,7 @@ floci:default-image: "floci/floci-duck:latest"glue:enabled: true+ job-run-duration-seconds: 0 # 0 = job runs succeed as soon as they startses:enabled: true# smtp-host: mailpit # SMTP server for email relay (empty = store only)diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJobRunIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJobRunIntegrationTest.javanew file mode 100644index 0000000000..29ae53aa25--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJobRunIntegrationTest.java@@ -0,0 +1,62 @@+package io.github.hectorvent.floci.services.glue;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItem;+import static org.hamcrest.Matchers.matchesPattern;++@QuarkusTest+class GlueJobRunIntegrationTest {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.1";+ private static final String ROLE = "arn:aws:iam::000000000000:role/my-role";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ private static ValidatableResponse call(String action, String body) {+ return given().contentType(CONTENT_TYPE)+ .header("X-Amz-Target", "AWSGlue." + action)+ .body(body)+ .when().post("/")+ .then();+ }++ @Test+ void jobRunStartsSucceedsAndIsRemovedWithItsJob() {+ String jobName = "run-job-" + UUID.randomUUID().toString().substring(0, 8);+ call("CreateJob", """+ { "Name": "%s", "Role": "%s", "Command": { "Name": "glueetl" } }+ """.formatted(jobName, ROLE)).statusCode(200);++ String runId = call("StartJobRun", "{ \"JobName\": \"" + jobName + "\" }")+ .statusCode(200)+ .body("JobRunId", matchesPattern("jr_[0-9a-f]{64}"))+ .extract().path("JobRunId");++ call("GetJobRun", "{ \"JobName\": \"" + jobName + "\", \"RunId\": \"" + runId + "\" }")+ .statusCode(200)+ .body("JobRun.Id", equalTo(runId))+ .body("JobRun.JobRunState", equalTo("SUCCEEDED"));++ call("ListJobs", "{}")+ .statusCode(200)+ .body("JobNames", hasItem(jobName));++ call("DeleteJob", "{ \"JobName\": \"" + jobName + "\" }").statusCode(200);++ call("GetJobRuns", "{ \"JobName\": \"" + jobName + "\" }")+ .statusCode(400)+ .body("__type", equalTo("EntityNotFoundException"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJobRunServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJobRunServiceTest.javanew file mode 100644index 0000000000..178af64361--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJobRunServiceTest.java@@ -0,0 +1,465 @@+package io.github.hectorvent.floci.services.glue;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.glue.model.ExecutionProperty;+import io.github.hectorvent.floci.services.glue.model.Job;+import io.github.hectorvent.floci.services.glue.model.JobCommand;+import io.github.hectorvent.floci.services.glue.model.JobRun;+import io.github.hectorvent.floci.services.glue.schemaregistry.GlueSchemaRegistryService;+import io.github.hectorvent.floci.services.kms.KmsService;+import io.github.hectorvent.floci.services.resourcegroupstagging.ResourceGroupsTaggingService;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.time.Clock;+import java.time.Instant;+import java.time.ZoneId;+import java.time.ZoneOffset;+import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.Optional;+import java.util.Set;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.TimeoutException;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.function.Predicate;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class GlueJobRunServiceTest {++ private static final String REGION = "us-east-1";+ private static final String ACCOUNT_ID = "000000000000";+ private static final String ROLE = "arn:aws:iam::000000000000:role/glue";+ private static final Instant T0 = Instant.parse("2026-09-25T12:00:00Z");++ private GlueService glueService;+ private InMemoryStorage<String, JobRun> runStore;+ private MutableClock clock;++ @BeforeEach+ void setUp() {+ RegionResolver regionResolver = new RegionResolver(REGION, ACCOUNT_ID);+ StorageFactory storageFactory = new InMemoryStorageFactory();+ glueService = new GlueService(storageFactory, new GlueSchemaRegistryService(storageFactory, regionResolver),+ regionResolver, new ResourceGroupsTaggingService(storageFactory),+ new KmsService(storageFactory, regionResolver));+ runStore = new InMemoryStorage<>();+ clock = new MutableClock(T0);+ }++ private GlueJobRunService service(int runDurationSeconds) {+ return new GlueJobRunService(runStore, glueService, runDurationSeconds, clock);+ }++ private Job createJob(String name, Integer maxConcurrentRuns, Integer timeoutMinutes) {+ Job job = new Job();+ job.setName(name);+ job.setRole(ROLE);+ job.setCommand(new JobCommand());+ job.setWorkerType("G.1X");+ job.setNumberOfWorkers(2);+ job.setTimeout(timeoutMinutes);+ if (maxConcurrentRuns != null) {+ ExecutionProperty property = new ExecutionProperty();+ property.setMaxConcurrentRuns(maxConcurrentRuns);+ job.setExecutionProperty(property);+ }+ glueService.createJob(job, null, REGION);+ return job;+ }++ @Test+ void runSucceedsAsSoonAsItStartsByDefault() {+ createJob("etl", null, null);++ JobRun run = service(0).startJobRun("etl", null, new JobRun());++ assertTrue(run.getId().matches("jr_[0-9a-f]{64}"), run.getId());+ assertEquals("SUCCEEDED", run.getJobRunState());+ assertEquals(T0, run.getStartedOn());+ assertEquals(T0, run.getCompletedOn());+ assertEquals(0, run.getExecutionTime());+ assertEquals(0, run.getAttempt());+ assertEquals("G.1X", run.getWorkerType());+ assertEquals(2, run.getNumberOfWorkers());+ assertEquals(480, run.getTimeout());+ assertEquals("5.1", run.getGlueVersion());+ assertEquals("/aws-glue/jobs", run.getLogGroupName());+ }++ @Test+ void requestFieldsOverrideTheJobDefinitionForThatRunOnly() {+ createJob("etl", null, null);+ JobRun overrides = new JobRun();+ overrides.setArguments(Map.of("--day", "2026-09-25"));+ overrides.setWorkerType("G.2X");+ overrides.setNumberOfWorkers(10);+ overrides.setTimeout(30);++ JobRun run = service(0).startJobRun("etl", null, overrides);++ assertEquals(Map.of("--day", "2026-09-25"), run.getArguments());+ assertEquals("G.2X", run.getWorkerType());+ assertEquals(10, run.getNumberOfWorkers());+ assertEquals(30, run.getTimeout());+ assertEquals("G.1X", glueService.getJob("etl").getWorkerType());+ }++ @Test+ void runStaysRunningUntilTheConfiguredDurationHasPassed() {+ createJob("etl", null, null);+ GlueJobRunService service = service(60);+ String runId = service.startJobRun("etl", null, new JobRun()).getId();++ clock.set(T0.plusSeconds(59));+ JobRun running = service.getJobRun("etl", runId);+ assertEquals("RUNNING", running.getJobRunState());+ assertNull(running.getCompletedOn());++ clock.set(T0.plusSeconds(90));+ JobRun finished = service.getJobRun("etl", runId);+ assertEquals("SUCCEEDED", finished.getJobRunState());+ assertEquals(T0.plusSeconds(60), finished.getCompletedOn());+ assertEquals(60, finished.getExecutionTime());+ }++ @Test+ void runLongerThanTheJobTimeoutEndsInTimeout() {+ createJob("etl", null, 1);+ GlueJobRunService service = service(120);+ String runId = service.startJobRun("etl", null, new JobRun()).getId();++ clock.set(T0.plusSeconds(61));+ JobRun run = service.getJobRun("etl", runId);++ assertEquals("TIMEOUT", run.getJobRunState());+ assertEquals(T0.plusSeconds(60), run.getCompletedOn());+ assertEquals(60, run.getExecutionTime());+ }++ @Test+ void secondRunIsRejectedWhileMaxConcurrentRunsDefaultsToOne() {+ createJob("etl", null, null);+ GlueJobRunService service = service(60);+ service.startJobRun("etl", null, new JobRun());++ AwsException error = assertThrows(AwsException.class,+ () -> service.startJobRun("etl", null, new JobRun()));+ assertEquals("ConcurrentRunsExceededException", error.getErrorCode());++ clock.set(T0.plusSeconds(60));+ assertEquals("RUNNING", service.startJobRun("etl", null, new JobRun()).getJobRunState());+ }++ @Test+ void maxConcurrentRunsAndQueuingBothAdmitAnotherRun() {+ createJob("wide", 2, null);+ createJob("queued", null, null);+ GlueJobRunService service = service(60);++ service.startJobRun("wide", null, new JobRun());+ service.startJobRun("wide", null, new JobRun());+ assertThrows(AwsException.class, () -> service.startJobRun("wide", null, new JobRun()));++ JobRun queuing = new JobRun();+ queuing.setJobRunQueuingEnabled(true);+ service.startJobRun("queued", null, new JobRun());+ assertTrue(service.startJobRun("queued", null, queuing).getJobRunQueuingEnabled());+ }++ @Test+ void batchStopStopsARunningRunAndReportsTheRest() {+ createJob("etl", 5, null);+ GlueJobRunService service = service(60);+ String finished = service.startJobRun("etl", null, new JobRun()).getId();+ clock.set(T0.plusSeconds(60));+ String stillRunning = service.startJobRun("etl", null, new JobRun()).getId();+ clock.set(T0.plusSeconds(70));++ GlueJobRunService.StopResult result =+ service.batchStopJobRun("etl", List.of(stillRunning, finished, "jr_missing"));++ assertEquals(List.of(new GlueJobRunService.StoppedRun("etl", stillRunning)), result.stopped());+ assertEquals(2, result.errors().size());+ assertEquals("InvalidInputException", result.errors().get(0).errorCode());+ assertEquals("EntityNotFoundException", result.errors().get(1).errorCode());+ JobRun stopped = service.getJobRun("etl", stillRunning);+ assertEquals("STOPPED", stopped.getJobRunState());+ assertEquals(10, stopped.getExecutionTime());+ assertEquals("SUCCEEDED", service.getJobRun("etl", finished).getJobRunState());+ }++ @Test+ void getJobRunsListsNewestFirstAndPages() {+ createJob("etl", 10, null);+ GlueJobRunService service = service(0);+ String first = service.startJobRun("etl", null, new JobRun()).getId();+ clock.set(T0.plusSeconds(1));+ String second = service.startJobRun("etl", null, new JobRun()).getId();++ GlueService.Page<JobRun> page = service.getJobRuns("etl", 1, null);+ assertEquals(second, page.items().getFirst().getId());+ GlueService.Page<JobRun> next = service.getJobRuns("etl", 1, page.nextToken());+ assertEquals(first, next.items().getFirst().getId());+ assertNull(next.nextToken());++ AwsException tooMany = assertThrows(AwsException.class, () -> service.getJobRuns("etl", 201, null));+ assertEquals("InvalidInputException", tooMany.getErrorCode());+ }++ @Test+ void runsAreScopedToTheirJob() {+ createJob("a", null, null);+ createJob("b", null, null);+ GlueJobRunService service = service(0);+ String runOfA = service.startJobRun("a", null, new JobRun()).getId();++ AwsException error = assertThrows(AwsException.class, () -> service.getJobRun("b", runOfA));+ assertEquals("EntityNotFoundException", error.getErrorCode());+ assertTrue(service.getJobRuns("b", null, null).items().isEmpty());+ }++ @Test+ void unknownJobOrRetriedRunIsEntityNotFound() {+ createJob("etl", null, null);+ GlueJobRunService service = service(0);++ assertEquals("EntityNotFoundException", assertThrows(AwsException.class,+ () -> service.startJobRun("missing", null, new JobRun())).getErrorCode());+ assertEquals("EntityNotFoundException", assertThrows(AwsException.class,+ () -> service.startJobRun("etl", "jr_missing", new JobRun())).getErrorCode());++ String first = service.startJobRun("etl", null, new JobRun()).getId();+ assertEquals(first, service.startJobRun("etl", first, new JobRun()).getPreviousRunId());+ }++ @Test+ void deletingTheJobRemovesItsRuns() {+ createJob("etl", null, null);+ GlueJobRunService service = service(0);+ service.startJobRun("etl", null, new JobRun());++ glueService.deleteJob("etl", REGION);+ service.deleteRuns("etl");+ createJob("etl", null, null);++ assertTrue(service.getJobRuns("etl", null, null).items().isEmpty());+ assertTrue(runStore.scan(key -> true).isEmpty());+ }++ @Test+ void concurrentStartsAdmitNoMoreThanMaxConcurrentRuns() throws Exception {+ createJob("etl", null, null);+ GlueJobRunService service = service(60);+ int threads = 16;+ CountDownLatch go = new CountDownLatch(1);+ AtomicInteger admitted = new AtomicInteger();+ AtomicInteger rejected = new AtomicInteger();+ ExecutorService pool = Executors.newFixedThreadPool(threads);+ try {+ List<Future<?>> futures = new ArrayList<>();+ for (int i = 0; i < threads; i++) {+ futures.add(pool.submit(() -> {+ go.await();+ try {+ service.startJobRun("etl", null, new JobRun());+ admitted.incrementAndGet();+ } catch (AwsException expected) {+ // ConcurrentRunsExceededException is the outcome under test for all but one start.+ rejected.incrementAndGet();+ }+ return null;+ }));+ }+ go.countDown();+ for (Future<?> future : futures) {+ future.get(10, TimeUnit.SECONDS);+ }+ } finally {+ pool.shutdownNow();+ }++ assertEquals(1, admitted.get());+ assertEquals(threads - 1, rejected.get());+ assertEquals(1, runStore.scan(key -> true).size());+ }++ /**+ * Holds the run write inside StartJobRun open while DeleteJob runs. Without the service lock,+ * deleteRuns scans before the run is stored and the run outlives its job; with it, deleteRuns+ * waits for the write and removes the run.+ */+ @Test+ void startRacingDeleteNeverLeavesARunBehind() throws Exception {+ createJob("etl", null, null);+ PausingStore store = new PausingStore(runStore);+ GlueJobRunService service = new GlueJobRunService(store, glueService, 60, clock);+ ExecutorService pool = Executors.newFixedThreadPool(2);+ try {+ Future<?> start = pool.submit(() -> service.startJobRun("etl", null, new JobRun()));+ assertTrue(store.putStarted.await(10, TimeUnit.SECONDS));++ Future<?> delete = pool.submit(() -> {+ glueService.deleteJob("etl", REGION);+ service.deleteRuns("etl");+ return null;+ });+ try {+ delete.get(500, TimeUnit.MILLISECONDS);+ } catch (TimeoutException expected) {+ // With the lock held by the paused start, the delete is still waiting here.+ }+ store.release.countDown();+ start.get(10, TimeUnit.SECONDS);+ delete.get(10, TimeUnit.SECONDS);+ } finally {+ pool.shutdownNow();+ }++ assertTrue(runStore.scan(key -> true).isEmpty());+ }++ @Test+ void timeoutBelowOneMinuteIsRejected() {+ createJob("etl", null, null);+ JobRun overrides = new JobRun();+ overrides.setTimeout(-5);++ AwsException error = assertThrows(AwsException.class,+ () -> service(0).startJobRun("etl", null, overrides));++ assertEquals("InvalidInputException", error.getErrorCode());+ assertTrue(runStore.scan(key -> true).isEmpty());+ }++ @Test+ void zeroTimeoutInheritedFromTheJobIsRejected() {+ createJob("etl", null, 0);++ AwsException error = assertThrows(AwsException.class,+ () -> service(0).startJobRun("etl", null, new JobRun()));++ assertEquals("InvalidInputException", error.getErrorCode());+ assertTrue(runStore.scan(key -> true).isEmpty());+ }++ @Test+ void negativeRunDurationIsRefusedAtConstruction() {+ assertThrows(IllegalArgumentException.class, () -> service(-1));+ }++ /** Delegates to a store, pausing the first put until {@code release} opens. */+ private static final class PausingStore implements StorageBackend<String, JobRun> {+ private final StorageBackend<String, JobRun> delegate;+ private final CountDownLatch putStarted = new CountDownLatch(1);+ private final CountDownLatch release = new CountDownLatch(1);++ private PausingStore(StorageBackend<String, JobRun> delegate) {+ this.delegate = delegate;+ }++ @Override+ public void put(String key, JobRun value) {+ if (putStarted.getCount() > 0) {+ putStarted.countDown();+ try {+ release.await(10, TimeUnit.SECONDS);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("interrupted while paused", e);+ }+ }+ delegate.put(key, value);+ }++ @Override+ public Optional<JobRun> get(String key) {+ return delegate.get(key);+ }++ @Override+ public void delete(String key) {+ delegate.delete(key);+ }++ @Override+ public List<JobRun> scan(Predicate<String> keyFilter) {+ return delegate.scan(keyFilter);+ }++ @Override+ public Set<String> keys() {+ return delegate.keys();+ }++ @Override+ public void flush() {+ delegate.flush();+ }++ @Override+ public void load() {+ delegate.load();+ }++ @Override+ public void clear() {+ delegate.clear();+ }+ }++ private static final class InMemoryStorageFactory extends StorageFactory {+ private InMemoryStorageFactory() {+ super(null, null);+ }++ @Override+ public <V> AccountAwareStorageBackend<V> create(String serviceName,+ String fileName,+ TypeReference<Map<String, V>> typeReference) {+ return AccountAwareStorageBackend.inMemory(ACCOUNT_ID);+ }+ }++ private static final class MutableClock extends Clock {+ private Instant now;++ private MutableClock(Instant now) {+ this.now = now;+ }++ void set(Instant now) {+ this.now = now;+ }++ @Override+ public ZoneOffset getZone() {+ return ZoneOffset.UTC;+ }++ @Override+ public Clock withZone(ZoneId zone) {+ return this;+ }++ @Override+ public Instant instant() {+ return now;+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerEmptyListTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerEmptyListTest.javaindex 281fd7a6b6..b28c93ec7d 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerEmptyListTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerEmptyListTest.java@@ -15,6 +15,7 @@ import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import com.fasterxml.jackson.core.type.TypeReference;+import java.time.Clock;import java.util.Map;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -44,7 +45,9 @@ class GlueJsonHandlerEmptyListTest {GlueService glueService = new GlueService(storageFactory, schemaRegistryService, regionResolver,new ResourceGroupsTaggingService(storageFactory), new KmsService(storageFactory, regionResolver));- handler = new GlueJsonHandler(glueService, schemaRegistryService, mapper);+ handler = new GlueJsonHandler(glueService,+ new GlueJobRunService(new InMemoryStorage<>(), glueService, 0, Clock.systemUTC()),+ schemaRegistryService, mapper);}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.javaindex 7326862cfa..88ab00f401 100644--- a/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/glue/GlueJsonHandlerTest.java@@ -7,6 +7,7 @@ import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.glue.schemaregistry.GlueSchemaRegistryService;import io.github.hectorvent.floci.services.kms.KmsService;@@ -16,6 +17,7 @@ import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import com.fasterxml.jackson.core.type.TypeReference;+import java.time.Clock;import java.util.List;import java.util.Map;@@ -44,7 +46,9 @@ class GlueJsonHandlerTest {GlueService glueService = new GlueService(storageFactory, schemaRegistryService, regionResolver, new ResourceGroupsTaggingService(storageFactory),new KmsService(storageFactory, regionResolver));- handler = new GlueJsonHandler(glueService, schemaRegistryService, mapper);+ handler = new GlueJsonHandler(glueService,+ new GlueJobRunService(new InMemoryStorage<>(), glueService, 0, Clock.systemUTC()),+ schemaRegistryService, mapper);}private void createDatabaseAndTable(String dbName, String tableName) throws Exception {@@ -793,4 +797,82 @@ class GlueJsonHandlerTest {assertEquals("alias/glue", after.get("ConnectionPasswordEncryption").get("AwsKmsKeyId").asText());assertEquals("DISABLED", after.get("EncryptionAtRest").get("CatalogEncryptionMode").asText());}++ private void createJobWithTags(String name, Map<String, String> tags) throws Exception {+ ObjectNode create = mapper.createObjectNode();+ create.put("Name", name);+ create.put("Role", "arn:aws:iam::000000000000:role/glue");+ create.putObject("Command").put("Name", "glueetl");+ ObjectNode tagNode = create.putObject("Tags");+ tags.forEach(tagNode::put);+ assertEquals(200, handler.handle("CreateJob", create, REGION).getStatus());+ }++ /**+ * The wire shape a job run client reads: StartJobRun answers with the run id alone, GetJobRun+ * nests the run under "JobRun" with numeric timestamps, and stopping a finished run is an entry+ * in Errors rather than a failed request.+ */+ @Test+ void jobRunOperationsAnswerWithTheDocumentedBodies() throws Exception {+ createJobWithTags("nightly", Map.of());++ ObjectNode start = mapper.createObjectNode();+ start.put("JobName", "nightly");+ start.putObject("Arguments").put("--day", "2026-09-25");+ JsonNode started = mapper.valueToTree(handler.handle("StartJobRun", start, REGION).getEntity());+ assertEquals(1, started.size());+ String runId = started.get("JobRunId").asText();++ ObjectNode get = mapper.createObjectNode().put("JobName", "nightly").put("RunId", runId);+ JsonNode run = mapper.valueToTree(handler.handle("GetJobRun", get, REGION).getEntity()).get("JobRun");+ assertEquals(runId, run.get("Id").asText());+ assertEquals("nightly", run.get("JobName").asText());+ assertEquals("SUCCEEDED", run.get("JobRunState").asText());+ assertEquals("2026-09-25", run.get("Arguments").get("--day").asText());+ assertTrue(run.get("StartedOn").isNumber());+ assertTrue(run.get("CompletedOn").isNumber());+ assertFalse(run.has("ErrorMessage"));++ JsonNode runs = mapper.valueToTree(handler.handle(+ "GetJobRuns", mapper.createObjectNode().put("JobName", "nightly"), REGION).getEntity());+ assertEquals(1, runs.get("JobRuns").size());+ assertFalse(runs.has("NextToken"));++ ObjectNode stop = mapper.createObjectNode().put("JobName", "nightly");+ stop.putArray("JobRunIds").add(runId);+ JsonNode stopped = mapper.valueToTree(handler.handle("BatchStopJobRun", stop, REGION).getEntity());+ assertEquals(0, stopped.get("SuccessfulSubmissions").size());+ JsonNode error = stopped.get("Errors").get(0);+ assertEquals("nightly", error.get("JobName").asText());+ assertEquals(runId, error.get("JobRunId").asText());+ assertEquals("InvalidInputException", error.get("ErrorDetail").get("ErrorCode").asText());++ handler.handle("DeleteJob", mapper.createObjectNode().put("JobName", "nightly"), REGION);+ AwsException gone = assertThrows(AwsException.class, () -> handler.handle(+ "GetJobRuns", mapper.createObjectNode().put("JobName", "nightly"), REGION));+ assertEquals("EntityNotFoundException", gone.getErrorCode());+ }++ @Test+ void listJobsFiltersOnTagsAndBatchGetJobsReportsMissingNames() throws Exception {+ createJobWithTags("tagged", Map.of("team", "data"));+ createJobWithTags("plain", Map.of());++ JsonNode all = mapper.valueToTree(handler.handle("ListJobs", mapper.createObjectNode(), REGION).getEntity());+ assertEquals(List.of("plain", "tagged"), mapper.convertValue(all.get("JobNames"), List.class));+ assertFalse(all.has("NextToken"));++ ObjectNode filtered = mapper.createObjectNode();+ filtered.putObject("Tags").put("team", "data");+ JsonNode byTag = mapper.valueToTree(handler.handle("ListJobs", filtered, REGION).getEntity());+ assertEquals(List.of("tagged"), mapper.convertValue(byTag.get("JobNames"), List.class));++ ObjectNode batch = mapper.createObjectNode();+ batch.putArray("JobNames").add("tagged").add("absent");+ JsonNode got = mapper.valueToTree(handler.handle("BatchGetJobs", batch, REGION).getEntity());+ assertEquals(1, got.get("Jobs").size());+ assertEquals("tagged", got.get("Jobs").get(0).get("Name").asText());+ assertEquals("absent", got.get("JobsNotFound").get(0).asText());+ }}