- Fixed incorrect parsing of time values

- Added test for https://issues.redhat.com/browse/JGRP-2867

Author: belaban

src/org/jgroups/conf/PropertyConverters.java

@@ -16,6 +16,8 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static org.jgroups.conf.AttributeType.TIME;
+
 /**
  * Groups a set of standard PropertyConverter(s) supplied by JGroups.
  *
@@ -164,34 +166,33 @@ public Object convert(Object obj, Class<?> propertyFieldType, String propertyNam
         }
 
         @Override
-        public Object convert(Property annotation, Object obj, Class<?> propertyFieldType, String propertyName, String propertyValue,
+        public Object convert(Property ann, Object obj, Class<?> propertyFieldType, String propertyName, String propValue,
                               boolean check_scope, StackType ip_version) throws Exception {
-            if(propertyValue == null)
+            if(propValue == null)
                 throw new NullPointerException("Property value cannot be null");
 
             if(Boolean.TYPE.equals(propertyFieldType))
-                return Boolean.parseBoolean(propertyValue);
+                return Boolean.parseBoolean(propValue);
             if(Integer.TYPE.equals(propertyFieldType))
-                return Util.readBytesInteger(propertyValue);
-            if(Long.TYPE.equals(propertyFieldType)) {
-                return annotation != null && annotation.type() == AttributeType.TIME ? Util.readDurationLong(propertyValue, annotation.unit()) : Util.readBytesLong(propertyValue);
-            }
+                return ann != null && ann.type() == TIME? Util.readDurationInt(propValue, ann.unit()) : Util.readBytesInteger(propValue);
+            if(Long.TYPE.equals(propertyFieldType))
+                return ann != null && ann.type() == TIME ? Util.readDurationLong(propValue, ann.unit()) : Util.readBytesLong(propValue);
             if(Byte.TYPE.equals(propertyFieldType))
-                return Byte.parseByte(propertyValue);
+                return Byte.parseByte(propValue);
             if(Double.TYPE.equals(propertyFieldType))
-                return Util.readBytesDouble(propertyValue);
+                return Util.readBytesDouble(propValue);
             if(Short.TYPE.equals(propertyFieldType))
-                return Short.parseShort(propertyValue);
+                return Short.parseShort(propValue);
             if(Float.TYPE.equals(propertyFieldType))
-                return Float.parseFloat(propertyValue);
+                return Float.parseFloat(propValue);
             if(String[].class.equals(propertyFieldType))
-                return Util.parseStringArray(propertyValue, ",");
+                return Util.parseStringArray(propValue, ",");
             if(propertyFieldType.isEnum())
-                return Util.createEnum(propertyValue, propertyFieldType);
+                return Util.createEnum(propValue, propertyFieldType);
             if(InetAddress.class.equals(propertyFieldType)) {
                 InetAddress retval=null;
-                if(propertyValue.contains(",")) {
-                    List<String> addrs=Util.parseCommaDelimitedStrings(propertyValue);
+                if(propValue.contains(",")) {
+                    List<String> addrs=Util.parseCommaDelimitedStrings(propValue);
                     for(String addr : addrs) {
                         try {
                             retval=Util.getAddress(addr, ip_version);
@@ -202,10 +203,10 @@ public Object convert(Property annotation, Object obj, Class<?> propertyFieldTyp
                         }
                     }
                     if(retval == null)
-                        throw new IllegalArgumentException(String.format("failed parsing attribute %s with value %s", propertyName, propertyValue));
+                        throw new IllegalArgumentException(String.format("failed parsing attribute %s with value %s", propertyName, propValue));
                 }
                 else
-                    retval=Util.getAddress(propertyValue, ip_version);
+                    retval=Util.getAddress(propValue, ip_version);
 
                 if(check_scope && retval instanceof Inet6Address && retval.isLinkLocalAddress()) {
                     // check scope
@@ -220,7 +221,7 @@ public Object convert(Property annotation, Object obj, Class<?> propertyFieldTyp
                 }
                 return retval;
             }
-            return propertyValue;
+            return propValue;
         }
 
 

src/org/jgroups/util/Util.java

@@ -2761,6 +2761,12 @@ public static long readDurationLong(String input, TimeUnit unit) {
         return unit.convert(num.multiply(new BigDecimal(tuple.getVal2())).longValue(), TimeUnit.MILLISECONDS);
     }
 
+    public static int readDurationInt(String input, TimeUnit unit) {
+        Tuple<String,Long> tuple=readDuration(input);
+        BigDecimal num = new BigDecimal(tuple.getVal1());
+        return (int)unit.convert(num.multiply(new BigDecimal(tuple.getVal2())).longValue(), TimeUnit.MILLISECONDS);
+    }
+
     private static Tuple<String,Long> readDuration(String input) {
         input=input.trim().toLowerCase();
 

tests/junit-functional/org/jgroups/tests/ConfigTest.java

@@ -0,0 +1,60 @@
+package org.jgroups.tests;
+
+import org.jgroups.Global;
+import org.jgroups.JChannel;
+import org.jgroups.protocols.TCP;
+import org.testng.annotations.Test;
+
+import java.io.*;
+import java.util.Map;
+
+/**
+ * Tests correct parsing of attribute values: https://issues.redhat.com/browse/JGRP-2867
+ * @author Bela Ban
+ * @since  5.4.5, 5.3.16
+ */
+@Test(groups=Global.FUNCTIONAL)
+public class ConfigTest {
+
+    public void test1() throws IOException {
+        File f=generate(Map.of("sock_conn_timeout", "500ms",
+                               "max_send_queue", "1024",
+                               "recv_buf_size", "2m",
+                               "peer_addr_read_timeout", "0.5m"));
+        try(InputStream in=new FileInputStream(f);JChannel ch=new JChannel(in)) {
+            TCP tcp=(TCP)ch.stack().getTransport();
+            int timeout=tcp.getSockConnTimeout();
+            assert timeout == 500;
+            int max_send_queue=tcp.maxSendQueue();
+            assert max_send_queue == 1024;
+            int recv_buf_size=tcp.getRecvBufSize();
+            assert recv_buf_size == 2_000_000;
+            int peer_addr_read_timeout=tcp.getPeerAddrReadTimeout();
+            assert peer_addr_read_timeout == 30_000;
+        }
+        catch(Exception e) {
+            throw new RuntimeException(e);
+        }
+        finally {
+            f.delete();
+        }
+
+    }
+
+    protected static File generate(Map<String,String> attrs) throws IOException {
+        File f=File.createTempFile("config-test", "xml");
+        StringBuilder sb=new StringBuilder("<config>\n  <TCP");
+        if(attrs != null) {
+            for(Map.Entry<String,String> e: attrs.entrySet()) {
+                sb.append(String.format(" %s=\"%s\"", e.getKey(), e.getValue()));
+            }
+        }
+
+        sb.append(" />\n</config>");
+        OutputStream os=new FileOutputStream(f);
+        os.write(sb.toString().getBytes());
+        os.close();
+        return f;
+    }
+
+}