fix issue #3289. enhance tagRoute: support ip expression match

LICENSE

@@ -220,3 +220,8 @@ This product contains a modified portion of 'Netty', an event-driven asynchronou
  * io.netty.util.Timeout
  * io.netty.util.HashedWheelTimer
 
+For the org.apache.dubbo.common.utils.CIDRUtils :
+
+This product contains a modified portion of 'edazdarevic.commons.net.CIDRUtils',
+ under a "MIT License" license, see https://github.com/edazdarevic/CIDRUtils/blob/master/CIDRUtils.java
+

dubbo-cluster/src/main/java/org/apache/dubbo/rpc/cluster/router/tag/TagRouter.java

@@ -21,6 +21,7 @@
 import org.apache.dubbo.common.logger.Logger;
 import org.apache.dubbo.common.logger.LoggerFactory;
 import org.apache.dubbo.common.utils.CollectionUtils;
+import org.apache.dubbo.common.utils.NetUtils;
 import org.apache.dubbo.common.utils.StringUtils;
 import org.apache.dubbo.configcenter.ConfigChangeEvent;
 import org.apache.dubbo.configcenter.ConfigChangeType;
@@ -34,6 +35,7 @@
 import org.apache.dubbo.rpc.cluster.router.tag.model.TagRouterRule;
 import org.apache.dubbo.rpc.cluster.router.tag.model.TagRuleParser;
 
