Keep time outside ValidationOverrides

3 files changed, 60 insertions, 60 deletions

diff --git a/config-model-api/src/main/java/com/yahoo/config/application/api/ValidationOverrides.java b/config-model-api/src/main/java/com/yahoo/config/application/api/ValidationOverrides.java
index edcc4abb700..0d35967ff8a 100644
--- a/config-model-api/src/main/java/com/yahoo/config/application/api/ValidationOverrides.java
+++ b/config-model-api/src/main/java/com/yahoo/config/application/api/ValidationOverrides.java
@@ -27,71 +27,60 @@ import java.util.Optional;
  */
 public class ValidationOverrides {
 
+    public static final ValidationOverrides empty = new ValidationOverrides(ImmutableList.of(), "<deployment version='1.0'/>");
+
     private final List<Allow> overrides;
 
-    /** Instant to use as "now". This is a field to allow unit testing. */
-    private final Instant now;
-    
     private final String xmlForm;
 
-    /** Creates validation overrides for the current instant */
+    /** Creates a validation overrides which does not have an xml form */
     public ValidationOverrides(List<Allow> overrides) {
-        this(overrides, Instant.now());
-    }
-
-    public ValidationOverrides(List<Allow> overrides, Instant now) {
-        this(overrides, now, null);
+        this(overrides, null);
     }
 
-    private ValidationOverrides(List<Allow> overrides, Instant now, String xmlForm) {
+    private ValidationOverrides(List<Allow> overrides, String xmlForm) {
         this.overrides = ImmutableList.copyOf(overrides);
-        this.now = now;
         this.xmlForm = xmlForm;
-        for (Allow override : overrides)
-            if (now.plus(Duration.ofDays(30)).isBefore(override.until))
-                throw new IllegalArgumentException(override + " is too far in the future: Max 30 days is allowed");
     }
 
     /** Throws a ValidationException unless this validation is overridden at this time */
-    public void invalid(ValidationId validationId, String message) {
-        if ( ! allows(validationId))
+    public void invalid(ValidationId validationId, String message, Instant now) {
+        if ( ! allows(validationId, now))
             throw new ValidationException(validationId, message);
     }
 
-    public boolean allows(String validationIdString) {
+    public boolean allows(String validationIdString, Instant now) {
         Optional<ValidationId> validationId = ValidationId.from(validationIdString);
         if ( ! validationId.isPresent()) return false; // unknown id -> not allowed
-        return allows(validationId.get());
+        return allows(validationId.get(), now);
     }
 
     /** Returns whether the given (assumed invalid) change is allowed by this at the moment */
-    public boolean allows(ValidationId validationId) {
-        for (Allow override : overrides)
+    public boolean allows(ValidationId validationId, Instant now) {
+        for (Allow override : overrides) {
+            if (now.plus(Duration.ofDays(30)).isBefore(override.until))
+                throw new IllegalArgumentException(override + " is too far in the future: Max 30 days is allowed");
             if (override.allows(validationId, now))
                 return true;
+        }
         return false;
     }
 
     /** Returns the XML form of this, or null if it was not created by fromXml, nor is empty */
     public String xmlForm() { return xmlForm; }
 
-    public static ValidationOverrides empty() { 
-        return new ValidationOverrides(ImmutableList.of(), Instant.now(), "<deployment version='1.0'/>"); 
-    }
-
     /**
      * Returns a ValidationOverrides instance with the content of the given Reader.
      * An empty ValidationOverrides is returned if the argument is empty.
      *
      * @param reader the reader which optionally contains a validation-overrides XML structure
-     * @param now the instant to use as "now", settable for unit testing
      * @return a ValidationOverrides from the argument
      * @throws IllegalArgumentException if the validation-allows.xml file exists but is invalid
      */
-    public static ValidationOverrides fromXml(Optional<Reader> reader, Instant now) {
+    public static ValidationOverrides fromXml(Optional<Reader> reader) {
         try {
-            if ( ! reader.isPresent()) return ValidationOverrides.empty();
-            return fromXml(IOUtils.readAll(reader.get()), now);
+            if ( ! reader.isPresent()) return ValidationOverrides.empty;
+            return fromXml(IOUtils.readAll(reader.get()));
         } catch (IOException e) {
             throw new IllegalArgumentException("Could not read deployment spec", e);
         }
@@ -102,12 +91,11 @@ public class ValidationOverrides {
      * An empty ValidationOverrides is returned if the argument is empty.
      *
      * @param xmlForm the string which optionally contains a validation-overrides XML structure
-     * @param now the instant to use as "now", settable for unit testing
      * @return a ValidationOverrides from the argument
      * @throws IllegalArgumentException if the validation-allows.xml file exists but is invalid
      */
-    public static ValidationOverrides fromXml(String xmlForm, Instant now) {
-        if ( xmlForm.isEmpty()) return ValidationOverrides.empty();
+    public static ValidationOverrides fromXml(String xmlForm) {
+        if ( xmlForm.isEmpty()) return ValidationOverrides.empty;
 
         try {
             // Assume valid structure is ensured by schema validation
@@ -121,7 +109,7 @@ public class ValidationOverrides {
                 if (validationId.isPresent()) // skip unknown ids as they may be valid for other model versions
                     overrides.add(new ValidationOverrides.Allow(validationId.get(), until));
             }
-            return new ValidationOverrides(overrides, now, xmlForm);
+            return new ValidationOverrides(overrides, xmlForm);
         }
         catch (IllegalArgumentException e) {
             throw new IllegalArgumentException("validation-overrides is invalid", e);
diff --git a/config-model-api/src/main/java/com/yahoo/config/model/api/Model.java b/config-model-api/src/main/java/com/yahoo/config/model/api/Model.java
index c86859d2357..0c038077fe4 100644
--- a/config-model-api/src/main/java/com/yahoo/config/model/api/Model.java
+++ b/config-model-api/src/main/java/com/yahoo/config/model/api/Model.java
@@ -6,6 +6,8 @@ import com.yahoo.vespa.config.ConfigKey;
 import com.yahoo.vespa.config.ConfigPayload;
 import com.yahoo.vespa.config.buildergen.ConfigDefinition;
 
+import java.time.Clock;
+import java.time.Instant;
 import java.util.Optional;
 import java.util.Set;
 import java.util.Collection;
@@ -67,7 +69,12 @@ public interface Model {
      * This is a validation override which is useful when we skip loading old config models
      * due to some problem, or when we need to try a newer version of the platform on some node.
      */
-    default boolean allowModelVersionMismatch() { return false; }
+    default boolean allowModelVersionMismatch(Instant now) { return false; }
+
+    /** @deprecated pass now. */
+    // TODO: Remove this when no version older than 6.115 is deployed anywhere
+    @Deprecated
+    default boolean allowModelVersionMismatch() { return allowModelVersionMismatch(Clock.systemUTC().instant()); }
 
     /**
      * Returns whether old config models should be loaded (default) or not.
@@ -79,6 +86,11 @@ public interface Model {
      * If a model returns true to this it should also return true to {@link #allowModelVersionMismatch}
      * or clients requesting config for those old models will not get config at all.
      */
-    default boolean skipOldConfigModels() { return false; }
+    default boolean skipOldConfigModels(Instant now) { return false; }
+    
+    /** @deprecated pass now. */
+    // TODO: Remove this when no version older than 6.115 is deployed anywhere
+    @Deprecated 
+    default boolean skipOldConfigModels() { return skipOldConfigModels(Clock.systemUTC().instant()); }
 
 }
diff --git a/config-model-api/src/test/java/com/yahoo/config/application/api/ValidationOverrideTest.java b/config-model-api/src/test/java/com/yahoo/config/application/api/ValidationOverrideTest.java
index 919d52ac811..75e1fe72e4b 100644
--- a/config-model-api/src/test/java/com/yahoo/config/application/api/ValidationOverrideTest.java
+++ b/config-model-api/src/test/java/com/yahoo/config/application/api/ValidationOverrideTest.java
@@ -8,7 +8,7 @@ import org.xml.sax.SAXException;
 
 import java.io.IOException;
 import java.io.StringReader;
-import java.time.Clock;
+import java.time.Instant;
 import java.util.Optional;
 
 import static org.junit.Assert.assertEquals;
@@ -27,29 +27,29 @@ public class ValidationOverrideTest {
                 "</validation-overrides>";
         {
 
-            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)),
-                                                                        ManualClock.at("2000-01-01T23:59:00"));
-            assertOverridden("indexing-change", overrides);
-            assertOverridden("indexing-mode-change", overrides);
-            assertNotOverridden("field-type-change", overrides);
+            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)));
+            Instant now = ManualClock.at("2000-01-01T23:59:00");
+            assertOverridden("indexing-change", overrides, now);
+            assertOverridden("indexing-mode-change", overrides, now);
+            assertNotOverridden("field-type-change", overrides, now);
 
             assertEquals(validationOverrides, overrides.xmlForm());
         }
 
         {
-            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)),
-                                                                        ManualClock.at("2000-01-02T00:00:00"));
-            assertNotOverridden("indexing-change", overrides);
-            assertOverridden("indexing-mode-change", overrides);
-            assertNotOverridden("field-type-change", overrides);
+            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)));
+            Instant now = ManualClock.at("2000-01-02T00:00:00");
+            assertNotOverridden("indexing-change", overrides, now);
+            assertOverridden("indexing-mode-change", overrides, now);
+            assertNotOverridden("field-type-change", overrides, now);
         }
 
         {
-            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)),
-                                                                        ManualClock.at("2000-01-04T00:00:00"));
-            assertNotOverridden("indexing-change", overrides);
-            assertNotOverridden("indexing-mode-change", overrides);
-            assertNotOverridden("field-type-change", overrides);
+            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)));
+            Instant now = ManualClock.at("2000-01-04T00:00:00");
+            assertNotOverridden("indexing-change", overrides, now);
+            assertNotOverridden("indexing-mode-change", overrides, now);
+            assertNotOverridden("field-type-change", overrides, now);
         }
 
     }
