8231640: (prop) Canonical property storage

src/java.base/share/classes/java/util/Properties.java

@@ -41,8 +41,13 @@
 import java.nio.charset.Charset;
 import java.nio.charset.IllegalCharsetNameException;
 import java.nio.charset.UnsupportedCharsetException;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.time.DateTimeException;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
@@ -167,10 +172,41 @@ public class Properties extends Hashtable<Object,Object> {
      */
     private transient volatile ConcurrentHashMap<Object, Object> map;
 
-    // cached, string representation of any Date parsed out of the SOURCE_DATE_EPOCH environment variable
-    private static volatile String cachedDateComment;
-    // true if SOURCE_DATE_EPOCH environment variable value has been parsed
-    private static volatile boolean sourceDateEpochParsed;
+    @SuppressWarnings("removal")
+    private static final class LazyDateCommentProvider {
+        // formatter used while writing out current date. this formatter matches the format
+        // used by java.util.Date.toString()
+        private static final DateTimeFormatter currentDateFormatter =
+                DateTimeFormatter.ofPattern("EEE MMM dd HH:mm:ss zzz yyyy");
+        private static final String cachedDateComment;
+
+        static {
+            String sourceDateEpoch = System.getSecurityManager() == null
+                                        ? System.getenv("SOURCE_DATE_EPOCH")
+                                        : AccessController.doPrivileged((PrivilegedAction<String>)
+                                                () -> System.getenv("SOURCE_DATE_EPOCH"));
+            String dateComment = null;
+            if (sourceDateEpoch != null) {
+                try {
+                    long epochSeconds = Long.parseLong(sourceDateEpoch);
+                    dateComment = "#" + DateTimeFormatter.RFC_1123_DATE_TIME
+                            .withLocale(Locale.ROOT)
+                            .withZone(ZoneOffset.UTC)
+                            .format(Instant.ofEpochSecond(epochSeconds));
+                } catch (NumberFormatException | DateTimeException e) {
+                    // ignore any value that cannot be parsed for the SOURCE_DATE_EPOCH.
+                    // store APIs will subsequently use current date, in their date comments
+                }
+            }
+            cachedDateComment = dateComment;
+        }
+
+        private static String getDateComment() {
+            return cachedDateComment != null
+                            ? cachedDateComment
+                            : "#" + currentDateFormatter.format(ZonedDateTime.now());
+        }
+    }
 
     /**
      * Creates an empty property list with no default values.
@@ -920,9 +956,17 @@ private void store0(BufferedWriter bw, String comments, boolean escUnicode)
         if (comments != null) {
             writeComments(bw, comments);
         }
-        writeDateComment(bw);
+        bw.write(LazyDateCommentProvider.getDateComment());
+        bw.newLine();
         synchronized (this) {
-            for (Map.Entry<Object, Object> e : new TreeMap<>(map).entrySet()) {
+            var entries = map.entrySet().toArray(new Map.Entry<?, ?>[0]);
+            Arrays.sort(entries, new Comparator<Map.Entry<?, ?>>() {
+                @Override
+                public int compare(Map.Entry<?, ?> o1, Map.Entry<?, ?> o2) {
+                    return ((String) o1.getKey()).compareTo((String) o2.getKey());
+                }
+            });
+            for (Map.Entry<?, ?> e : entries) {
                 String key = (String)e.getKey();
                 String val = (String)e.getValue();
                 key = saveConvert(key, true, escUnicode);
@@ -937,59 +981,6 @@ private void store0(BufferedWriter bw, String comments, boolean escUnicode)
         bw.flush();
     }
 
-    private static void writeDateComment(BufferedWriter bw) throws IOException {
-        if (sourceDateEpochParsed && cachedDateComment == null) {
-            // SOURCE_DATE_EPOCH environment variable value has already been queried previously and
-            // the environment variable was either not set or its value couldn't be parsed to a Date.
-            // In either case, we write out the current date in the date comment
-            bw.write("#" + new Date());
-            bw.newLine();
-            return;
-        }
-        // Either the SOURCE_DATE_EPOCH environment variable needs to be queried or we have already
-        // queried it previously and are holding a cached string representation of that value.
-        // In either case, we first make sure the current caller has the necessary permissions to access
-        // that environment variable's value
-        String sourceDateEpoch = null;
-        try {
-            sourceDateEpoch = System.getenv("SOURCE_DATE_EPOCH");
-        } catch (SecurityException se) {
-            // caller code doesn't have permissions to SOURCE_DATE_EPOCH environment variable.
-            // Use current date in comment
-            bw.write("#" + new Date());
-            bw.newLine();
-            return;
-        }
-        // caller code has permissions to the environment variable, OK to use (any parseable) value
-        // of that environment variable in the date comment
-        if (!sourceDateEpochParsed) {
-            synchronized (Properties.class) {
-                if (!sourceDateEpochParsed) {
-                    try {
-                        String dateComment = null;
-                        if (sourceDateEpoch != null) {
-                            try {
-                                Date d = new Date(Long.parseLong(sourceDateEpoch) * 1000);
-                                // use the same format as that of Date.toGMTString() and a neutral locale for reproducibility
-                                DateFormat df = new SimpleDateFormat("d MMM yyyy HH:mm:ss 'GMT'", Locale.ROOT);
-                                df.setTimeZone(TimeZone.getTimeZone("GMT"));
-                                dateComment = "#" + df.format(d);
-                            } catch (NumberFormatException nfe) {
-                                // ignore any value that cannot be parsed for the SOURCE_DATE_EPOCH.
-                                // store APIs will subsequently use current date, in their date comments
-                            }
-                        }
-                        cachedDateComment = dateComment;
-                    } finally {
-                        sourceDateEpochParsed = true;
-                    }
-                }
-            }
-        }
-        bw.write(cachedDateComment != null ? cachedDateComment : "#" + new Date());
-        bw.newLine();
-    }
-
     /**
      * Loads all of the properties represented by the XML document on the
      * specified input stream into this properties table.

test/jdk/java/util/Properties/StoreReproducibilityTest.java

@@ -28,16 +28,20 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 import java.util.Locale;
 import java.util.Properties;
-import java.util.TimeZone;
 
 /*
  * @test
@@ -49,15 +53,14 @@
 public class StoreReproducibilityTest {
 
     private static final String ENV_SOURCE_DATE_EPOCH = "SOURCE_DATE_EPOCH";
-    private static final String GMT_DATE_FORMAT = "d MMM yyyy HH:mm:ss 'GMT'";
 
     public static void main(final String[] args) throws Exception {
         // no security manager enabled
         testWithoutSecurityManager();
-        // security manager enabled and security policy allows read permissions on getenv.SOURCE_DATE_EPOCH
-        testWithSecMgrCallerHasPermission();
-        // security manager enabled and security policy doesn't allow getenv.SOURCE_DATE_EPOCH permission
-        testWithSecMgrCallerNotPermitted();
+        // security manager enabled and security policy explicitly allows read permissions on getenv.SOURCE_DATE_EPOCH
+        testWithSecMgrExplicitPermission();
+        // security manager enabled and no explicit getenv.SOURCE_DATE_EPOCH permission
+        testWithSecMgrNoSpecificPermission();
         // invalid/unparsable value for SOURCE_DATE_EPOCH
         testInvalidSourceDateEpochValue();
     }
@@ -98,17 +101,23 @@ private static void testWithoutSecurityManager() throws Exception {
      * properties to a file. The launched Java program is passed an environment variable value for
      * {@code SOURCE_DATE_EPOCH} environment variable and the date comment written out to the file
      * is expected to use this value.
+     * The launched Java program is run with the default security manager and is granted
+     * a {@code read} permission on {@code getenv.SOURCE_DATE_EPOCH}.
      * The program is launched multiple times with the same value for {@code SOURCE_DATE_EPOCH}
      * and the output written out by each run of this program is verified to be exactly the same.
      * Additionally, the date comment that's written out is verified to be the expected date that
      * corresponds to the passed {@code SOURCE_DATE_EPOCH}.
-     * The launched Java program is run with the default security manager and the launched program that
-     * uses the Properties.store() APIs is granted a {@code read} permission on {@code getenv.SOURCE_DATE_EPOCH},
-     * thus allowing it to see the actual value of the environment variable.
      */
-    private static void testWithSecMgrCallerHasPermission() throws Exception {
-        final Path policyFile = Path.of(System.getProperty("test.src"),
-                "source-date-epoch-policy").toAbsolutePath();
+    private static void testWithSecMgrExplicitPermission() throws Exception {
+        final Path policyFile = Files.createTempFile("8231640", ".policy");
+        Files.write(policyFile, Collections.singleton("""
+                grant {
+                    // test writes/stores to a file, so FilePermission
+                    permission java.io.FilePermission "<<ALL FILES>>", "read,write";
+                    // explicitly grant read on SOURCE_DATE_EPOCH to verifies store() APIs work fine
+                    permission java.lang.RuntimePermission "getenv.SOURCE_DATE_EPOCH", "read";
+                };
+                """));
         final List<Path> storedFiles = new ArrayList<>();
         final String sourceDateEpoch = "1234342423";
         for (int i = 0; i < 5; i++) {
@@ -135,34 +144,42 @@ private static void testWithSecMgrCallerHasPermission() throws Exception {
      * properties to a file. The launched Java program is passed an environment variable value for
      * {@code SOURCE_DATE_EPOCH} environment variable and the date comment written out to the file
      * is expected to use this value.
-     * The launched Java program is run with the default security manager. The launched program that
-     * uses the Properties.store() APIs is NOT granted any permission on {@code getenv.SOURCE_DATE_EPOCH}.
-     * It is expected and verified in this test that the absence of such a permission will cause the
-     * date comment to be the "current date" instead of the date corresponding to the {@code SOURCE_DATE_EPOCH}
+     * The launched Java program is run with the default security manager and is NOT granted
+     * any explicit permission for {@code getenv.SOURCE_DATE_EPOCH}.
+     * The program is launched multiple times with the same value for {@code SOURCE_DATE_EPOCH}
+     * and the output written out by each run of this program is verified to be exactly the same.
+     * Additionally, the date comment that's written out is verified to be the expected date that
+     * corresponds to the passed {@code SOURCE_DATE_EPOCH}.
      */
-    private static void testWithSecMgrCallerNotPermitted() throws Exception {
-        final Path policyFile = Path.of(System.getProperty("test.src"),
-                "source-date-epoch-policy-no-perm").toAbsolutePath();
+    private static void testWithSecMgrNoSpecificPermission() throws Exception {
+        final Path policyFile = Files.createTempFile("8231640", ".policy");
+        Files.write(policyFile, Collections.singleton("""
+                grant {
+                    // test writes/stores to a file, so FilePermission
+                    permission java.io.FilePermission "<<ALL FILES>>", "read,write";
+                    // no other grants, not even "read" on SOURCE_DATE_EPOCH. test should still
+                    // work fine and the date comment should correspond to the value of SOURCE_DATE_EPOCH
+                };
+                """));
+        final List<Path> storedFiles = new ArrayList<>();
         final String sourceDateEpoch = "1234342423";
-        for (int i = 0; i < 2; i++) {
+        for (int i = 0; i < 5; i++) {
             final Path tmpFile = Files.createTempFile("8231640", ".props");
+            storedFiles.add(tmpFile);
             final ProcessBuilder processBuilder = ProcessTools.createJavaProcessBuilder(
                     "-Djava.security.manager",
                     "-Djava.security.policy=" + policyFile.toString(),
                     StoreTest.class.getName(),
                     tmpFile.toString(),
                     i % 2 == 0 ? "--use-outputstream" : "--use-writer");
             processBuilder.environment().put(ENV_SOURCE_DATE_EPOCH, sourceDateEpoch);
-            final Date processLaunchedAt = new Date();
-            // launch with a second delay so that we can then verify that the date comment
-            // written out by the program is "after" this date
-            Thread.sleep(1000);
             executeJavaProcess(processBuilder);
+            assertExpectedSourceEpochDate(tmpFile, sourceDateEpoch);
             if (!StoreTest.propsToStore.equals(loadProperties(tmpFile))) {
                 throw new RuntimeException("Unexpected properties stored in " + tmpFile);
             }
-            assertCurrentDate(tmpFile, processLaunchedAt);
         }
+        assertAllFileContentsAreSame(storedFiles, sourceDateEpoch);
     }
 
     /**
@@ -224,21 +241,22 @@ private static void assertExpectedSourceEpochDate(final Path destFile,
                     + " when " + ENV_SOURCE_DATE_EPOCH + " was set " +
                     "(to " + sourceEpochDate + ")");
         }
-        final Date parsedDate;
+        long parsedSecondsSinceEpoch;
         try {
-            final DateFormat df = new SimpleDateFormat(GMT_DATE_FORMAT, Locale.ROOT);
-            df.setTimeZone(TimeZone.getTimeZone("GMT"));
-            parsedDate = df.parse(dateComment);
-        } catch (ParseException pe) {
+            var d = DateTimeFormatter.RFC_1123_DATE_TIME
+                    .withLocale(Locale.ROOT)
+                    .withZone(ZoneOffset.UTC).parse(dateComment);
+            parsedSecondsSinceEpoch = Duration.between(Instant.ofEpochSecond(0), Instant.from(d)).toSeconds();
+        } catch (DateTimeParseException pe) {
             throw new RuntimeException("Unexpected date " + dateComment + " in stored properties " + destFile
                     + " when " + ENV_SOURCE_DATE_EPOCH + " was set " +
-                    "(to " + sourceEpochDate + ")");
+                    "(to " + sourceEpochDate + ")", pe);
 
         }
-        final long expected = Long.parseLong(sourceEpochDate) * 1000;
-        if (parsedDate.getTime() != expected) {
-            throw new RuntimeException("Expected " + expected + " millis since epoch but found "
-                    + parsedDate.getTime());
+        final long expected = Long.parseLong(sourceEpochDate);
+        if (parsedSecondsSinceEpoch != expected) {
+            throw new RuntimeException("Expected " + expected + " seconds since epoch but found "
+                    + parsedSecondsSinceEpoch);
         }
     }