Light, fluffy, and always free - The AWS Local Emulator alternative
fix(scheduler): validate replacement cleanup addresses (#5713)
XuJian0eee5ee28d89
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisioner.javaindex 620a1b9657..b5ac44a1b5 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisioner.java@@ -21,6 +21,7 @@ import org.jboss.logging.Logger;import java.time.Instant;import java.time.format.DateTimeParseException;+import java.util.HashMap;import java.util.Map;import java.util.Set;@@ -131,9 +132,13 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {// Ref is the name, but deletion needs both name and group. The cleanup helper's private// identity includes the group so a group move with an unchanged Ref is still tracked.+ String priorIdentity = null;+ if (ctx.isUpdate()) {+ priorIdentity = CfnResourceDispatcher.isStub(ctx.priorPhysicalId(), attributesBefore)+ ? ctx.priorPhysicalId() : address(priorGroup, ctx.priorPhysicalId());+ }ProvisionContext cleanupContext = new ProvisionContext(ctx.engine(), ctx.region(), ctx.accountId(),- ctx.stackName(), ctx.isUpdate() ? address(priorGroup, ctx.priorPhysicalId()) : null, ctx.progress(),- ctx.priorProperties());+ ctx.stackName(), priorIdentity, ctx.progress(), ctx.priorProperties());ReplacementCleanup.record(cleanupResource(resource), cleanupContext, attributesBefore);if (moveSnapshot != null) {moveSnapshot.put("destinationCreated", true);@@ -248,8 +253,11 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void delete(StackResource resource, String region) {- deleteAddress(address(resource.getAttributes().getOrDefault(GROUP_ATTR, "default"),- resource.getPhysicalId()), region);+ readCleanup(resource);+ if (!CfnResourceDispatcher.isStub(resource.getPhysicalId(), resource.getAttributes())) {+ deleteAddress(address(resource.getAttributes().getOrDefault(GROUP_ATTR, "default"),+ resource.getPhysicalId()), region);+ }UpdateCleanupResult result = ReplacementCleanup.complete(cleanupResource(resource),(type, id, cleanupRegion) -> deleteAddress(id, cleanupRegion));if (result.applicable() && !result.complete()) {@@ -259,6 +267,7 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {}private void deleteAddress(String physicalId, String region) {+ validateAddress(physicalId);int separator = physicalId.indexOf('/');String group = physicalId.substring(0, separator);String name = physicalId.substring(separator + 1);@@ -287,16 +296,19 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic boolean hasReplacementUpdate(StackResource resource) {+ readCleanup(resource);return ReplacementCleanup.hasReplacement(resource);}@Overridepublic String updateCleanupPhysicalId(StackResource resource) {+ readCleanup(resource);return ReplacementCleanup.cleanupPhysicalId(cleanupResource(resource));}@Overridepublic UpdateCleanupResult completeUpdate(StackResource resource) {+ readCleanup(resource);if ("UPDATE_FAILED".equals(resource.getStatus()) && retainsFailedUpdateState(resource)) {throw new IllegalStateException("Schedule rollback is still pending; its original configuration "+ "cannot be discarded by another resource's update cleanup");@@ -312,6 +324,7 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic UpdateCleanupResult completeDeleteCleanup(StackResource resource) {+ readCleanup(resource);UpdateCleanupResult result = ReplacementCleanup.complete(cleanupResource(resource),(type, id, region) -> deleteAddress(id, region));return result;@@ -319,6 +332,7 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void clearDeleteCleanup(StackResource resource) {+ readCleanup(resource);ReplacementCleanup.clear(resource);if (!ReplacementCleanup.hasReplacement(resource)) {resource.getAttributes().remove(NAME_REPLACEMENT_ATTR);@@ -327,6 +341,7 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void clearUpdate(StackResource resource) {+ readCleanup(resource);resource.getAttributes().remove(SNAPSHOT_ATTR);ReplacementCleanup.clear(resource);resource.getAttributes().remove(NAME_REPLACEMENT_ATTR);@@ -334,6 +349,7 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic void mergeFailedUpdateResourceTracking(StackResource previous, StackResource attempted) {+ readCleanup(previous);ObjectNode source = readCleanup(attempted);if (source != null) {String currentAddress = cleanupResource(previous).getPhysicalId();@@ -360,17 +376,100 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {if (!node.isObject() || (node.has("displaced") && !node.path("displaced").isArray())) {throw new IllegalStateException("Invalid schedule replacement cleanup");}+ String legacyStubAddress = null;+ String legacyStubId = null;+ if (node.has("priorPhysicalId") != node.has("priorAttributes")) {+ throw new IllegalStateException("Invalid schedule replacement cleanup");+ }+ if (node.has("priorPhysicalId")) {+ JsonNode priorId = node.path("priorPhysicalId");+ JsonNode priorAttributes = node.path("priorAttributes");+ if (!priorId.isTextual() || !priorAttributes.isObject()) {+ throw new IllegalStateException("Invalid schedule replacement cleanup");+ }+ Map<String, String> priorValues = new HashMap<>();+ priorAttributes.fields().forEachRemaining(entry -> {+ if (entry.getKey().startsWith("__Floci") || !entry.getValue().isTextual()) {+ throw new IllegalStateException("Invalid schedule replacement cleanup");+ }+ priorValues.put(entry.getKey(), entry.getValue().textValue());+ });+ String expectedStubArn = CfnResourceDispatcher.STUB_ARN_PREFIX + resource.getLogicalId();+ boolean priorStub = CfnResourceDispatcher.isStub(priorId.textValue(), priorValues)+ && expectedStubArn.equals(priorValues.get("Arn"));+ if (!priorStub && priorId.textValue().startsWith("default/")) {+ String candidate = priorId.textValue().substring("default/".length());+ if (CfnResourceDispatcher.isStub(candidate, priorValues)+ && expectedStubArn.equals(priorValues.get("Arn"))) {+ legacyStubAddress = priorId.textValue();+ legacyStubId = candidate;+ priorStub = true;+ }+ }+ if (!priorStub) {+ if (!isValidAddress(priorId.textValue())) {+ throw new IllegalStateException("Invalid schedule replacement cleanup");+ }+ String priorGroup = priorId.textValue().substring(0, priorId.textValue().indexOf('/'));+ JsonNode recordedGroup = priorAttributes.path(GROUP_ATTR);+ if (recordedGroup.isMissingNode() ? !"default".equals(priorGroup)+ : !recordedGroup.isTextual() || !priorGroup.equals(recordedGroup.textValue())) {+ throw new IllegalStateException("Invalid schedule replacement cleanup");+ }+ }+ }for (JsonNode entry : node.path("displaced")) {- if (!entry.isObject()) {+ JsonNode id = entry.path("physicalId");+ JsonNode type = entry.path("resourceType");+ JsonNode region = entry.path("region");+ JsonNode retainable = entry.path("retainable");+ JsonNode attempts = entry.path("cleanupAttempts");+ JsonNode failure = entry.path("cleanupFailureReason");+ boolean legacyStubEntry = id.isTextual() && id.textValue().equals(legacyStubAddress);+ if (!entry.isObject() || !id.isTextual()+ || (!legacyStubEntry && !isValidAddress(id.textValue()))+ || (!type.isMissingNode() && (!type.isTextual() || !TYPE.equals(type.textValue())))+ || (!region.isMissingNode() && !region.isNull() && !region.isTextual())+ || (!retainable.isMissingNode() && !retainable.isBoolean())+ || (!attempts.isMissingNode() && (!attempts.isIntegralNumber()+ || !attempts.canConvertToInt() || attempts.intValue() < 0))+ || (!failure.isMissingNode() && !failure.isNull() && !failure.isTextual())) {throw new IllegalStateException("Invalid schedule replacement cleanup");}}+ if (legacyStubAddress != null) {+ ((ObjectNode) node).put("priorPhysicalId", legacyStubId);+ ArrayNode remaining = MAPPER.createArrayNode();+ for (JsonNode entry : node.path("displaced")) {+ if (!legacyStubAddress.equals(entry.path("physicalId").asText())) {+ remaining.add(entry);+ }+ }+ ((ObjectNode) node).set("displaced", remaining);+ resource.getAttributes().put(CfnRollback.REPLACEMENT_CLEANUP_ATTR, node.toString());+ }return (ObjectNode) node;} catch (JsonProcessingException e) {throw new IllegalStateException("Could not read schedule replacement cleanup", e);}}+ private static void validateAddress(String physicalId) {+ if (!isValidAddress(physicalId)) {+ throw new IllegalStateException("Invalid schedule address");+ }+ }++ private static boolean isValidAddress(String physicalId) {+ if (physicalId == null) {+ return false;+ }+ int separator = physicalId.indexOf('/');+ return separator > 0+ && SchedulerService.isValidName(physicalId.substring(0, separator))+ && SchedulerService.isValidName(physicalId.substring(separator + 1));+ }+private static void retireDisplaced(StackResource resource, String physicalId) {ObjectNode cleanup = readCleanup(resource);if (cleanup == null) {@@ -392,6 +491,7 @@ public class SchedulerScheduleCfnProvisioner implements CfnResourceProvisioner {@Overridepublic boolean rollbackUpdate(StackResource resource) {+ readCleanup(resource);JsonNode snapshot = readSnapshot(resource);if (snapshot != null && snapshot.path("destinationCreated").asBoolean(false)) {// Disable the move's destination before restoring an enabled original, even if deletingdiff --git a/src/main/java/io/github/hectorvent/floci/services/scheduler/SchedulerService.java b/src/main/java/io/github/hectorvent/floci/services/scheduler/SchedulerService.javaindex 055dfd2272..cdcc0a9c9b 100644--- a/src/main/java/io/github/hectorvent/floci/services/scheduler/SchedulerService.java+++ b/src/main/java/io/github/hectorvent/floci/services/scheduler/SchedulerService.java@@ -325,11 +325,15 @@ public class SchedulerService {// ──────────────────────────── Helpers ────────────────────────────+ public static boolean isValidName(String name) {+ return name != null && NAME_PATTERN.matcher(name).matches();+ }+private void validateName(String name) {if (name == null || name.isBlank()) {throw new AwsException("ValidationException", "Name is required.", 400);}- if (!NAME_PATTERN.matcher(name).matches()) {+ if (!isValidName(name)) {throw new AwsException("ValidationException","Name must match pattern [0-9a-zA-Z-_.]{1,64}: " + name, 400);}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisionerTest.javaindex 4e89e3da62..d94f7b296d 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SchedulerScheduleCfnProvisionerTest.java@@ -342,7 +342,10 @@ class SchedulerScheduleCfnProvisionerTest {}@ParameterizedTest- @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]"})+ @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]",+ "{\"physicalId\":\"/victim\"}", "{\"physicalId\":\"default/\"}",+ "{\"physicalId\":\"default/victim/extra\"}", "{\"physicalId\":123}",+ "{\"physicalId\":\"default/victim\",\"cleanupAttempts\":\"zero\"}"})void malformedCleanupEntryRejectsCreateBeforeAnyServiceCall(String entry) throws Exception {StackResource resource = resource();appendMalformedCleanupEntry(resource, entry);@@ -351,7 +354,10 @@ class SchedulerScheduleCfnProvisionerTest {}@ParameterizedTest- @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]"})+ @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]",+ "{\"physicalId\":\"/victim\"}", "{\"physicalId\":\"default/\"}",+ "{\"physicalId\":\"default/victim/extra\"}", "{\"physicalId\":123}",+ "{\"physicalId\":\"default/victim\",\"cleanupAttempts\":\"zero\"}"})void malformedCleanupEntryRejectsReplacementBeforeAnyServiceCall(String entry) throws Exception {StackResource resource = resource();provisioner.provision(resource, properties("current", "default"), context(null));@@ -361,7 +367,10 @@ class SchedulerScheduleCfnProvisionerTest {}@ParameterizedTest- @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]"})+ @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]",+ "{\"physicalId\":\"/victim\"}", "{\"physicalId\":\"default/\"}",+ "{\"physicalId\":\"default/victim/extra\"}", "{\"physicalId\":123}",+ "{\"physicalId\":\"default/victim\",\"cleanupAttempts\":\"zero\"}"})void malformedCleanupEntryRejectsInPlaceUpdateBeforeAnyServiceCall(String entry) throws Exception {StackResource resource = resource();provisioner.provision(resource, properties("current", "default"), context(null));@@ -372,7 +381,10 @@ class SchedulerScheduleCfnProvisionerTest {}@ParameterizedTest- @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]"})+ @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]",+ "{\"physicalId\":\"/victim\"}", "{\"physicalId\":\"default/\"}",+ "{\"physicalId\":\"default/victim/extra\"}", "{\"physicalId\":123}",+ "{\"physicalId\":\"default/victim\",\"cleanupAttempts\":\"zero\"}"})void malformedCleanupEntryPreservesPendingRollbackBeforeAnotherUpdate(String entry) throws Exception {StackResource resource = resource();provisioner.provision(resource, properties("current", "default"), context(null));@@ -387,7 +399,10 @@ class SchedulerScheduleCfnProvisionerTest {}@ParameterizedTest- @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]"})+ @ValueSource(strings = {"1", "true", "null", "\"invalid\"", "[]",+ "{\"physicalId\":\"/victim\"}", "{\"physicalId\":\"default/\"}",+ "{\"physicalId\":\"default/victim/extra\"}", "{\"physicalId\":123}",+ "{\"physicalId\":\"default/victim\",\"cleanupAttempts\":\"zero\"}"})void malformedCleanupEntryRejectsMergeWithoutChangingExistingDebt(String entry) throws Exception {StackResource previous = resource();provisioner.provision(previous, properties("current", "default"), context(null));@@ -431,6 +446,166 @@ class SchedulerScheduleCfnProvisionerTest {() -> verifyNoInteractions(scheduler));}+ @Test+ void malformedCleanupAddressCannotDeleteAnotherSchedule() throws Exception {+ StackResource resource = resource();+ provisioner.provision(resource, properties("current", "default"), context(null));+ appendMalformedCleanupEntry(resource, "{\"physicalId\":\"/victim\"}");+ Map<String, String> before = Map.copyOf(resource.getAttributes());+ clearInvocations(scheduler);++ assertAll(+ () -> assertThrows(IllegalStateException.class,+ () -> provisioner.completeDeleteCleanup(resource)),+ () -> assertThrows(IllegalStateException.class,+ () -> provisioner.delete(resource, REGION)),+ () -> assertThrows(IllegalStateException.class,+ () -> provisioner.completeUpdate(resource)),+ () -> assertEquals(before, resource.getAttributes()),+ () -> verifyNoInteractions(scheduler));+ }++ @ParameterizedTest+ @ValueSource(strings = {+ "{\"priorPhysicalId\":\"/victim\",\"priorAttributes\":{}}",+ "{\"priorPhysicalId\":\"a/victim\",\"priorAttributes\":{\"FlociSchedulerGroupName\":\"default\"}}",+ "{\"priorPhysicalId\":\"a/victim\",\"priorAttributes\":{}}",+ "{\"priorPhysicalId\":\"default/victim\",\"priorAttributes\":{\"FlociSchedulerGroupName\":\"a\"}}",+ "{\"priorPhysicalId\":\"default/victim\",\"priorAttributes\":{\"FlociSchedulerGroupName\":42}}",+ "{\"priorPhysicalId\":\"default/victim\",\"priorAttributes\":[]}",+ "{\"priorPhysicalId\":\"default/victim\",\"priorAttributes\":{\"Arn\":42}}",+ "{\"priorPhysicalId\":\"default/victim\",\"priorAttributes\":{\"__FlociReplacementCleanup\":\"x\"}}",+ "{\"priorPhysicalId\":\"default/victim\"}",+ "{\"priorAttributes\":{}}",+ "{\"priorPhysicalId\":42,\"priorAttributes\":{}}"})+ void malformedPriorCleanupRejectsEveryMutationEntryPoint(String cleanup) throws Exception {+ StackResource resource = resource();+ provisioner.provision(resource, properties("current", "default"), context(null));+ resource.getAttributes().put("__FlociReplacementCleanup", cleanup);+ Map<String, String> before = Map.copyOf(resource.getAttributes());+ String physicalIdBefore = resource.getPhysicalId();+ clearInvocations(scheduler);++ assertAll(+ () -> assertThrows(IllegalStateException.class, () -> provisioner.provision(resource,+ properties("new", "default"), context("current"))),+ () -> assertThrows(IllegalStateException.class, () -> provisioner.rollbackUpdate(resource)),+ () -> assertThrows(IllegalStateException.class, () -> provisioner.delete(resource, REGION)),+ () -> assertThrows(IllegalStateException.class, () -> provisioner.completeUpdate(resource)),+ () -> assertThrows(IllegalStateException.class, () -> provisioner.completeDeleteCleanup(resource)),+ () -> assertEquals(physicalIdBefore, resource.getPhysicalId()),+ () -> assertEquals(before, resource.getAttributes()),+ () -> verifyNoInteractions(scheduler));+ }++ @Test+ void priorDefaultGroupCanBeOmittedFromStoredCleanup() throws Exception {+ StackResource resource = resource();+ provisioner.provision(resource, properties("old", "default"), context(null));+ provisioner.provision(resource, properties("new", "default"), context("old"));+ ObjectNode cleanup = (ObjectNode) mapper.readTree(resource.getAttributes().get("__FlociReplacementCleanup"));+ ((ObjectNode) cleanup.path("priorAttributes")).remove("FlociSchedulerGroupName");+ resource.getAttributes().put("__FlociReplacementCleanup", cleanup.toString());++ assertTrue(provisioner.rollbackUpdate(resource));++ assertEquals("old", resource.getPhysicalId());+ verify(scheduler).deleteSchedule("new", "default", REGION);+ }++ @ParameterizedTest+ @ValueSource(ints = {5, 56})+ void stubMigrationDoesNotScheduleTheStubForDeletion(int logicalIdLength) throws Exception {+ StackResource resource = stubResource(logicalIdLength);+ String stubId = resource.getPhysicalId();++ provisioner.provision(resource, properties("new", "default"), context(stubId));++ assertFalse(provisioner.hasReplacementUpdate(resource));+ assertNull(provisioner.updateCleanupPhysicalId(resource));+ assertTrue(provisioner.completeUpdate(resource).complete());+ verify(scheduler, never()).deleteSchedule(any(), any(), eq(REGION));+ }++ @ParameterizedTest+ @ValueSource(ints = {5, 56})+ void stubMigrationRollbackRestoresTheStubWithoutDeletingIt(int logicalIdLength) throws Exception {+ StackResource resource = stubResource(logicalIdLength);+ String stubId = resource.getPhysicalId();+ String stubArn = resource.getAttributes().get("Arn");+ provisioner.provision(resource, properties("new", "default"), context(stubId));++ assertTrue(provisioner.rollbackUpdate(resource));+ assertEquals(stubId, resource.getPhysicalId());+ assertEquals(stubArn, resource.getAttributes().get("Arn"));+ verify(scheduler).deleteSchedule("new", "default", REGION);++ clearInvocations(scheduler);+ provisioner.delete(resource, REGION);+ verifyNoInteractions(scheduler);+ }++ @ParameterizedTest+ @ValueSource(ints = {5, 56})+ void persistedStubMigrationDoesNotDeleteAnUnownedSchedule(int logicalIdLength) throws Exception {+ StackResource resource = stubResource(logicalIdLength);+ String stubId = resource.getPhysicalId();+ provisioner.provision(resource, properties("new", "default"), context(stubId));+ restoreLegacyStubCleanup(resource, stubId);+ clearInvocations(scheduler);++ assertFalse(provisioner.hasReplacementUpdate(resource));+ assertTrue(provisioner.completeUpdate(resource).complete());+ verifyNoInteractions(scheduler);+ }++ @ParameterizedTest+ @ValueSource(ints = {5, 56})+ void persistedStubMigrationCanRollbackWithoutDeletingTheStub(int logicalIdLength) throws Exception {+ StackResource resource = stubResource(logicalIdLength);+ String stubId = resource.getPhysicalId();+ provisioner.provision(resource, properties("new", "default"), context(stubId));+ restoreLegacyStubCleanup(resource, stubId);+ clearInvocations(scheduler);++ assertTrue(provisioner.rollbackUpdate(resource));+ assertEquals(stubId, resource.getPhysicalId());+ verify(scheduler).deleteSchedule("new", "default", REGION);+ clearInvocations(scheduler);+ provisioner.delete(resource, REGION);+ verifyNoInteractions(scheduler);+ }++ @Test+ void malformedPersistedStubCleanupIsNotPartiallyRewritten() throws Exception {+ StackResource resource = stubResource(5);+ String stubId = resource.getPhysicalId();+ provisioner.provision(resource, properties("new", "default"), context(stubId));+ restoreLegacyStubCleanup(resource, stubId);+ ObjectNode cleanup = (ObjectNode) mapper.readTree(resource.getAttributes().get("__FlociReplacementCleanup"));+ cleanup.withArray("displaced").addObject().put("physicalId", "/victim");+ resource.getAttributes().put("__FlociReplacementCleanup", cleanup.toString());+ Map<String, String> before = Map.copyOf(resource.getAttributes());+ clearInvocations(scheduler);++ assertThrows(IllegalStateException.class, () -> provisioner.completeUpdate(resource));+ assertEquals(before, resource.getAttributes());+ verifyNoInteractions(scheduler);+ }++ private void restoreLegacyStubCleanup(StackResource resource, String stubId) throws Exception {+ ObjectNode cleanup = (ObjectNode) mapper.readTree(resource.getAttributes().get("__FlociReplacementCleanup"));+ String oldAddress = "default/" + stubId;+ cleanup.put("priorPhysicalId", oldAddress);+ cleanup.withArray("displaced").addObject()+ .put("physicalId", oldAddress)+ .put("resourceType", "AWS::Scheduler::Schedule")+ .put("region", REGION)+ .put("retainable", true)+ .put("cleanupAttempts", 0);+ resource.getAttributes().put("__FlociReplacementCleanup", cleanup.toString());+ }+@Testvoid groupMoveKeepsRefAndDoesNotHonorReplacementRetain() throws Exception {StackResource resource = resource();@@ -1028,6 +1203,15 @@ class SchedulerScheduleCfnProvisionerTest {return resource;}+ private static StackResource stubResource(int logicalIdLength) {+ StackResource resource = resource();+ String logicalId = "S".repeat(logicalIdLength);+ resource.setLogicalId(logicalId);+ resource.setPhysicalId(logicalId + "-01234567");+ resource.getAttributes().put("Arn", CfnResourceDispatcher.STUB_ARN_PREFIX + logicalId);+ return resource;+ }+private static ScheduleRequest request(String name, String group, String expression) {ScheduleRequest request = new ScheduleRequest();request.setName(name);