get rid of guava dependency

exchange-common/pom.xml

@@ -24,6 +24,12 @@
             <groupId>com.vesoft</groupId>
             <artifactId>client</artifactId>
             <version>${nebula.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>guava</artifactId>
+                    <groupId>com.google.guava</groupId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>org.locationtech.jts</groupId>

exchange-common/src/main/scala/com/vesoft/exchange/common/GraphProvider.scala

@@ -24,18 +24,14 @@ import scala.collection.mutable.ListBuffer
 /**
   * GraphProvider for Nebula Graph Service
   */
-class GraphProvider(addresses: List[HostAndPort], timeout: Int, sslConfigEntry: SslConfigEntry)
+class GraphProvider(addresses: List[HostAddress], timeout: Int, sslConfigEntry: SslConfigEntry)
     extends AutoCloseable
     with Serializable {
   private[this] lazy val LOG = Logger.getLogger(this.getClass)
 
   @transient val nebulaPoolConfig = new NebulaPoolConfig
   @transient val pool: NebulaPool = new NebulaPool
-  val address                     = new ListBuffer[HostAddress]()
-  for (addr <- addresses) {
-    address.append(new HostAddress(addr.getHost, addr.getPort))
-  }
-  val randAddr = scala.util.Random.shuffle(address)
+  val randAddr = scala.util.Random.shuffle(addresses)
 
   nebulaPoolConfig.setTimeout(timeout)
 

exchange-common/src/main/scala/com/vesoft/exchange/common/MetaProvider.scala

@@ -25,19 +25,14 @@ import scala.collection.mutable.ListBuffer
 /**
   * MetaProvider provide nebula graph meta query operations.
   */
-class MetaProvider(addresses: List[HostAndPort],
+class MetaProvider(addresses: List[HostAddress],
                    timeout: Int,
                    retry: Int,
                    sslConfigEntry: SslConfigEntry)
     extends AutoCloseable
     with Serializable {
   private[this] lazy val LOG = Logger.getLogger(this.getClass)
 
-  val address: ListBuffer[HostAddress] = new ListBuffer[HostAddress]
-  for (addr <- addresses) {
-    address.append(new HostAddress(addr.getHost, addr.getPort))
-  }
-
   private var metaClient: MetaClient = null
   var sslParam: SSLParam             = null
   // com.vesoft.exchange.common.config meta ssl
@@ -49,9 +44,9 @@ class MetaProvider(addresses: List[HostAndPort],
       val self = sslConfigEntry.selfSignParam
       sslParam = new SelfSignedSSLParam(self.crtFilePath, self.keyFilePath, self.password)
     }
-    metaClient = new MetaClient(address.asJava, timeout, retry, retry, true, sslParam)
+    metaClient = new MetaClient(addresses.asJava, timeout, retry, retry, true, sslParam)
   } else {
-    metaClient = new MetaClient(address.asJava, timeout, retry, retry)
+    metaClient = new MetaClient(addresses.asJava, timeout, retry, retry)
   }
 
   metaClient.connect()

exchange-common/src/main/scala/com/vesoft/exchange/common/config/Configs.scala

@@ -7,11 +7,12 @@ package com.vesoft.exchange.common.config
 
 import java.io.{File, InputStreamReader}
 import java.nio.file.Files
-
 import com.google.common.net.HostAndPort
 import com.typesafe.config.{Config, ConfigFactory}
 import com.vesoft.exchange.Argument
 import com.vesoft.exchange.common.KeyPolicy
+import com.vesoft.exchange.common.utils.NebulaUtils
+import com.vesoft.nebula.client.graph.data.HostAddress
 import org.apache.hadoop.conf.Configuration
 import org.apache.hadoop.fs.{FSDataInputStream, FileSystem, Path}
 import org.apache.log4j.Logger
@@ -60,18 +61,18 @@ case class DataBaseConfigEntry(graphAddress: List[String],
 
   override def toString: String = super.toString
 
-  def getGraphAddress: List[HostAndPort] = {
-    val hostAndPorts = new ListBuffer[HostAndPort]
+  def getGraphAddress: List[HostAddress] = {
+    val hostAndPorts = new ListBuffer[HostAddress]
     for (address <- graphAddress) {
-      hostAndPorts.append(HostAndPort.fromString(address))
+      hostAndPorts.append(NebulaUtils.getAddressFromString(address))
     }
     hostAndPorts.toList
   }
 
-  def getMetaAddress: List[HostAndPort] = {
-    val hostAndPorts = new ListBuffer[HostAndPort]
+  def getMetaAddress: List[HostAddress] = {
+    val hostAndPorts = new ListBuffer[HostAddress]
     for (address <- metaAddresses) {
-      hostAndPorts.append(HostAndPort.fromString(address))
+      hostAndPorts.append(NebulaUtils.getAddressFromString(address))
     }
     hostAndPorts.toList
   }

exchange-common/src/main/scala/com/vesoft/exchange/common/utils/NebulaUtils.scala

@@ -5,14 +5,16 @@
 
 package com.vesoft.exchange.common.utils
 
+import com.google.common.base.{CharMatcher, Strings}
+
 import java.nio.charset.Charset
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
-
 import com.google.common.primitives.UnsignedLong
 import com.vesoft.exchange.common.MetaProvider
 import com.vesoft.exchange.common.VidType
 import com.vesoft.exchange.common.config.{SchemaConfigEntry, Type}
+import com.vesoft.nebula.client.graph.data.HostAddress
 import org.apache.commons.codec.digest.MurmurHash2
 import org.apache.log4j.Logger
 
@@ -121,4 +123,62 @@ object NebulaUtils {
     }
     propNames.toList
   }
+
+  def getAddressFromString(addr: String): HostAddress = {
+    if (addr == null) {
+      throw new IllegalArgumentException("wrong address format.")
+    }
+    var host: String       = null
+    var portString: String = null
+
+    if (addr.startsWith("[")) {
+      val hostAndPort = getHostAndPortFromBracketedHost(addr)
+      host = hostAndPort._1
+      portString = hostAndPort._2
+    } else {
+      val colonPos = addr.indexOf(":")
+      if (colonPos >= 0 && addr.indexOf(":", colonPos + 1) == -1) {
+        host = addr.substring(0, colonPos)
+        portString = addr.substring(colonPos + 1)
+      } else {
+        host = addr
+      }
+    }
+
+    var port = -1;
+    if (!Strings.isNullOrEmpty(portString)) {
+      for (c <- portString.toCharArray) {
+        if (!Character.isDigit(c)) {
+          throw new IllegalArgumentException(s"Port must be numeric: $addr")
+        }
+      }
+      port = Integer.parseInt(portString)
+      if (port < 0 || port > 65535) {
+        throw new IllegalArgumentException(s"Port number out of range: $addr")
+      }
+    }
+    new HostAddress(host, port)
+  }
+
+  def getHostAndPortFromBracketedHost(addr: String): (String, String) = {
+    val colonIndex        = addr.indexOf(":")
+    val closeBracketIndex = addr.lastIndexOf("]")
+    if (colonIndex < 0 || closeBracketIndex < colonIndex) {
+      throw new IllegalArgumentException(s"invalid bracketed host/port: $addr")
+    }
+    val host: String = addr.substring(1, closeBracketIndex)
+    if (closeBracketIndex + 1 == addr.length) {
+      return (host, "")
+    } else {
+      if (addr.charAt(closeBracketIndex + 1) != ':') {
+        throw new IllegalArgumentException(s"only a colon may follow a close bracket: $addr")
+      }
+      for (i <- closeBracketIndex + 2 until addr.length) {
+        if (!Character.isDigit(addr.charAt(i))) {
+          throw new IllegalArgumentException(s"Port must be numeric: $addr")
+        }
+      }
+    }
+    (host, addr.substring(closeBracketIndex + 2))
+  }
 }

exchange-common/src/test/scala/com/vesoft/exchange/common/GraphProviderSuite.scala

@@ -7,6 +7,7 @@ package com.vesoft.exchange.common
 
 import com.google.common.net.HostAndPort
 import com.vesoft.exchange.common.config.{SslConfigEntry, SslType, UserConfigEntry}
+import com.vesoft.nebula.client.graph.data.HostAddress
 import com.vesoft.nebula.client.graph.exception.AuthFailedException
 import com.vesoft.nebula.client.graph.net.Session
 import org.junit.{After, Before, Test}
@@ -26,7 +27,7 @@ class GraphProviderSuite {
 
     val sslConfig = SslConfigEntry(false, false, SslType.CA, null, null)
     graphProvider =
-      new GraphProvider(List(HostAndPort.fromParts("127.0.0.1", 9669)), 5000, sslConfig)
+      new GraphProvider(List(new HostAddress("127.0.0.1", 9669)), 5000, sslConfig)
   }
 
   @After

exchange-common/src/test/scala/com/vesoft/exchange/common/MetaProviderSuite.scala

@@ -7,6 +7,7 @@ package com.vesoft.exchange.common
 
 import com.google.common.net.HostAndPort
 import com.vesoft.exchange.common.config.{SslConfigEntry, SslType, Type}
+import com.vesoft.nebula.client.graph.data.HostAddress
 import com.vesoft.nebula.client.meta.exception.ExecuteFailedException
 import org.junit.{After, Before, Test}
 import org.scalatest.Assertions.assertThrows
@@ -22,8 +23,7 @@ class MetaProviderSuite {
     mockData.close()
 
     val sslConfig = SslConfigEntry(false, false, SslType.CA, null, null)
-    metaProvider =
-      new MetaProvider(List(HostAndPort.fromParts("127.0.0.1", 9559)), 5000, 1, sslConfig)
+    metaProvider = new MetaProvider(List(new HostAddress("127.0.0.1", 9559)), 5000, 1, sslConfig)
   }
 
   @After

exchange-common/src/test/scala/com/vesoft/exchange/common/utils/NebulaUtilsSuite.scala

@@ -92,8 +92,8 @@ class NebulaUtilsSuite {
                                       Some(""))
 
     val space   = "test_string"
-    val address = new ListBuffer[HostAndPort]()
-    address.append(HostAndPort.fromParts("127.0.0.1", 9559))
+    val address = new ListBuffer[HostAddress]()
+    address.append(new HostAddress("127.0.0.1", 9559))
     val sslConfig    = SslConfigEntry(false, false, null, null, null)
     val metaProvider = new MetaProvider(address.toList, 6000, 1, sslConfig)
 
@@ -219,4 +219,41 @@ class NebulaUtilsSuite {
     assert("`col2`".equals(escapeName.tail.head))
     assert("`col3`".equals(escapeName.tail.tail.head))
   }
+
+  @Test
+  def getAddressFromString(): Unit = {
+    var addr = "127.0.0.1:9669"
+    var hostAddress = NebulaUtils.getAddressFromString(addr)
+    assert("127.0.0.1".equals(hostAddress.getHost))
+    assert(hostAddress.getPort==9669)
+
+    addr="localhost:9669"
+    hostAddress = NebulaUtils.getAddressFromString(addr)
+    assert("localhost".equals(hostAddress.getHost))
+
+    addr = "www.baidu.com:22"
+    hostAddress = NebulaUtils.getAddressFromString(addr)
+    assert(hostAddress.getPort==22)
+
+    addr = "[2023::2]:65535"
+    hostAddress = NebulaUtils.getAddressFromString(addr)
+    assert(hostAddress.getPort == 65535)
+
+    addr = "2023::3"
+    hostAddress = NebulaUtils.getAddressFromString(addr)
+    assert(hostAddress.getHost.equals("2023::3"))
+    assert(hostAddress.getPort== -1)
+
+    // bad address
+    addr = "localhost:65536"
+    assertThrows[IllegalArgumentException](NebulaUtils.getAddressFromString(addr))
+    addr = "localhost:-1"
+    assertThrows[IllegalArgumentException](NebulaUtils.getAddressFromString(addr))
+    addr = "[localhost]:9669"
+    assertThrows[IllegalArgumentException](NebulaUtils.getAddressFromString(addr))
+    addr = "www.baidu.com:+25"
+    assertThrows[IllegalArgumentException](NebulaUtils.getAddressFromString(addr))
+    addr = "[]:8080"
+    assertThrows[IllegalArgumentException](NebulaUtils.getAddressFromString(addr))
+  }
 }