fix(rules): disallow configurations on archiver rules

cryostatio · Aug 18, 2021 · 8872916 · 8872916
1 parent 2280c87
commit 8872916
Show file tree

Hide file tree

Showing 2 changed files with 83 additions and 0 deletions.
diff --git a/src/main/java/io/cryostat/rules/Rule.java b/src/main/java/io/cryostat/rules/Rule.java
@@ -137,6 +137,13 @@ public void validate() throws IllegalArgumentException, MatchExpressionValidatio
         requireNonNegative(this.archivalPeriodSeconds, Attribute.ARCHIVAL_PERIOD_SECONDS);
         requireNonNegative(this.preservedArchives, Attribute.PRESERVED_ARCHIVES);
         validateMatchExpression(this);
+
+        if (isArchiver()) {
+            requireNonPositive(this.archivalPeriodSeconds, Attribute.ARCHIVAL_PERIOD_SECONDS);
+            requireNonPositive(this.preservedArchives, Attribute.PRESERVED_ARCHIVES);
+            requireNonPositive(this.maxSizeBytes, Attribute.MAX_SIZE_BYTES);
+            requireNonPositive(this.maxAgeSeconds, Attribute.MAX_AGE_SECONDS);
+        }
     }
 
     private static String validateMatchExpression(Rule rule)
@@ -152,6 +159,14 @@ private static int requireNonNegative(int i, Attribute attr) {
         return i;
     }
 
+    private static int requireNonPositive(int i, Attribute attr) {
+        if (i > 0) {
+            throw new IllegalArgumentException(
+                    String.format("\"%s\" cannot be positive, was \"%d\"", attr, i));
+        }
+        return i;
+    }
+
     private static String validateEventSpecifier(String eventSpecifier)
             throws IllegalArgumentException {
         if (eventSpecifier.equals(ARCHIVE_EVENT)) {

diff --git a/src/test/java/io/cryostat/rules/RuleTest.java b/src/test/java/io/cryostat/rules/RuleTest.java
@@ -216,4 +216,72 @@ void shouldAcceptEventSpecifierArchiveSpecialCase() throws Exception {
                         .build();
         MatcherAssert.assertThat(rule.getEventSpecifier(), Matchers.equalTo("archive"));
     }
+
+    @Test
+    void shouldThrowOnArchiverWithArchivalPeriod() throws Exception {
+        IllegalArgumentException ex =
+                Assertions.assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            builder.name(NAME)
+                                    .matchExpression(MATCH_EXPRESSION)
+                                    .eventSpecifier("archive")
+                                    .archivalPeriodSeconds(5)
+                                    .build();
+                        });
+        MatcherAssert.assertThat(
+                ex.getMessage(),
+                Matchers.containsString("\"archivalPeriodSeconds\" cannot be positive, was \"5\""));
+    }
+
+    @Test
+    void shouldThrowOnArchiverWithPreservedArchives() throws Exception {
+        IllegalArgumentException ex =
+                Assertions.assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            builder.name(NAME)
+                                    .matchExpression(MATCH_EXPRESSION)
+                                    .eventSpecifier("archive")
+                                    .preservedArchives(5)
+                                    .build();
+                        });
+        MatcherAssert.assertThat(
+                ex.getMessage(),
+                Matchers.containsString("\"preservedArchives\" cannot be positive, was \"5\""));
+    }
+
+    @Test
+    void shouldThrowOnArchiverWithMaxSizeBytes() throws Exception {
+        IllegalArgumentException ex =
+                Assertions.assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            builder.name(NAME)
+                                    .matchExpression(MATCH_EXPRESSION)
+                                    .eventSpecifier("archive")
+                                    .maxSizeBytes(5)
+                                    .build();
+                        });
+        MatcherAssert.assertThat(
+                ex.getMessage(),
+                Matchers.containsString("\"maxSizeBytes\" cannot be positive, was \"5\""));
+    }
+
+    @Test
+    void shouldThrowOnArchiverWithMaxAgeSeconds() throws Exception {
+        IllegalArgumentException ex =
+                Assertions.assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            builder.name(NAME)
+                                    .matchExpression(MATCH_EXPRESSION)
+                                    .eventSpecifier("archive")
+                                    .maxAgeSeconds(5)
+                                    .build();
+                        });
+        MatcherAssert.assertThat(
+                ex.getMessage(),
+                Matchers.containsString("\"maxAgeSeconds\" cannot be positive, was \"5\""));
+    }
 }