protect AsyncSocketImpl.channel lateinit var

Author: ekoby

ziti/src/integrationTest/kotlin/org/openziti/net/ConnectionTests.kt

@@ -216,4 +216,10 @@ class ConnectionTests: BaseTest() {
         }
     }
 
+    @Test
+    fun closeUnconnectedSocket() = runTest(timeout = 1.seconds) {
+        val sock = Ziti.getSocketFactory().createSocket()
+        sock.close()
+        assertTrue(sock.isClosed)
+    }
 }

ziti/src/main/kotlin/org/openziti/net/nio/AsychChannelSocket.kt

@@ -41,14 +41,11 @@ class AsychChannelSocket(internal val impl: AsyncSocketImpl = AsyncSocketImpl())
         connect(InetSocketAddress(address, port))
     }
 
-    override fun isConnected(): Boolean {
-        return impl.channel.remoteAddress != null
-    }
-
-    override fun isClosed(): Boolean = !impl.channel.isOpen
+    override fun isConnected(): Boolean = impl.isConnected()
+    override fun isClosed(): Boolean = impl.isClosed()
 
     override fun close() {
-        impl.channel.close()
+        impl.closeInternal()
     }
 
     override fun getInputStream(): InputStream {

ziti/src/main/kotlin/org/openziti/net/nio/AsyncSocketImpl.kt

@@ -177,9 +177,14 @@ internal class AsyncSocketImpl(private val connector: Connector = DefaultConnect
         }
     }
 
-    override fun close() {
-        if (::channel.isInitialized)
-            channel.close()
+    internal fun isConnected(): Boolean = ::channel.isInitialized && channel.remoteAddress != null
+    fun isClosed(): Boolean = ::channel.isInitialized && !channel.isOpen
+
+    override fun close() = closeInternal()
+    internal fun closeInternal() {
+        if (!::channel.isInitialized)
+            channel = AsynchronousSocketChannel.open()
+        channel.close()
     }
 
     override fun getOption(optID: Int): Any? {

ziti/src/test/kotlin/org/openziti/net/ZitiSocketFactoryTest.kt

@@ -16,95 +16,19 @@
 
 package org.openziti.net
 
-import com.google.gson.Gson
-import com.google.gson.JsonObject
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.runBlocking
-import okhttp3.*
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.RequestBody.Companion.toRequestBody
-import org.junit.Assume
-import org.junit.BeforeClass
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.openziti.Ziti
-import org.openziti.Ziti.getDNSResolver
-import org.openziti.ZitiContext
-import java.net.InetAddress
-import java.security.KeyStore
-import java.util.concurrent.TimeUnit
-import javax.net.ssl.TrustManagerFactory
-import javax.net.ssl.X509TrustManager
+import kotlin.time.Duration.Companion.seconds
 
 
 class ZitiSocketFactoryTest {
 
-    companion object {
-        lateinit var ctx: ZitiContext
-        lateinit var tm: X509TrustManager
-        lateinit var dns: Dns
-        @BeforeClass
-        @JvmStatic
-        fun setup() {
-            val path = System.getProperty("test.identity")
-            Assume.assumeNotNull(path)
-
-            ctx = Ziti.newContext(path, charArrayOf())
-            val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()).apply {
-                val ks = KeyStore.getInstance(KeyStore.getDefaultType())
-                init(ks)
-            }
-            tm = tmf.trustManagers[0] as X509TrustManager
-
-            dns = object : Dns {
-                override fun lookup(hostname: String): List<InetAddress> =
-                    listOf(getDNSResolver().resolve(hostname) ?: InetAddress.getByName(hostname)).filterNotNull()
-            }
-            runBlocking {
-                delay(4000)
-            }
-        }
-    }
-
-
-    @Test
-    fun testHttpClient() {
-
-        val clt = OkHttpClient.Builder()
-            .socketFactory(Ziti.getSocketFactory())
-            .sslSocketFactory(Ziti.getSSLSocketFactory(), tm)
-            .dns(dns)
-            .callTimeout(5, TimeUnit.MINUTES)
-            .build()
-
-        val req = Request.Builder()
-            .post("this is request body".toRequestBody("text/plain".toMediaType()))
-            .url("http://httpbin.ziti/anything").build()
-        val call = clt.newCall(req)
-        val resp = call.execute()
-        println(resp)
-        println(resp.headers)
-        val respBody = Gson().fromJson(resp.body?.byteStream()?.reader(), JsonObject::class.java)
-        println(respBody)
-    }
-
     @Test
-    fun testConnect() {
-        val req = "GET /json HTTP/1.1\r\n"+
-                "Accept: */*\r\n" +
-                "Accept-Encoding: gzip, deflate\r\n" +
-                "Connection: close\r\n" +
-                "Host: httpbin.org\r\n" +
-                "User-Agent: HTTPie/1.0.2\r\n" +
-                "\r\n"
-
-        val zock = ctx.connect("httpbin.ziti", 80)
-        zock.getOutputStream().writer().apply {
-            write(req)
-            flush()
-        }
-
-        val resp = zock.getInputStream().reader().readLines()
-        assert(resp[0].startsWith("HTTP/1.1 200"))
-        println(resp)
+    fun closeUnconnectedSocket() = runTest(timeout = 1.seconds) {
+        val sock = Ziti.getSocketFactory().createSocket()
+        sock.close()
+        assertTrue(sock.isClosed)
     }
 }