Light, fluffy, and always free - The AWS Local Emulator alternative
fix(stepfunctions): honor explicit Lambda task qualifiers (#6563)
Andre Kurait74a932bc5067
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.mdindex a0d1d82dfc..9e4252f2bd 100644--- a/docs/services/step-functions.md+++ b/docs/services/step-functions.md@@ -51,8 +51,10 @@ Omitting the filter returns all statuses. Invalid filter values or types return`ValidationException`. Map Run execution listing and `PENDING_REDRIVE` filtering are notsupported; `PENDING_REDRIVE` returns `ValidationException` even when a `mapRunArn` is supplied.-Lambda task invocation retains the alias or version from `FunctionName` or a-direct function ARN when acquiring execution capacity. A READY provisioned+Lambda task invocation retains the alias or version from `FunctionName`, the+optimized integration's `Qualifier` parameter, or a direct function ARN when+acquiring execution capacity. Embedded and explicit qualifiers must agree.+A READY provisionedconcurrency pool for that qualifier can serve the task; resolving an alias toits version does not discard its pool identity. Unqualified invocation retainsthe normal on-demand path, and existing authorization checks still precedediff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.javaindex 124c3e648e..2ffa86d776 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutor.java@@ -1288,7 +1288,8 @@ public class AslExecutor {AwsArnUtils.Arn stateMachineArn = AwsArnUtils.parse(sm.getStateMachineArn());LambdaArnUtils.ResolvedFunctionRef ref;try {- ref = LambdaArnUtils.resolve(functionRef);+ ref = LambdaArnUtils.resolveWithQualifier(functionRef,+ optimizedLambdaInvoke ? input.path("Qualifier").asText(null) : null);} catch (AwsException e) {throw new FailStateException("Lambda." + e.getErrorCode(), e.getMessage());}@@ -1303,6 +1304,7 @@ public class AslExecutor {String region = ref.region() != null ? ref.region() : stateMachineArn.region();String accountId = ref.account() == null || ref.account().equals(stateMachineArn.accountId())? null : ref.account();+ String invokedQualifier = ref.qualifier();// The task invokes the function as its role: the execution role, or the role its// Credentials name once the execution role has assumed it. The role's policies or the// function's have to allow the call, and both when the function is in another account.@@ -1318,12 +1320,14 @@ public class AslExecutor {}String functionArn = LambdaArnUtils.functionArn(functionRef, stateMachineArn.partition(), region,stateMachineArn.accountId());+ if (invokedQualifier != null && extractLambdaQualifier(functionRef) == null) {+ functionArn += ":" + invokedQualifier;+ }Optional<String> refusal = lambdaTaskAuthorizer.refusal(invokingRoleArn, functionArn);if (refusal.isPresent()) {throw new FailStateException("Lambda.AccessDeniedException", refusal.get());}}- String invokedQualifier = extractLambdaQualifier(functionRef);LambdaFunction fn = resolveLambdaFunction(accountId, region, functionName, invokedQualifier);if (fn == null) {// A missing function is a task failure on AWS, so it must stay reachable fordiff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.javaindex cdfdbc12ac..2e82ade836 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaArnTargetTest.java@@ -18,6 +18,8 @@ import io.vertx.mutiny.core.Vertx;import jakarta.inject.Inject;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;import java.util.ArrayList;import java.util.List;@@ -31,6 +33,7 @@ import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.never;import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.verifyNoInteractions;import static org.mockito.Mockito.when;/**@@ -288,6 +291,43 @@ class AslExecutorLambdaArnTargetTest {verify(authorizer).assumeRefusal(ROLE_ARN, TASK_ROLE_ARN, STATE_MACHINE_ARN);}+ @ParameterizedTest+ @ValueSource(strings = {"worker", "111111111111:function:worker",+ "arn:aws:lambda:us-east-2:111111111111:function:worker"})+ void anExplicitQualifierIsAuthorizedBeforeResolvingOrInvoking(String reference) {+ LambdaTaskAuthorizer authorizer = enforcing();+ when(authorizer.refusal(anyString(), anyString())).thenReturn(Optional.of("refused"));++ Execution execution = run("""+ {"StartAt":"Call","States":{"Call":{"Type":"Task",+ "Resource":"arn:aws:states:::lambda:invoke",+ "Parameters":{"FunctionName":"%s","Qualifier":"live"},"End":true}}}+ """.formatted(reference));++ assertEquals("FAILED", execution.getStatus());+ assertEquals("Lambda.AccessDeniedException", execution.getError());+ String account = reference.equals(FUNCTION_NAME) ? ACCOUNT : OTHER_ACCOUNT;+ verify(authorizer).refusal(ROLE_ARN, functionArn(account, REGION) + ":live");+ verifyNoInteractions(functionStore, lambdaExecutor);+ }++ @Test+ void anExplicitQualifierDoesNotChangeFunctionNameValidation() {+ LambdaTaskAuthorizer authorizer = enforcing();+ when(authorizer.refusal(anyString(), anyString())).thenReturn(Optional.of("refused"));+ String qualifier = "q".repeat(128);++ Execution execution = run("""+ {"StartAt":"Call","States":{"Call":{"Type":"Task",+ "Resource":"arn:aws:states:::lambda:invoke",+ "Parameters":{"FunctionName":"%s","Qualifier":"%s"},"End":true}}}+ """.formatted(functionArn(ACCOUNT, REGION), qualifier));++ assertEquals("Lambda.AccessDeniedException", execution.getError());+ verify(authorizer).refusal(ROLE_ARN, functionArn(ACCOUNT, REGION) + ":" + qualifier);+ verifyNoInteractions(functionStore, lambdaExecutor);+ }+private LambdaTaskAuthorizer enforcing() {EmulatorConfig enforcing = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);when(enforcing.services().iam().enforcementEnabled()).thenReturn(true);diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.javaindex f33880f80d..ffdb2a223c 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/AslExecutorLambdaInvokeResultTest.java@@ -18,6 +18,9 @@ import io.vertx.mutiny.core.Vertx;import jakarta.inject.Inject;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;import java.util.ArrayList;import java.util.List;@@ -31,6 +34,7 @@ import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.verifyNoInteractions;import static org.mockito.Mockito.when;/**@@ -291,6 +295,58 @@ class AslExecutorLambdaInvokeResultTest {eq(InvocationType.RequestResponse), eq(0), eq("live"));}+ @ParameterizedTest+ @ValueSource(strings = {"echo-lambda", "000000000000:function:echo-lambda",+ "arn:aws:lambda:us-east-2:000000000000:function:echo-lambda"})+ void optimizedInvokeUsesAnExplicitAlias(String reference) throws Exception {+ stubVersion("2", "V2");+ LambdaAlias alias = new LambdaAlias();+ alias.setName("live");+ alias.setFunctionName(FUNCTION_NAME);+ alias.setFunctionVersion("2");+ when(aliasStore.get(REGION, FUNCTION_NAME, "live")).thenReturn(Optional.of(alias));++ Execution execution = run(optimizedInvocation(reference, "live"));++ assertEquals("SUCCEEDED", execution.getStatus());+ JsonNode output = objectMapper.readTree(execution.getOutput());+ assertEquals("V2", output.path("Payload").path("marker").asText());+ assertEquals("2", output.path("ExecutedVersion").asText());+ verify(lambdaExecutor).invoke(any(LambdaFunction.class), any(byte[].class),+ eq(InvocationType.RequestResponse), eq(0), eq("live"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"echo-lambda", "echo-lambda:2"})+ void optimizedInvokeUsesAnExplicitVersion(String reference) throws Exception {+ stubVersion("2", "V2");++ Execution execution = run(optimizedInvocation(reference, "2"));++ assertEquals("SUCCEEDED", execution.getStatus());+ assertEquals("V2", objectMapper.readTree(execution.getOutput()).path("Payload").path("marker").asText());+ verify(lambdaExecutor).invoke(any(LambdaFunction.class), any(byte[].class),+ eq(InvocationType.RequestResponse), eq(0), eq("2"));+ }++ @ParameterizedTest+ @CsvSource({"echo-lambda:1, 2", "echo-lambda, invalid.alias"})+ void optimizedInvokeRejectsAnInconsistentOrInvalidQualifier(String reference, String qualifier) {+ Execution execution = run(optimizedInvocation(reference, qualifier));++ assertEquals("FAILED", execution.getStatus());+ assertEquals("Lambda.InvalidParameterValueException", execution.getError());+ verifyNoInteractions(lambdaExecutor);+ }++ private static String optimizedInvocation(String reference, String qualifier) {+ return """+ {"StartAt":"Call","States":{"Call":{"Type":"Task",+ "Resource":"arn:aws:states:::lambda:invoke",+ "Parameters":{"FunctionName":"%s","Qualifier":"%s","Payload":{}},"End":true}}}+ """.formatted(reference, qualifier);+ }+private void stubVersion(String version, String marker) throws Exception {LambdaFunction function = new LambdaFunction();function.setFunctionName(FUNCTION_NAME);diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.javaindex 59ccfd0dd0..973a2e83e8 100644--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsLambdaTaskAuthorizationIntegrationTest.java@@ -145,6 +145,29 @@ class StepFunctionsLambdaTaskAuthorizationIntegrationTest {.body("error", equalTo("Lambda.AccessDeniedException"));}+ @Test+ void anExplicitAliasParameterUsesTheAliasGrantAndInvocationQualifier() {+ String roleArn = createRole("sfn-exec-" + suffix(), INVOKE_ANYTHING);+ String name = "worker-" + suffix();+ String functionArn = createFunction(FUNCTION_ACCOUNT, name);+ publishVersionAndAlias(name, "live");+ addPermission(functionArn, "live", Map.of("Principal", SFN_ACCOUNT));++ run(roleArn, "explicit-alias-" + suffix(), """+ {"StartAt":"Call","States":{"Call":{"Type":"Task",+ "Resource":"arn:aws:states:::lambda:invoke",+ "Parameters":{"FunctionName":"%s","Qualifier.$":"$.alias","Payload":{}},+ "End":true}}}""".formatted(functionArn), "{\"alias\":\"live\"}")+ .body("status", equalTo("SUCCEEDED"))+ .body("output", containsString("\"ExecutedVersion\":\"1\""));++ verify(executor).invoke(argThat(isFunction(functionArn + ":1")), any(), any(), eq(0), eq("live"));+ runTask(roleArn, functionArn)+ .body("status", equalTo("FAILED"))+ .body("error", equalTo("Lambda.AccessDeniedException"));+ verify(executor, never()).invoke(argThat(isFunction(functionArn)), any(), any());+ }+@Testvoid inItsOwnAccountTheRolesPermissionIsEnough() {String roleArn = createRole("sfn-exec-" + suffix(), INVOKE_ANYTHING);