sdnr/wt/devicemanager/provider/src/test/java/org/onap/ccsdk/features/sdnr/wt/devicemanager/test/util/NetconfTimeStampOld.java

   1 /*******************************************************************************
   2  * ============LICENSE_START========================================================================
   3  * ONAP : ccsdk feature sdnr wt
   4  * =================================================================================================
   5  * Copyright (C) 2019 highstreet technologies GmbH Intellectual Property. All rights reserved.
   6  * =================================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   8  * in compliance with the License. You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software distributed under the License
  13  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  14  * or implied. See the License for the specific language governing permissions and limitations under
  15  * the License.
  16  * ============LICENSE_END==========================================================================
  17  ******************************************************************************/
  18 package org.onap.ccsdk.features.sdnr.wt.devicemanager.test.util;
  19
  20 import java.text.ParseException;
  21 import java.text.SimpleDateFormat;
  22 import java.util.Date;
  23 import java.util.TimeZone;
  24 import java.util.regex.Matcher;
  25 import java.util.regex.Pattern;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29
  30 /**
  31  * Function is handling the NETCONF and the format used by database and restconf communication.
  32  *
  33  * Input supported for the formats used in NETCONF messages:
  34  *
  35  * Format1 ISO 8601 2017-01-18T11:44:49.482-05:00
  36  *
  37  * Format2 NETCONF - pattern from ietf-yang-types "2013-07-15" Pattern:
  38  * "\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[\+\-](\d{2}):(\d{2}))"
  39  *
  40  * Format3 NETCONF DateAndTime CoreModel-CoreFoundationModule-TypeDefinitions vom
  41  * 2016-07-01 Example1: 20170118114449.1Z Example2: 20170118114449.1-0500 Pattern:
  42  * "\d{4}\d{2}\d{2}\d{2}\d{2}\d{2}.\d+?(Z|[\+\-](\d{2})(\d{2}))" typedef DateAndTime { description
  43  * "This primitive type defines the date and time according to the following structure:
  44  * 'yyyyMMddhhmmss.s[Z|{+|-}HHMm]' where: yyyy '0000'..'9999' year MM '01'..'12' month dd '01'..'31'
  45  * day hh '00'..'23' hour mm '00'..'59' minute ss '00'..'59' second s '.0'..'.9' tenth of second
  46  * (set to '.0' if EMS or NE cannot support this granularity) Z 'Z' indicates UTC (rather than local
  47  * time) {+|-} '+' or '-' delta from UTC HH '00'..'23' time zone difference in hours Mm '00'..'59'
  48  * time zone difference in minutes."; type string; } Format4 E/// specific Example1:
  49  * 2017-01-23T13:32:38-05:00 Example2: 2017-01-23T13:32-05:00
  50  *
  51  * Input formats netconfTime as String according the formats given above
  52  *
  53  * Return format is String in ISO8601 Format for database and presentation.
  54  *
  55  * Example formats:
  56  *    1) ISO8601. Example 2017-01-18T11:44:49.482-05:00
  57  *    2) Microwave ONF. Examples 20170118114449.1Z, 20170118114449.1-0500
  58  *    3.1) Ericson. Example: 2017-01-23T13:32:38-05:00
  59  *    3.2) Ericson. Example: 2017-01-23T13:32-05:00
  60  *          Always 10 Groups,
  61  *          1:Year 2:Month 3:day 4:Hour 5:minute 6:optional sec 7:optional ms 8:optional Z or 9:offset
  62  *           signedhour 10:min
  63  *
  64  * Template:
  65  *     private static final NetconfTimeStamp NETCONFTIME_CONVERTER = NetconfTimeStamp.getConverter();
  66  */
  67
  68 public class NetconfTimeStampOld {
  69     private static final Logger LOG = LoggerFactory.getLogger(NetconfTimeStampOld.class);
  70
  71     private static final NetconfTimeStampOld CONVERTER = new NetconfTimeStampOld();
  72
  73     private final SimpleDateFormat dateFormatResult = init("yyyy-MM-dd'T'HH:mm:ss.S'Z'", TimeZone.getTimeZone("GMT"));
  74     private final SimpleDateFormat dateFormatConvert = init("yyyy-MM-dd HH:mm:ss.S", TimeZone.getTimeZone("GMT"));
  75     private static int MILLISECONDSDIGITS = 3; // Digits of milliseconds in dateFormatResult
  76     private static String MILLISECONDZEROS = "000"; // String with zeros for milliseconds in dateFormatResult
  77     private static final Pattern dateNetconfPatter = Pattern.compile(
  78         "(\\d{4})-?(\\d{2})-?(\\d{2})T?(\\d{2}):?(\\d{2})(?:(?::?)(\\d{2}))?(?:.(\\d+))?(?:(Z)|([+-]\\d{2}):?(\\d{2}))");
  79
  80     /*
  81      * ------------------------------------ Public function
  82      */
  83
  84     /**
  85      * Use static access
  86      */
  87     private NetconfTimeStampOld() {
  88     }
  89
  90     /**
  91      * Use this function to get the converter
  92      * @return global converter
  93      */
  94     public static NetconfTimeStampOld getConverter() {
  95         return CONVERTER;
  96     }
  97
  98     /**
  99      * Get actual timestamp as NETCONF specific type NETCONF/YANG 1.0 Format
 100      *
 101      * @return String with Date in NETCONF/YANG Format Version 1.0.
 102      */
 103     public String getTimeStampAsNetconfString() {
 104         return this.getRightFormattedDate(new Date().getTime());
 105     }
 106
 107     /**
 108      * Get actual timestamp as NETCONF specific type NETCONF/YANG 1.0 Format
 109
 110      * @return String with Date in NETCONF/YANG Format Version 1.0.
 111      */
 112     public String getTimeStampAsNetconfString(Date date) {
 113         return getRightFormattedDate(date.getTime());
 114     }
 115     /**
 116      * Get actual timestamp as NETCONF specific type NETCONF/YANG 1.0 Format in GMT
 117      *
 118      * @return DateAndTime Type 1.0. Date in NETCONF/YANG Format Version 1.0.
 119      */
 120     public DateAndTime getTimeStamp() {
 121         return DateAndTime.getDefaultInstance(getTimeStampAsNetconfString());
 122     }
 123
 124     /**
 125      * Get time from date as NETCONF specific type NETCONF/YANG 1.0 Format in GMT
 126      * @param date specifying the date and time
 127      * @return DateAndTime Type 1.0. Date in NETCONF/YANG Format Version 1.0.
 128      */
 129     public DateAndTime getTimeStamp(Date date) {
 130         return DateAndTime.getDefaultInstance(getTimeStampAsNetconfString(date));
 131     }
 132
 133
 134     /**
 135      * Return the String with a NETCONF time converted to long
 136      *
 137      * @param netconfTime as String according the formats given above
 138      * @return Epoch milliseconds
 139      * @throws IllegalArgumentException In case of no compliant time format definition for the string
 140      * @throws ParseException Time parsing failed
 141      */
 142     public long getTimeStampFromNetconfAsMilliseconds(String netconfTime)
 143             throws IllegalArgumentException {
 144         Matcher m = dateNetconfPatter.matcher(netconfTime);
 145         // According to specified matches there have to be 10 parameter
 146         if (m.matches() && m.groupCount() == 10) {
 147             // Convert now
 148                 synchronized(dateFormatConvert) {
 149                         long utcMillis;
 150                                 try {
 151                                         utcMillis = dateFormatConvert.parse(getTimeAsNormalizedString(m, m.group(6), m.group(7))).getTime()
 152                                             - getTimezoneOffsetMilliseconds(m.group(9), m.group(10));
 153                                 return utcMillis;
 154                                 } catch (ParseException e) {
 155                             throw new IllegalArgumentException("Parse problem for NETCONF data string: " + netconfTime);
 156                                 }
 157                 }
 158         } else {
 159             throw new IllegalArgumentException("No pattern for NETCONF data string: " + netconfTime);
 160         }
 161     }
 162
 163     /**
 164      * Deliver String result.
 165      *
 166      * @param netconfTime as String according the formats given above
 167      * @return If successful: String in ISO8601 Format for database and presentation. If "wrong formed
 168      *         input" the Input string with the prefix "Mailformed date" is delivered back.
 169      */
 170     public String getTimeStampFromNetconf(String netconfTime) {
 171         Matcher m = dateNetconfPatter.matcher(netconfTime);
 172         // According to spezified matches there have to be 10 parameter
 173         if (m.matches() && m.groupCount() == 10) {
 174             // Convert now
 175             try {
 176                 synchronized(dateFormatConvert) {
 177                         long utcMillis = dateFormatConvert.parse(getTimeAsNormalizedString(m, m.group(6), m.group(7))).getTime()
 178                                 - getTimezoneOffsetMilliseconds(m.group(9), m.group(10));
 179                         return getRightFormattedDate(utcMillis);
 180                 }
 181             } catch (ParseException e) {
 182                 LOG.info(e.getMessage());
 183             } catch (IllegalArgumentException e) {
 184                 LOG.info(e.getMessage());
 185             }
 186         }
 187         LOG.debug("No pattern for NETCONF data string: {}", netconfTime);
 188         return "Malformed date: " + netconfTime; // Error handling
 189     }
 190
 191     /*-------------------------------------------
 192      * Private and static functions
 193      */
 194     /**
 195      * Convert timeZone parameter in format [+-]/d/d:/d/d into milliseconds
 196      *
 197      * @param m Index 9 with "+/-" and hour string or null for UTZ, Index 10 with minutes
 198      * @return long milliseconds of TimeZoneOffset
 199      * @throws IllegalArgumentException If parameters are wrong
 200      */
 201     private static long getTimezoneOffsetMilliseconds(String timeZoneHour, String timeZoneMinute)
 202             throws IllegalArgumentException {
 203         // -- Calculate timezone specific offset
 204         long timeZoneOffsetMilliseconds = 0;
 205         if (timeZoneHour != null) {
 206             // Time zone offset in hours and minutes
 207             int tzHour = 0;
 208             int tzMinutes = 0;
 209             tzHour = Integer.valueOf(timeZoneHour);
 210             if (timeZoneMinute != null) {
 211                 tzMinutes = Integer.valueOf(timeZoneMinute);
 212             } else {
 213                 throw new IllegalArgumentException("Problem in Netconf Time format timeZone minutes parameter.");
 214             }
 215             timeZoneOffsetMilliseconds = (tzHour * 60 + (tzHour > 0 ? tzMinutes : -tzMinutes)) * 60000L;
 216         }
 217         return timeZoneOffsetMilliseconds;
 218     }
 219
 220     /**
 221      * Convert parameters to String with year .. minutes and optional Seconds and .. milliseconds
 222      *
 223      * @param m Matcher with parsed date
 224      * @param secString Seconds as String or null
 225      * @param msString Milliseconds as String or null
 226      * @return Normalized time string
 227      */
 228     private static String getTimeAsNormalizedString(Matcher m, String secString, String msString) {
 229         // -- Create time as normalized string
 230         StringBuffer sb = new StringBuffer();
 231         sb.append(m.group(1)); // year
 232         sb.append('-');
 233         sb.append(m.group(2)); // Month
 234         sb.append('-');
 235         sb.append(m.group(3)); // Day
 236         sb.append(' ');
 237         sb.append(m.group(4)); // Hour 0-23
 238         sb.append(':');
 239         sb.append(m.group(5)); // Minute
 240         sb.append(':');
 241         sb.append(secString != null ? secString : "00"); // Seconds (optional)
 242         sb.append('.');
 243         if (msString == null) { // Milliseconds optional
 244             sb.append(MILLISECONDZEROS);
 245         } else if (msString.length() <= MILLISECONDSDIGITS) {
 246             sb.append(msString); // Millisecond
 247             sb.append(MILLISECONDZEROS.substring(0, MILLISECONDSDIGITS - msString.length()));
 248         } else {
 249             sb.append(msString.substring(0, MILLISECONDSDIGITS)); // Only first Three
 250         }
 251         return sb.toString();
 252     }
 253
 254     /**
 255      * Deliver format in a way that milliseconds are correct.
 256      *
 257      * @param dateMillis Date as milliseconds in Java definition
 258      * @return String
 259      */
 260     private String getRightFormattedDate(long dateMillis) {
 261         long tenthOfSeconds = dateMillis % 1000 / 100L; // Extract 100 milliseconds
 262         long base = dateMillis / 1000L * 1000L; // Cut milliseconds to 000
 263         Date newDate = new Date(base + tenthOfSeconds);
 264         synchronized(dateFormatResult) {
 265                 return dateFormatResult.format(newDate);
 266         }
 267     }
 268
 269     /**
 270      * Static initialization
 271      */
 272     private static SimpleDateFormat init(String format, TimeZone zone) {
 273         if (zone == null) {
 274             throw new ExceptionInInitializerError();
 275         } else {
 276             SimpleDateFormat dateFormat;
 277             dateFormat = new SimpleDateFormat(format);
 278             dateFormat.setTimeZone(zone);
 279             return dateFormat;
 280         }
 281     }
 282
 283
 284
 285 }