Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

test(core): compare every Query handler's dispatched actions with its routing (#5279)

Priamo Germosenf5d48bb5e029
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java
new file mode 100644
index 0000000000..733ece29c4
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java
@@ -0,0 +1,362 @@
+package io.github.hectorvent.floci.core.common;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Guards the rule that an action a Query handler dispatches is an action routing sends to that
+ * handler. The two lists are maintained by hand in different files, so they drift: #5032 was 28
+ * IAM operations that had drifted out, and the same gap exists today for most other Query
+ * services, which is what this test makes visible and stops growing.
+ *
+ * <p>Routing only decides anything when a request arrives without a usable credential scope,
+ * because otherwise the service comes from the SigV4 scope. On that path the action name is all
+ * there is, and {@code inferServiceFromAction}'s chain ends in {@code return "sqs"}, so a missing
+ * name answers {@code UnsupportedOperation} in the SQS namespace rather than failing visibly.
+ * {@code AwsQueryServiceResolver} backs {@code IamEnforcementFilter} through the same code, so the
+ * same operation is also authorized under the wrong namespace, which is the part worth a test.
+ *
+ * <p>The known gaps live in {@code src/test/resources/query-routing-known-gaps.tsv} rather than
+ * here, so that fixing one is a line removed from a data file. The list is checked both ways: a new
+ * gap fails {@link #everyDispatchedActionRoutesToItsOwnService}, and a gap that has been fixed
+ * without delisting fails {@link #theKnownGapListHasNoStaleEntries}.
+ */
+class AwsQueryActionRoutingParityTest {
+
+ /** The handler whose dispatch switch defines what a service accepts, and the service it is. */
+ private record QueryHandler(String service, Path source, String switchVariable) {
+
+ private QueryHandler(String service, String path) {
+ this(service, Path.of(path), "action");
+ }
+ }
+
+ private static final String HANDLERS_ROOT = "src/main/java/io/github/hectorvent/floci/services/";
+
+ /**
+ * Every Query handler in the tree, with the service its actions must reach.
+ *
+ * <p>Several entries share a service on purpose. DocDB and Neptune speak the RDS wire shape and
+ * their action names are indistinguishable from RDS's, so by name they can only resolve to
+ * {@code rds}. ELB Classic and ELBv2 both serve {@code elasticloadbalancing}, which is why
+ * their sets are checked as one and why {@code isElbClassicRequest} exists to split them on
+ * {@code Version} afterwards.
+ *
+ * <p>SQS is listed even though it is the fallback the chain ends in, because being the default
+ * does not make it safe: a name an earlier service claims never reaches it.
+ */
+ private static final List<QueryHandler> HANDLERS = List.of(
+ // StsQueryHandler sits in the iam package, beside IamQueryHandler.
+ new QueryHandler("sts", HANDLERS_ROOT + "iam/StsQueryHandler.java"),
+ new QueryHandler("iam", HANDLERS_ROOT + "iam/IamQueryHandler.java"),
+ new QueryHandler("sns", HANDLERS_ROOT + "sns/SnsQueryHandler.java"),
+ new QueryHandler("elasticache", HANDLERS_ROOT + "elasticache/ElastiCacheQueryHandler.java"),
+ new QueryHandler("rds", HANDLERS_ROOT + "rds/RdsQueryHandler.java"),
+ new QueryHandler("rds", HANDLERS_ROOT + "docdb/DocDbQueryHandler.java"),
+ new QueryHandler("rds", HANDLERS_ROOT + "neptune/NeptuneQueryHandler.java"),
+ // CloudWatch normalises the action before dispatching, so its switch reads a different
+ // variable. Named here rather than guessed at by the parser.
+ new QueryHandler("monitoring",
+ Path.of(HANDLERS_ROOT + "cloudwatch/metrics/CloudWatchMetricsQueryHandler.java"),
+ "normalizedAction"),
+ new QueryHandler("cloudformation",
+ HANDLERS_ROOT + "cloudformation/CloudFormationQueryHandler.java"),
+ new QueryHandler("email", HANDLERS_ROOT + "ses/SesQueryHandler.java"),
+ new QueryHandler("ec2", HANDLERS_ROOT + "ec2/Ec2QueryHandler.java"),
+ new QueryHandler("elasticloadbalancing", HANDLERS_ROOT + "elbv2/ElbV2QueryHandler.java"),
+ new QueryHandler("elasticloadbalancing", HANDLERS_ROOT + "elb/ElbClassicQueryHandler.java"),
+ new QueryHandler("autoscaling", HANDLERS_ROOT + "autoscaling/AutoScalingQueryHandler.java"),
+ new QueryHandler("elasticbeanstalk",
+ HANDLERS_ROOT + "elasticbeanstalk/ElasticBeanstalkQueryHandler.java"),
+ new QueryHandler("redshift", HANDLERS_ROOT + "redshift/RedshiftQueryHandler.java"),
+ new QueryHandler("sqs", HANDLERS_ROOT + "sqs/SqsQueryHandler.java"));
+
+ private static final Path KNOWN_GAPS = Path.of("src/test/resources/query-routing-known-gaps.tsv");
+
+ /**
+ * A {@code case} arm's label list, which may carry several names and may wrap across lines.
+ * Only quoted labels are taken, so a {@code case} on an enum constant contributes nothing.
+ */
+ private static final Pattern CASE_LABELS =
+ Pattern.compile("case\\s+((?:\"[A-Za-z0-9]+\"\\s*,?\\s*)+)\\s*(?:->|:)");
+ private static final Pattern QUOTED_LABEL = Pattern.compile("\"([A-Za-z0-9]+)\"");
+
+ @Test
+ void everyDispatchedActionRoutesToItsOwnService() throws IOException {
+ Set<String> known = knownGaps();
+ List<String> unexpected = new ArrayList<>();
+
+ for (QueryHandler handler : HANDLERS) {
+ for (String action : dispatchedActions(handler)) {
+ String reached = AwsQueryController.inferServiceFromAction(action);
+ if (!handler.service().equals(reached)
+ && !known.contains(gapKey(handler.service(), action, reached))) {
+ unexpected.add(handler.service() + " dispatches " + action
+ + " but the name reaches " + reached);
+ }
+ }
+ }
+
+ assertTrue(unexpected.isEmpty(),
+ "An action a handler dispatches has to route to that handler, or a request without "
+ + "a credential scope answers in the wrong namespace and is authorized "
+ + "under it too. Add the name to its service's set in AwsQueryController, "
+ + "having checked that no service earlier in inferServiceFromAction's "
+ + "chain already claims it. If an earlier service does claim it, the name "
+ + "needs the Version discriminator instead, and belongs in " + KNOWN_GAPS
+ + " with that noted. New: " + unexpected);
+ }
+
+ /**
+ * The other direction, which is what keeps the list honest: once a gap is fixed its line has to
+ * go, or the file slowly stops describing the tree and a later regression hides behind a stale
+ * entry.
+ */
+ @Test
+ void theKnownGapListHasNoStaleEntries() throws IOException {
+ Set<String> live = new LinkedHashSet<>();
+ for (QueryHandler handler : HANDLERS) {
+ for (String action : dispatchedActions(handler)) {
+ String reached = AwsQueryController.inferServiceFromAction(action);
+ if (!handler.service().equals(reached)) {
+ live.add(gapKey(handler.service(), action, reached));
+ }
+ }
+ }
+
+ List<String> stale = new ArrayList<>(knownGaps());
+ stale.removeAll(live);
+
+ assertTrue(stale.isEmpty(),
+ "These are listed as known routing gaps but route correctly now, so the lines "
+ + "should come out of " + KNOWN_GAPS + ": " + stale);
+ }
+
+ /**
+ * A new Query service must be checked too. Without this a handler added next to the others is
+ * simply not looked at, which is the shape of the drift this test exists to stop.
+ */
+ @Test
+ void everyQueryHandlerInTheTreeIsRegistered() throws IOException {
+ Set<Path> registered = new TreeSet<>();
+ for (QueryHandler handler : HANDLERS) {
+ registered.add(handler.source().normalize());
+ }
+
+ List<String> unregistered = new ArrayList<>();
+ try (Stream<Path> tree = Files.walk(Path.of(HANDLERS_ROOT))) {
+ tree.filter(path -> path.getFileName().toString().endsWith("QueryHandler.java"))
+ .map(Path::normalize)
+ .filter(path -> !registered.contains(path))
+ .forEach(path -> unregistered.add(path.toString()));
+ }
+
+ assertTrue(unregistered.isEmpty(),
+ "Every *QueryHandler.java has to be registered in this test with the service its "
+ + "actions must reach, so its dispatch list is compared against routing. "
+ + "Unregistered: " + unregistered);
+ }
+
+ /** One line of the known-gap file: the service, the action, and what it reaches instead. */
+ private static String gapKey(String service, String action, String reached) {
+ return service + "\t" + action + "\t" + reached;
+ }
+
+ private static Set<String> knownGaps() throws IOException {
+ Set<String> gaps = new LinkedHashSet<>();
+ for (String line : Files.readAllLines(KNOWN_GAPS)) {
+ String trimmed = line.strip();
+ if (trimmed.isEmpty() || trimmed.startsWith("#")) {
+ continue;
+ }
+ gaps.add(trimmed);
+ }
+ return gaps;
+ }
+
+ /**
+ * The action names a handler dispatches, read from its own dispatch switch and nothing else.
+ *
+ * <p>Bounded to that one switch on purpose. A handler holds other switches on other strings,
+ * for parameter names and for state values, and taking every {@code case} in the file picks
+ * those up as actions: the docs generator does exactly that and carries per-service exclusions
+ * to undo it.
+ */
+ private static Set<String> dispatchedActions(QueryHandler handler) throws IOException {
+ return dispatchedActions(Files.readString(handler.source()), handler.switchVariable(),
+ handler.source().toString());
+ }
+
+ /**
+ * The same, over source held as a string, so the parser can be tested on its own.
+ *
+ * <p>Brace counting runs over a masked copy rather than the source, because a {@code }} inside
+ * a comment or a string literal would otherwise close the switch early and silently shorten the
+ * action list. That is the worst way for this test to fail: a handler with no listed gaps would
+ * keep passing both checks while no longer checking anything. Masking comments also means a
+ * commented-out {@code case} arm does not count as an action.
+ */
+ private static Set<String> dispatchedActions(String source, String switchVariable, String where) {
+ String masked = maskCommentsAndBracesInLiterals(source);
+ Matcher dispatch = Pattern.compile("switch\\s*\\(\\s*" + switchVariable + "\\s*\\)")
+ .matcher(masked);
+ assertTrue(dispatch.find(),
+ where + " has no switch (" + switchVariable + "), so this test cannot tell what it "
+ + "dispatches. Point the registry at the right variable.");
+
+ int open = masked.indexOf('{', dispatch.end());
+ assertTrue(open >= 0, "no dispatch switch body in " + where);
+ int close = -1;
+ int depth = 0;
+ for (int i = open; i < masked.length(); i++) {
+ char character = masked.charAt(i);
+ if (character == '{') {
+ depth++;
+ } else if (character == '}') {
+ depth--;
+ if (depth == 0) {
+ close = i;
+ break;
+ }
+ }
+ }
+ assertTrue(close > open, "unbalanced dispatch switch in " + where);
+
+ Set<String> actions = new TreeSet<>();
+ Matcher arm = CASE_LABELS.matcher(masked.substring(open, close));
+ while (arm.find()) {
+ Matcher label = QUOTED_LABEL.matcher(arm.group(1));
+ while (label.find()) {
+ actions.add(label.group(1));
+ }
+ }
+ return actions;
+ }
+
+ /**
+ * A copy of the source with comments blanked and braces inside string and character literals
+ * replaced by spaces. The copy is the same length as the input, so offsets still line up, and
+ * literal contents survive apart from braces, so {@code case "Name"} still reads.
+ */
+ private static String maskCommentsAndBracesInLiterals(String source) {
+ StringBuilder masked = new StringBuilder(source);
+ int i = 0;
+ while (i < source.length()) {
+ char character = source.charAt(i);
+ if (character == '/' && i + 1 < source.length() && source.charAt(i + 1) == '/') {
+ while (i < source.length() && source.charAt(i) != '\n') {
+ masked.setCharAt(i, ' ');
+ i++;
+ }
+ } else if (character == '/' && i + 1 < source.length() && source.charAt(i + 1) == '*') {
+ int end = source.indexOf("*/", i + 2);
+ int stop = end < 0 ? source.length() : end + 2;
+ while (i < stop) {
+ if (source.charAt(i) != '\n') {
+ masked.setCharAt(i, ' ');
+ }
+ i++;
+ }
+ } else if (character == '"' || character == '\'') {
+ i = maskLiteral(source, masked, i, character);
+ } else {
+ i++;
+ }
+ }
+ return masked.toString();
+ }
+
+ /** Blanks the braces inside one literal and returns the index just past its closing quote. */
+ private static int maskLiteral(String source, StringBuilder masked, int start, char quote) {
+ int i = start + 1;
+ while (i < source.length()) {
+ char character = source.charAt(i);
+ if (character == '\\') {
+ i += 2;
+ continue;
+ }
+ if (character == quote) {
+ return i + 1;
+ }
+ if (character == '{' || character == '}') {
+ masked.setCharAt(i, ' ');
+ }
+ i++;
+ }
+ return i;
+ }
+
+ // Parser tests. The three assertions above are only as good as what this reads out of a
+ // handler, and a brace it miscounts costs coverage without failing anything.
+
+ private static final String SWITCH_TEMPLATE = """
+ class Handler {
+ Response handle(String action) {
+ return switch (action) {
+ case "First" -> first();
+ %s
+ case "Last" -> last();
+ default -> unsupported();
+ };
+ }
+ }
+ """;
+
+ @Test
+ void aBraceInALineCommentDoesNotEndTheSwitch() {
+ Set<String> actions = dispatchedActions(
+ SWITCH_TEMPLATE.formatted(" // closing } in a comment"),
+ "action", "<line comment>");
+ assertTrue(actions.contains("Last"),
+ "a } inside a line comment closed the switch early, so later arms were lost: "
+ + actions);
+ }
+
+ @Test
+ void aBraceInABlockCommentDoesNotEndTheSwitch() {
+ Set<String> actions = dispatchedActions(
+ SWITCH_TEMPLATE.formatted(" /* closing } in a block } comment */"),
+ "action", "<block comment>");
+ assertTrue(actions.contains("Last"),
+ "a } inside a block comment closed the switch early: " + actions);
+ }
+
+ @Test
+ void aBraceInsideALiteralDoesNotEndTheSwitch() {
+ Set<String> actions = dispatchedActions(
+ SWITCH_TEMPLATE.formatted(" case \"Brace\" -> literal(\"}\", '}');"),
+ "action", "<literal>");
+ assertTrue(actions.containsAll(Set.of("Brace", "Last")),
+ "a } inside a string or character literal closed the switch early: " + actions);
+ }
+
+ @Test
+ void aCommentedOutArmIsNotAnAction() {
+ Set<String> actions = dispatchedActions(
+ SWITCH_TEMPLATE.formatted(" // case \"Ghost\" -> ghost();"),
+ "action", "<commented arm>");
+ assertTrue(!actions.contains("Ghost"),
+ "a commented-out case arm was read as a dispatched action: " + actions);
+ }
+
+ @Test
+ void theTemplateItselfParsesAsExpected() {
+ Set<String> actions = dispatchedActions(SWITCH_TEMPLATE.formatted(""), "action",
+ "<template>");
+ assertTrue(actions.equals(Set.of("First", "Last")),
+ "the parser test template should yield exactly its two arms, got " + actions);
+ }
+}
diff --git a/src/test/resources/query-routing-known-gaps.tsv b/src/test/resources/query-routing-known-gaps.tsv
new file mode 100644
index 0000000000..dff27f0df2
--- /dev/null
+++ b/src/test/resources/query-routing-known-gaps.tsv
@@ -0,0 +1,234 @@
+# Query actions that a handler dispatches but routing does not send to that handler.
+#
+# Columns: service, action, service it reaches instead.
+#
+# Routing only matters when a request arrives without a usable credential scope, since
+# otherwise the service comes from the SigV4 scope. On that path the action name is all
+# there is, and AwsQueryServiceResolver backs IamEnforcementFilter too, so an entry here
+# is also authorized under the wrong namespace.
+#
+# Two kinds of entry, told apart by the third column:
+#
+# -> sqs The name is in no routing set, so it falls through to the sqs default.
+# Fixable by adding the name to its service's set, as #5032 did for IAM,
+# once checked that no service earlier in the chain claims it.
+#
+# -> other A service earlier in inferServiceFromAction's chain already owns the
+# name, so adding it to the right set changes nothing. These need the
+# Version form field to disambiguate, the way isElbClassicRequest already
+# reads it, which is a cross-service routing change of its own.
+#
+# 189 entries: 171 unrouted, 18 claimed by another service.
+#
+# Shrink this file, never grow it. Removing a line is the point; adding one needs a
+# reason in the PR that adds it. AwsQueryActionRoutingParityTest fails on an entry that
+# is no longer a gap, so a fix cannot leave the list stale.
+
+# autoscaling: 17 (13 unrouted, 4 claimed elsewhere)
+autoscaling AttachTrafficSources sqs
+autoscaling DeletePolicy iam
+autoscaling DeleteScheduledAction sqs
+autoscaling DeleteTags ec2
+autoscaling DeleteWarmPool sqs
+autoscaling DescribeAccountLimits elasticloadbalancing
+autoscaling DescribeLoadBalancers elasticloadbalancing
+autoscaling DescribeScheduledActions sqs
+autoscaling DescribeTrafficSources sqs
+autoscaling DescribeWarmPool sqs
+autoscaling DetachTrafficSources sqs
+autoscaling PutScheduledUpdateGroupAction sqs
+autoscaling PutWarmPool sqs
+autoscaling ResumeProcesses sqs
+autoscaling SetInstanceHealth sqs
+autoscaling SetInstanceProtection sqs
+autoscaling SuspendProcesses sqs
+
+# cloudformation: 3 (3 unrouted, 0 claimed elsewhere)
+cloudformation ActivateOrganizationsAccess sqs
+cloudformation DescribeOrganizationsAccess sqs
+cloudformation ListStackSetAutoDeploymentTargets sqs
+
+# ec2: 83 (83 unrouted, 0 claimed elsewhere)
+ec2 AcceptVpcPeeringConnection sqs
+ec2 AllocateHosts sqs
+ec2 AllocateIpamPoolCidr sqs
+ec2 AssociateIamInstanceProfile sqs
+ec2 AssociateIpamByoasn sqs
+ec2 AssociateTransitGatewayRouteTable sqs
+ec2 AttachNetworkInterface sqs
+ec2 CancelSpotInstanceRequests sqs
+ec2 CreateIpam sqs
+ec2 CreateIpamPool sqs
+ec2 CreateManagedPrefixList sqs
+ec2 CreateNetworkInterface sqs
+ec2 CreateTransitGateway sqs
+ec2 CreateTransitGatewayRoute sqs
+ec2 CreateTransitGatewayRouteTable sqs
+ec2 CreateTransitGatewayVpcAttachment sqs
+ec2 CreateVpcPeeringConnection sqs
+ec2 DeleteIpam sqs
+ec2 DeleteIpamPool sqs
+ec2 DeleteManagedPrefixList sqs
+ec2 DeleteNetworkInterface sqs
+ec2 DeleteTransitGateway sqs
+ec2 DeleteTransitGatewayRoute sqs
+ec2 DeleteTransitGatewayRouteTable sqs
+ec2 DeleteTransitGatewayVpcAttachment sqs
+ec2 DeleteVpcPeeringConnection sqs
+ec2 DescribeEgressOnlyInternetGateways sqs
+ec2 DescribeHosts sqs
+ec2 DescribeInstanceCreditSpecifications sqs
+ec2 DescribeIpamByoasn sqs
+ec2 DescribeIpamPools sqs
+ec2 DescribeIpamScopes sqs
+ec2 DescribeIpams sqs
+ec2 DescribeManagedPrefixLists sqs
+ec2 DescribeSpotInstanceRequests sqs
+ec2 DescribeTransitGatewayAttachments sqs
+ec2 DescribeTransitGatewayConnects sqs
+ec2 DescribeTransitGatewayRouteTables sqs
+ec2 DescribeTransitGatewayVpcAttachments sqs
+ec2 DescribeTransitGateways sqs
+ec2 DescribeVolumesModifications sqs
+ec2 DescribeVpcPeeringConnections sqs
+ec2 DescribeVpnGateways sqs
+ec2 DetachNetworkInterface sqs
+ec2 DisableEbsEncryptionByDefault sqs
+ec2 DisableIpamOrganizationAdminAccount sqs
+ec2 DisableTransitGatewayRouteTablePropagation sqs
+ec2 DisassociateIamInstanceProfile sqs
+ec2 DisassociateIpamByoasn sqs
+ec2 DisassociateTransitGatewayRouteTable sqs
+ec2 EnableEbsEncryptionByDefault sqs
+ec2 EnableIpamOrganizationAdminAccount sqs
+ec2 EnableTransitGatewayRouteTablePropagation sqs
+ec2 ExportTransitGatewayRoutes sqs
+ec2 GetEbsDefaultKmsKeyId sqs
+ec2 GetEbsEncryptionByDefault sqs
+ec2 GetIpamPoolAllocations sqs
+ec2 GetIpamPoolCidrs sqs
+ec2 GetManagedPrefixListEntries sqs
+ec2 GetSecurityGroupsForVpc sqs
+ec2 GetTransitGatewayRouteTableAssociations sqs
+ec2 GetTransitGatewayRouteTablePropagations sqs
+ec2 ModifyEbsDefaultKmsKeyId sqs
+ec2 ModifyHosts sqs
+ec2 ModifyInstanceMetadataOptions sqs
+ec2 ModifyIpam sqs
+ec2 ModifyIpamPool sqs
+ec2 ModifyManagedPrefixList sqs
+ec2 ModifyTransitGateway sqs
+ec2 ModifyTransitGatewayVpcAttachment sqs
+ec2 ModifyVolume sqs
+ec2 ModifyVpcEndpoint sqs
+ec2 ModifyVpcPeeringConnectionOptions sqs
+ec2 MonitorInstances sqs
+ec2 ProvisionIpamPoolCidr sqs
+ec2 ReleaseHosts sqs
+ec2 ReleaseIpamPoolAllocation sqs
+ec2 ReplaceIamInstanceProfileAssociation sqs
+ec2 ReplaceTransitGatewayRoute sqs
+ec2 RequestSpotInstances sqs
+ec2 ResetEbsDefaultKmsKeyId sqs
+ec2 SearchTransitGatewayRoutes sqs
+ec2 UnmonitorInstances sqs
+
+# elasticache: 15 (12 unrouted, 3 claimed elsewhere)
+elasticache CreateCacheCluster sqs
+elasticache CreateCacheParameterGroup sqs
+elasticache CreateCacheSubnetGroup sqs
+elasticache CreateUser iam
+elasticache DeleteCacheCluster sqs
+elasticache DeleteCacheParameterGroup sqs
+elasticache DeleteCacheSubnetGroup sqs
+elasticache DeleteUser iam
+elasticache DescribeCacheClusters sqs
+elasticache DescribeCacheParameterGroups sqs
+elasticache DescribeCacheParameters sqs
+elasticache DescribeCacheSubnetGroups sqs
+elasticache ListTagsForResource sns
+elasticache ModifyCacheParameterGroup sqs
+elasticache ModifyCacheSubnetGroup sqs
+
+# elasticloadbalancing: 4 (3 unrouted, 1 claimed elsewhere)
+elasticloadbalancing DescribeCapacityReservation sqs
+elasticloadbalancing DescribeListenerAttributes sqs
+elasticloadbalancing DescribeTags ec2
+elasticloadbalancing ModifyListenerAttributes sqs
+
+# email: 2 (1 unrouted, 1 claimed elsewhere)
+email GetTemplate cloudformation
+email UpdateAccountSendingEnabled sqs
+
+# monitoring: 3 (0 unrouted, 3 claimed elsewhere)
+monitoring ListTagsForResource sns
+monitoring TagResource sns
+monitoring UntagResource sns
+
+# rds: 48 (47 unrouted, 1 claimed elsewhere)
+rds AddSourceIdentifierToSubscription sqs
+rds CopyDBClusterParameterGroup sqs
+rds CopyDBClusterSnapshot sqs
+rds CopyDBParameterGroup sqs
+rds CopyDBSnapshot sqs
+rds CopyOptionGroup sqs
+rds CreateDBClusterEndpoint sqs
+rds CreateDBClusterSnapshot sqs
+rds CreateDBInstanceReadReplica sqs
+rds CreateDBSnapshot sqs
+rds CreateEventSubscription sqs
+rds CreateGlobalCluster sqs
+rds DeleteDBClusterEndpoint sqs
+rds DeleteDBClusterSnapshot sqs
+rds DeleteDBSnapshot sqs
+rds DeleteEventSubscription sqs
+rds DeleteGlobalCluster sqs
+rds DescribeDBClusterEndpoints sqs
+rds DescribeDBClusterSnapshotAttributes sqs
+rds DescribeDBSnapshotAttributes sqs
+rds DescribeEventSubscriptions sqs
+rds DescribeEvents sqs
+rds FailoverDBCluster sqs
+rds FailoverGlobalCluster sqs
+rds ListTagsForResource sns
+rds ModifyDBClusterEndpoint sqs
+rds ModifyDBClusterSnapshotAttribute sqs
+rds ModifyDBSnapshot sqs
+rds ModifyDBSnapshotAttribute sqs
+rds ModifyEventSubscription sqs
+rds ModifyGlobalCluster sqs
+rds PromoteReadReplica sqs
+rds PromoteReadReplicaDBCluster sqs
+rds RebootDBCluster sqs
+rds RemoveFromGlobalCluster sqs
+rds RemoveSourceIdentifierFromSubscription sqs
+rds ResetDBClusterParameterGroup sqs
+rds ResetDBParameterGroup sqs
+rds RestoreDBClusterFromSnapshot sqs
+rds RestoreDBClusterToPointInTime sqs
+rds RestoreDBInstanceFromDBSnapshot sqs
+rds RestoreDBInstanceToPointInTime sqs
+rds StartDBCluster sqs
+rds StartDBInstance sqs
+rds StopDBCluster sqs
+rds StopDBInstance sqs
+rds SwitchoverGlobalCluster sqs
+rds SwitchoverReadReplica sqs
+
+# redshift: 12 (9 unrouted, 3 claimed elsewhere)
+redshift CreateIntegration sqs
+redshift CreateTags ec2
+redshift DeleteIntegration sqs
+redshift DeleteTags ec2
+redshift DescribeClusterVersions sqs
+redshift DescribeIntegrations sqs
+redshift DescribeLoggingStatus sqs
+redshift DescribeOrderableClusterOptions sqs
+redshift DescribeTags ec2
+redshift DisableLogging sqs
+redshift EnableLogging sqs
+redshift ModifyClusterIamRoles sqs
+
+# sqs: 2 (0 unrouted, 2 claimed elsewhere)
+sqs AddPermission sns
+sqs RemovePermission sns