@@ -62,31 +62,31 @@ public class ValidationOverrideTest {
                 "</validation-overrides>";
 
         try {
-            ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)),
-                                        ManualClock.at("2000-01-01T23:59:00"));
+            ValidationOverrides overrides = ValidationOverrides.fromXml(Optional.of(new StringReader(validationOverrides)));
+            Instant now = ManualClock.at("2000-01-01T23:59:00");
+            overrides.allows("indexing-change", now);
             Assert.fail("Expected validation interval override validation validation failure");
         }
         catch (IllegalArgumentException e) {
-            Assert.assertEquals("validation-overrides is invalid", e.getMessage());
             Assert.assertEquals("allow 'indexing-change' until 2000-02-03T00:00:00Z is too far in the future: Max 30 days is allowed",
-                                e.getCause().getMessage());
+                                e.getMessage());
         }
     }
     
     @Test
     public void testEmpty() {
-        ValidationOverrides empty = ValidationOverrides.empty();
-        ValidationOverrides emptyReserialized = ValidationOverrides.fromXml(empty.xmlForm(), Clock.systemUTC().instant());
+        ValidationOverrides empty = ValidationOverrides.empty;
+        ValidationOverrides emptyReserialized = ValidationOverrides.fromXml(empty.xmlForm());
         assertEquals(empty.xmlForm(), emptyReserialized.xmlForm());
     }
 
-    private void assertOverridden(String validationId, ValidationOverrides overrides) {
-        overrides.invalid(ValidationId.from(validationId).get(), "message"); // should not throw exception
+    private void assertOverridden(String validationId, ValidationOverrides overrides, Instant now) {
+        overrides.invalid(ValidationId.from(validationId).get(), "message", now); // should not throw exception
     }
 
-    private void assertNotOverridden(String validationId, ValidationOverrides overrides) {
+    private void assertNotOverridden(String validationId, ValidationOverrides overrides, Instant now) {
         try {
-            overrides.invalid(ValidationId.from(validationId).get(), "message");
+            overrides.invalid(ValidationId.from(validationId).get(), "message", now);
             Assert.fail("Expected '" + validationId + "' to not be overridden");
         }
         catch (ValidationOverrides.ValidationException expected) {