Deprecation info for joda-java migration

docs/reference/indices/templates.asciidoc

@@ -41,7 +41,9 @@ PUT _template/template_1
 }
 --------------------------------------------------
 // CONSOLE
-// TESTSETUP
+// TEST[setup:name]
+// TEST[warning:'y' year becomes 'u'. Use 'y' for year-of-era.; 'Z' time zone offset/id fails when parsing 'Z' for Zulu timezone. Consider using 'X'. Prefix your date format with '8' to use the new specifier.]
+
 
 NOTE: Index templates provide C-style /* */ block comments. Comments are allowed
 everywhere in the JSON document except before the initial opening curly bracket. 

server/src/main/java/org/elasticsearch/common/joda/Joda.java

@@ -49,6 +49,17 @@
 import java.util.Locale;
 import java.util.regex.Pattern;
 
+import static org.elasticsearch.common.time.FormatNames.BASICDATE;
+import static org.elasticsearch.common.time.FormatNames.BASICDATETIME;
+import static org.elasticsearch.common.time.FormatNames.BASICDATETIMENOMILLIS;
+import static org.elasticsearch.common.time.FormatNames.BASICORDINALDATE;
+import static org.elasticsearch.common.time.FormatNames.BASICORDINALDATETIME;
+import static org.elasticsearch.common.time.FormatNames.BASICORDINALDATETIMENOMILLIS;
+import static org.elasticsearch.common.time.FormatNames.BASICTIME;
+import static org.elasticsearch.common.time.FormatNames.BASICTIMENOMILLIS;
+import static org.elasticsearch.common.time.FormatNames.BASICTTIME;
+import static org.elasticsearch.common.time.FormatNames.BASICTTIMENOMILLIS;
+
 public class Joda {
 
     private static DeprecationLogger deprecationLogger = new DeprecationLogger(LogManager.getLogger(Joda.class));
@@ -65,25 +76,25 @@ public static JodaDateFormatter forPattern(String input) {
         }
 
         DateTimeFormatter formatter;
-        if ("basicDate".equals(input) || "basic_date".equals(input)) {
+        if (BASICDATE.matches(input)) {
             formatter = ISODateTimeFormat.basicDate();
-        } else if ("basicDateTime".equals(input) || "basic_date_time".equals(input)) {
+        } else if (BASICDATETIME.matches(input) ) {
             formatter = ISODateTimeFormat.basicDateTime();
-        } else if ("basicDateTimeNoMillis".equals(input) || "basic_date_time_no_millis".equals(input)) {
+        } else if (BASICDATETIMENOMILLIS.matches(input) ) {
             formatter = ISODateTimeFormat.basicDateTimeNoMillis();
-        } else if ("basicOrdinalDate".equals(input) || "basic_ordinal_date".equals(input)) {
+        } else if (BASICORDINALDATE.matches(input) ) {
             formatter = ISODateTimeFormat.basicOrdinalDate();
-        } else if ("basicOrdinalDateTime".equals(input) || "basic_ordinal_date_time".equals(input)) {
+        } else if (BASICORDINALDATETIME.matches(input) ) {
             formatter = ISODateTimeFormat.basicOrdinalDateTime();
-        } else if ("basicOrdinalDateTimeNoMillis".equals(input) || "basic_ordinal_date_time_no_millis".equals(input)) {
+        } else if (BASICORDINALDATETIMENOMILLIS.matches(input) ) {
             formatter = ISODateTimeFormat.basicOrdinalDateTimeNoMillis();
-        } else if ("basicTime".equals(input) || "basic_time".equals(input)) {
+        } else if (BASICTIME.matches(input) ) {
             formatter = ISODateTimeFormat.basicTime();
-        } else if ("basicTimeNoMillis".equals(input) || "basic_time_no_millis".equals(input)) {
+        } else if (BASICTIMENOMILLIS.matches(input) ) {
             formatter = ISODateTimeFormat.basicTimeNoMillis();
-        } else if ("basicTTime".equals(input) || "basic_t_time".equals(input)) {
+        } else if (BASICTTIME.matches(input) ) {
             formatter = ISODateTimeFormat.basicTTime();
-        } else if ("basicTTimeNoMillis".equals(input) || "basic_t_time_no_millis".equals(input)) {
+        } else if (BASICTTIMENOMILLIS.matches(input) ) {
             formatter = ISODateTimeFormat.basicTTimeNoMillis();
         } else if ("basicWeekDate".equals(input) || "basic_week_date".equals(input)) {
             formatter = ISODateTimeFormat.basicWeekDate();
@@ -267,18 +278,11 @@ public static JodaDateFormatter forPattern(String input) {
         return new JodaDateFormatter(input, formatter, formatter);
     }
 
-    private static void maybeLogJodaDeprecation(String input) {
-        if (input.contains("CC")) {
-            deprecationLogger.deprecatedAndMaybeLog("joda-century-of-era-format",
-                "Use of 'C' (century-of-era) is deprecated and will not be supported in the next major version of Elasticsearch.");
-        }
-        if (input.contains("YY")) {
-            deprecationLogger.deprecatedAndMaybeLog("joda-year-of-era-format", "Use of 'Y' (year-of-era) will change to 'y' in the" +
-                " next major version of Elasticsearch. Prefix your date format with '8' to use the new specifier.");
-        }
-        if (input.contains("xx")) {
-            deprecationLogger.deprecatedAndMaybeLog("joda-week-based-year-format","Use of 'x' (week-based-year) will change" +
-                " to 'Y' in the next major version of Elasticsearch. Prefix your date format with '8' to use the new specifier.");
+    private static void maybeLogJodaDeprecation(String format) {
+        if (JodaDeprecationPatterns.isDeprecatedFormat(format)) {
+            String suggestion = JodaDeprecationPatterns.formatSuggestion(format);
+            deprecationLogger.deprecatedAndMaybeLog("joda-pattern-deprecation",
+                suggestion + " " + JodaDeprecationPatterns.USE_PREFIX_8_WARNING);
         }
     }
 

server/src/main/java/org/elasticsearch/common/joda/JodaDeprecationPatterns.java

@@ -0,0 +1,85 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.common.joda;
+
+import org.elasticsearch.common.time.DateFormatter;
+import org.elasticsearch.common.time.FormatNames;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+public class JodaDeprecationPatterns {
+    private static Map<String, String> JODA_PATTERNS_DEPRECATIONS = new LinkedHashMap<>();
+
+    static {
+        JODA_PATTERNS_DEPRECATIONS.put("Y", "'Y' year-of-era becomes 'y'. Use 'Y' for week-based-year.");
+        JODA_PATTERNS_DEPRECATIONS.put("y", "'y' year becomes 'u'. Use 'y' for year-of-era.");
+        JODA_PATTERNS_DEPRECATIONS.put("C", "'C' century of era is no longer supported.");
+        JODA_PATTERNS_DEPRECATIONS.put("x", "'x' weak-year becomes 'Y'. Use 'x' for zone-offset.");
+        JODA_PATTERNS_DEPRECATIONS.put("Z",
+            "'Z' time zone offset/id fails when parsing 'Z' for Zulu timezone. Consider using 'X'.");
+        JODA_PATTERNS_DEPRECATIONS.put("z",
+            "'z' time zone text. Will print 'Z' for Zulu given UTC timezone.");
+    }
+
+    public static final String USE_PREFIX_8_WARNING = "Prefix your date format with '8' to use the new specifier.";
+
+    /**
+     * Returns true if pattern is deprecated. That is when it was not already prefixed with 8 (meaning already upgraded)
+     * and it is not a predefined pattern from <code>FormatNames</code>  like basic_date_time_no_millis
+     * and it uses pattern characters which changed meaning from joda to java like Y->y
+     * @param format
+     * @return
+     */
+    public static boolean isDeprecatedFormat(String format) {
+        List<String> patterns = DateFormatter.splitCombinedPatterns(format);
+
+        for (String pattern : patterns) {
+            boolean isDeprecated = pattern.startsWith("8") == false && FormatNames.exist(pattern) == false &&
+                JODA_PATTERNS_DEPRECATIONS.keySet().stream()
+                                          .filter(s -> pattern.contains(s))
+                                          .findAny()
+                                          .isPresent();
+            if (isDeprecated)
+                return true;
+        }
+        return false;
+    }
+
+    public static String formatSuggestion(String format) {
+        List<String> patterns = DateFormatter.splitCombinedPatterns(format);
+
+        StringJoiner joiner = new StringJoiner("; ");
+        for (String pattern : patterns) {
+            if (isDeprecatedFormat(pattern)) {
+
+                String suggestion = JODA_PATTERNS_DEPRECATIONS.entrySet().stream()
+                                                              .filter(s -> pattern.contains(s.getKey()))
+                                                              .map(s -> s.getValue())
+                                                              .collect(Collectors.joining("; "));
+                joiner.add(suggestion);
+            }
+        }
+        return joiner.toString();
+    }
+}

server/src/main/java/org/elasticsearch/common/time/DateFormatter.java

@@ -32,6 +32,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
+import java.util.stream.Collectors;
 
 public interface DateFormatter {
 
@@ -138,18 +139,26 @@ static DateFormatter forPattern(String input) {
         // dates starting with 8 will not be using joda but java time formatters
         input = input.substring(1);
 
-        List<DateFormatter> formatters = new ArrayList<>();
-        for (String pattern : Strings.delimitedListToStringArray(input, "||")) {
-            if (Strings.hasLength(pattern) == false) {
-                throw new IllegalArgumentException("Cannot have empty element in multi date format pattern: " + input);
-            }
-            formatters.add(DateFormatters.forPattern(pattern));
-        }
+        List<String> patterns = splitCombinedPatterns(input);
+        List<DateFormatter> formatters = patterns.stream()
+                                                 .map(DateFormatters::forPattern)
+                                                 .collect(Collectors.toList());
 
         if (formatters.size() == 1) {
             return formatters.get(0);
         }
 
         return DateFormatters.merge(input, formatters);
     }
+
+    public static List<String> splitCombinedPatterns(String input) {
+        List<String> formatters = new ArrayList<>();
+        for (String pattern : Strings.delimitedListToStringArray(input, "||")) {
+            if (Strings.hasLength(pattern) == false) {
+                throw new IllegalArgumentException("Cannot have empty element in multi date format pattern: " + input);
+            }
+            formatters.add(pattern);
+        }
+        return formatters;
+    }
 }