+import java.net.UnknownHostException;
 import java.util.List;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -143,10 +145,10 @@ public <T> List<Invoker<T>> route(List<Invoker<T>> invokers, URL url, Invocation
 
     /**
      * If there's no dynamic tag rule being set, use static tag in URL.
-     *
+     * <p>
      * A typical scenario is a Consumer using version 2.7.x calls Providers using version 2.6.x or lower,
      * the Consumer should always respect the tag in provider URL regardless of whether a dynamic tag rule has been set to it or not.
-     *
+     * <p>
      * TODO, to guarantee consistent behavior of interoperability between 2.6- and 2.7+, this method should has the same logic with the TagRouter in 2.6.x.
      *
      * @param invokers
@@ -199,11 +201,26 @@ private <T> List<Invoker<T>> filterInvoker(List<Invoker<T>> invokers, Predicate<
     }
 
     private boolean addressMatches(URL url, List<String> addresses) {
-        return addresses != null && addresses.contains(url.getAddress());
+        return addresses != null && checkAddressMatch(addresses, url.getAddress());
     }
 
     private boolean addressNotMatches(URL url, List<String> addresses) {
-        return addresses == null || !addresses.contains(url.getAddress());
+        return addresses == null || !checkAddressMatch(addresses, url.getAddress());
+    }
+
+    private boolean checkAddressMatch(List<String> addresses, String targetAddress) {
+        for (String address : addresses) {
+            try {
+                if (NetUtils.matchIpExpression(address, targetAddress)) {
+                    return true;
+                }
+            } catch (UnknownHostException e) {
+                logger.error("The format of ip address is invalid in tag route. Address :" + address, e);
+            } catch (Exception e) {
+                logger.error("The format of ip address is invalid in tag route. Address :" + address, e);
+            }
+        }
+        return false;
     }
 
     public void setApplication(String app) {

dubbo-common/src/main/java/org/apache/dubbo/common/utils/CIDRUtils.java

@@ -0,0 +1,140 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2013 Edin Dazdarevic (edin.dazdarevic@gmail.com)
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **/
+package org.apache.dubbo.common.utils;
+
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A class that enables to get an IP range from CIDR specification. It supports
+ * both IPv4 and IPv6.
+ * <p>
+ * From https://github.com/edazdarevic/CIDRUtils/blob/master/CIDRUtils.java
+ */
+public class CIDRUtils {
+    private final String cidr;
+
+    private InetAddress inetAddress;
+    private InetAddress startAddress;
+    private InetAddress endAddress;
+    private final int prefixLength;
+
+
+    public CIDRUtils(String cidr) throws UnknownHostException {
+
+        this.cidr = cidr;
+
+        /* split CIDR to address and prefix part */
+        if (this.cidr.contains("/")) {
+            int index = this.cidr.indexOf("/");
+            String addressPart = this.cidr.substring(0, index);
+            String networkPart = this.cidr.substring(index + 1);
+
+            inetAddress = InetAddress.getByName(addressPart);
+            prefixLength = Integer.parseInt(networkPart);
+
+            calculate();
+        } else {
+            throw new IllegalArgumentException("not an valid CIDR format!");
+        }
+    }
+
+
+    private void calculate() throws UnknownHostException {
+
+        ByteBuffer maskBuffer;
+        int targetSize;
+        if (inetAddress.getAddress().length == 4) {
+            maskBuffer =
+                    ByteBuffer
+                            .allocate(4)
+                            .putInt(-1);
+            targetSize = 4;
+        } else {
+            maskBuffer = ByteBuffer.allocate(16)
+                    .putLong(-1L)
+                    .putLong(-1L);
+            targetSize = 16;
+        }
+
+        BigInteger mask = (new BigInteger(1, maskBuffer.array())).not().shiftRight(prefixLength);
+
+        ByteBuffer buffer = ByteBuffer.wrap(inetAddress.getAddress());
+        BigInteger ipVal = new BigInteger(1, buffer.array());
+
+        BigInteger startIp = ipVal.and(mask);
+        BigInteger endIp = startIp.add(mask.not());
+
+        byte[] startIpArr = toBytes(startIp.toByteArray(), targetSize);
+        byte[] endIpArr = toBytes(endIp.toByteArray(), targetSize);
+
+        this.startAddress = InetAddress.getByAddress(startIpArr);
+        this.endAddress = InetAddress.getByAddress(endIpArr);
+
+    }
+
+    private byte[] toBytes(byte[] array, int targetSize) {
+        int counter = 0;
+        List<Byte> newArr = new ArrayList<Byte>();
+        while (counter < targetSize && (array.length - 1 - counter >= 0)) {
+            newArr.add(0, array[array.length - 1 - counter]);
+            counter++;
+        }
+
+        int size = newArr.size();
+        for (int i = 0; i < (targetSize - size); i++) {
+
+            newArr.add(0, (byte) 0);
+        }
+
+        byte[] ret = new byte[newArr.size()];
+        for (int i = 0; i < newArr.size(); i++) {
+            ret[i] = newArr.get(i);
+        }
+        return ret;
+    }
+
+    public String getNetworkAddress() {
+
+        return this.startAddress.getHostAddress();
+    }
+
+    public String getBroadcastAddress() {
+        return this.endAddress.getHostAddress();
+    }
+
+    public boolean isInRange(String ipAddress) throws UnknownHostException {
+        InetAddress address = InetAddress.getByName(ipAddress);
+        BigInteger start = new BigInteger(1, this.startAddress.getAddress());
+        BigInteger end = new BigInteger(1, this.endAddress.getAddress());
+        BigInteger target = new BigInteger(1, address.getAddress());
+
+        int st = start.compareTo(target);
+        int te = target.compareTo(end);
+
+        return (st == -1 || st == 0) && (te == -1 || te == 0);
+    }
+}

dubbo-common/src/main/java/org/apache/dubbo/common/utils/NetUtils.java

@@ -340,13 +340,13 @@ public static String toURL(String protocol, String host, int port, String path)
         return sb.toString();
     }
 
