Implement isConnected method

json_rpc/client.nim

@@ -137,6 +137,9 @@ method call*(client: RpcClient, name: string,
 
   await client.call(name, params.paramsTx)
 
+method isConnected*(client: RpcClient): bool {.base, gcsafe.} =
+  doAssert(false, "`RpcClient.isConnected` not implemented")
+
 method close*(client: RpcClient): Future[void] {.base, gcsafe, async.} =
   doAssert(false, "`RpcClient.close` not implemented")
 

json_rpc/clients/httpclient.nim

@@ -220,8 +220,12 @@ proc connect*(client: RpcHttpClient, address: string, port: Port, secure: bool)
   else:
     raise newException(RpcAddressUnresolvableError, res.error)
 
+method isConnected*(client: RpcHttpClient): bool =
+  (not client.httpSession.isNil()) and client.httpAddress.isOk()
+
 method close*(client: RpcHttpClient) {.async.} =
   if not client.httpSession.isNil:
     await client.httpSession.closeWait()
+    client.httpSession = nil
 
 {.pop.}

json_rpc/clients/socketclient.nim

@@ -80,6 +80,7 @@ method callBatch*(client: RpcSocketClient,
 proc processData(client: RpcSocketClient) {.async: (raises: []).} =
   while true:
     var localException: ref JsonRpcError
+    var stopping = false
     while true:
       try:
         var value = await client.transport.readLine(defaultMaxRequestLength)
@@ -99,6 +100,7 @@ proc processData(client: RpcSocketClient) {.async: (raises: []).} =
         break
       except CancelledError as exc:
         localException = newException(JsonRpcError, exc.msg)
+        stopping = true
         await client.transport.closeWait()
         break
 
@@ -108,6 +110,9 @@ proc processData(client: RpcSocketClient) {.async: (raises: []).} =
       if client.batchFut.isNil.not and not client.batchFut.completed():
         client.batchFut.fail(localException)
 
+    if stopping:
+      break
+
     # async loop reconnection and waiting
     try:
       info "Reconnect to server", address=`$`(client.address)
@@ -130,8 +135,11 @@ proc connect*(client: RpcSocketClient, address: TransportAddress) {.async.} =
   client.address = address
   client.loop = processData(client)
 
+method isConnected*(client: RpcSocketClient): bool =
+  not client.transport.isNil()
+
 method close*(client: RpcSocketClient) {.async.} =
   await client.loop.cancelAndWait()
   if not client.transport.isNil:
-    client.transport.close()
+    await client.transport.closeWait()
     client.transport = nil

json_rpc/clients/websocketclientimpl.nim

@@ -148,6 +148,9 @@ proc connect*(
   client.uri = uri
   client.loop = processData(client)
 
+method isConnected*(client: RpcWebSocketClient): bool =
+  not client.transport.isNil()
+
 method close*(client: RpcWebSocketClient) {.async.} =
   await client.loop.cancelAndWait()
   if not client.transport.isNil:

tests/testhttp.nim

@@ -28,7 +28,7 @@ proc continuousTest(address: string): Future[int] {.async.} =
     var r = await client.call("myProc", %[%"abc", %[1, 2, 3, i]])
     if r.string == "\"Hello abc data: [1, 2, 3, " & $i & "]\"":
       result += 1
-    await client.close()
+  await client.close()
 
 proc invalidTest(address: string): Future[bool] {.async.} =
   var client = newRpcHttpClient()

tests/testhttps.nim

@@ -88,7 +88,7 @@ proc continuousTest(address: string): Future[int] {.async.} =
     var r = await client.call("myProc", %[%"abc", %[1, 2, 3, i]])
     if r.string == "\"Hello abc data: [1, 2, 3, " & $i & "]\"":
       result += 1
-    await client.close()
+  await client.close()
 
 proc invalidTest(address: string): Future[bool] {.async.} =
   var client = newRpcHttpClient(secure=true)

tests/testserverclient.nim

@@ -49,9 +49,51 @@ suite "Socket Server/Client RPC":
     except CatchableError as e:
       check e.msg == """{"code":-32001,"message":"Unknown payload"}"""
 
+  test "Client close and isConnected":
+    check client.isConnected() == true
+    # Is socket server close broken?
+    waitFor client.close()
+    check client.isConnected() == false
+
   srv.stop()
   waitFor srv.closeWait()
 
+suite "HTTP Server/Client RPC":
+  var srv = newRpcHttpServer([initTAddress("127.0.0.1", Port(0))])
+  var client = newRpcHttpClient()
+
+  echo "address: ", $srv.localAddress()
+  srv.setupServer()
+  srv.start()
+  waitFor client.connect("http://" & $(srv.localAddress()[0]))
+
+  test "Successful RPC call":
+    let r = waitFor client.call("myProc", %[%"abc", %[1, 2, 3, 4]])
+    check r.string == "\"Hello abc data: [1, 2, 3, 4]\""
+
+  test "Missing params":
+    expect(CatchableError):
+      discard waitFor client.call("myProc", %[%"abc"])
+
+  test "Error RPC call":
+    expect(CatchableError): # The error type wont be translated
+      discard waitFor client.call("myError", %[%"abc", %[1, 2, 3, 4]])
+
+  test "Invalid request exception":
+    try:
+      discard waitFor client.call("invalidRequest", %[])
+      check false
+    except CatchableError as e:
+      check e.msg == """{"code":-32001,"message":"Unknown payload"}"""
+
+  test "Client close and isConnected":
+    check client.isConnected() == true
+    waitFor client.close()
+    check client.isConnected() == false
+
+  waitFor srv.stop()
+  waitFor srv.closeWait()
+
 suite "Websocket Server/Client RPC":
   var srv = newRpcWebSocketServer("127.0.0.1", Port(0))
   var client = newRpcWebSocketClient()
@@ -79,6 +121,11 @@ suite "Websocket Server/Client RPC":
     except CatchableError as e:
       check e.msg == """{"code":-32001,"message":"Unknown payload"}"""
 
+  test "Client close and isConnected":
+    check client.isConnected() == true
+    waitFor client.close()
+    check client.isConnected() == false
+
   srv.stop()
   waitFor srv.closeWait()
 
@@ -111,16 +158,21 @@ suite "Websocket Server/Client RPC with Compression":
     except CatchableError as e:
       check e.msg == """{"code":-32001,"message":"Unknown payload"}"""
 
+  test "Client close and isConnected":
+    check client.isConnected() == true
+    waitFor client.close()
+    check client.isConnected() == false
+
   srv.stop()
   waitFor srv.closeWait()
 
 suite "Custom processClient":
   test "Should be able to use custom processClient":
     var wasCalled: bool = false
-    
+
     proc processClientHook(server: StreamServer, transport: StreamTransport) {.async: (raises: []), gcsafe.} =
       wasCalled = true
-    
+
     var srv = newRpcSocketServer(processClientHook)
     srv.addStreamServer("localhost", Port(8888))
     var client = newRpcSocketClient()