-    public static void joinMulticastGroup (MulticastSocket multicastSocket, InetAddress multicastAddress) throws IOException {
+    public static void joinMulticastGroup(MulticastSocket multicastSocket, InetAddress multicastAddress) throws IOException {
         setInterface(multicastSocket, multicastAddress instanceof Inet6Address);
         multicastSocket.setLoopbackMode(false);
         multicastSocket.joinGroup(multicastAddress);
     }
 
-    public static void setInterface (MulticastSocket multicastSocket, boolean preferIpv6) throws IOException{
+    public static void setInterface(MulticastSocket multicastSocket, boolean preferIpv6) throws IOException {
         boolean interfaceSet = false;
         Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
         while (interfaces.hasMoreElements()) {
@@ -370,4 +370,71 @@ public static void setInterface (MulticastSocket multicastSocket, boolean prefer
         }
     }
 
+    public static boolean matchIpExpression(String pattern, String address) throws UnknownHostException {
+
+        if (pattern.contains("/")) {
+            CIDRUtils utils = new CIDRUtils(pattern);
+            return utils.isInRange(address);
+        }
+
+
+        return matchIpRange(pattern, address);
+    }
+
+    public static boolean matchIpRange(String pattern, String address) throws UnknownHostException {
+        if (pattern.equals("*.*.*.*") || pattern.equals("*")) {
+            return true;
+        }
+
+        InetAddress inetAddress = InetAddress.getByName(address);
+        boolean isIpv4 = isValidV4Address(inetAddress) ? true : false;
+        String splitCharacter = "\\.";
+        String[] mask;
+        if (!isIpv4) {
+            splitCharacter = ":";
+            //check format of pattern
+            mask = pattern.split(splitCharacter);
+            if (mask.length != 8 && pattern.contains("*")) {
+                throw new IllegalArgumentException("If you config ip expression that contains '*', please fill qulified ip pattern like 234e:0:4567:0:0:0:3d:*. ");
+            }
+        } else {
+            mask = pattern.split(splitCharacter);
+        }
+
+        address = inetAddress.getHostAddress();
+
+        String[] ip_address = address.split(splitCharacter);
+        if (pattern.equals(address)) {
+            return true;
+        }
+        for (int i = 0; i < mask.length; i++) {
+            if (mask[i].equals("*") || mask[i].equals(ip_address[i])) {
+                continue;
+            } else if (mask[i].contains("-")) {
+                String[] rangeNumStrs = mask[i].split("-");
+                if (rangeNumStrs.length != 2) {
+                    throw new IllegalArgumentException("There are wrong format of ip Address: " + mask[i]);
+                }
+                Integer min = getNumOfIpSegment(rangeNumStrs[0], isIpv4);
+                Integer max = getNumOfIpSegment(rangeNumStrs[1], isIpv4);
+                Integer ip = getNumOfIpSegment(ip_address[i], isIpv4);
+                if (ip < min || ip > max) {
+                    return false;
+                }
+            } else if ("0".equals(ip_address[i]) && ("0".equals(mask[i]) || "00".equals(mask[i]) || "000".equals(mask[i]) || "0000".equals(mask[i]))) {
+                continue;
+            } else if (!mask[i].equals(ip_address[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static Integer getNumOfIpSegment(String ipSegment, boolean isIpv4) {
+        if (isIpv4) {
+            return Integer.parseInt(ipSegment);
+        }
+        return Integer.parseInt(ipSegment, 16);
+    }
+
 }

dubbo-common/src/test/java/org/apache/dubbo/common/utils/CIDRUtilsTest.java

@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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.apache.dubbo.common.utils;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.net.UnknownHostException;
+
+/**
+ * @author cvictory ON 2019-02-28
+ */
+public class CIDRUtilsTest {
+
+    @Test
+    public void testIpv4() throws UnknownHostException {
+        CIDRUtils cidrUtils = new CIDRUtils("192.168.1.0/26");
+        Assertions.assertTrue(cidrUtils.isInRange("192.168.1.63"));
+        Assertions.assertFalse(cidrUtils.isInRange("192.168.1.65"));
+
+        cidrUtils = new CIDRUtils("192.168.1.192/26");
+        Assertions.assertTrue(cidrUtils.isInRange("192.168.1.199"));
+        Assertions.assertFalse(cidrUtils.isInRange("192.168.1.190"));
+    }
+
+    @Test
+    public void testIpv6() throws UnknownHostException {
+        CIDRUtils cidrUtils = new CIDRUtils("234e:0:4567::3d/64");
+        Assertions.assertTrue(cidrUtils.isInRange("234e:0:4567::3e"));
+        Assertions.assertTrue(cidrUtils.isInRange("234e:0:4567::ffff:3e"));
+        Assertions.assertFalse(cidrUtils.isInRange("234e:1:4567::3d"));
+        Assertions.assertFalse(cidrUtils.isInRange("234e:0:4567:1::3d"));
+
+        cidrUtils = new CIDRUtils("3FFE:FFFF:0:CC00::/54");
+        Assertions.assertTrue(cidrUtils.isInRange("3FFE:FFFF:0:CC00::dd"));
+        Assertions.assertTrue(cidrUtils.isInRange("3FFE:FFFF:0:CC00:0000:eeee:0909:dd"));
+        Assertions.assertTrue(cidrUtils.isInRange("3FFE:FFFF:0:CC0F:0000:eeee:0909:dd"));
+
+        Assertions.assertFalse(cidrUtils.isInRange("3EFE:FFFE:0:C107::dd"));
+        Assertions.assertFalse(cidrUtils.isInRange("1FFE:FFFE:0:CC00::dd"));
+    }
+}