Merge pull request #4733 from cheatfate/asyncssl_and_tests

async: small ssl fix and updated tests

lib/pure/asyncnet.nim

@@ -165,9 +165,14 @@ when defineSsl:
       await sendPendingSslData(socket, flags)
     of SSL_ERROR_WANT_READ:
       var data = await recv(socket.fd.AsyncFD, BufferSize, flags)
+      let length = len(data)
+      if length > 0:
         let ret = bioWrite(socket.bioIn, addr data[0], data.len.cint)
         if ret < 0:
           raiseSSLError()
+      elif length == 0:
+        # connection not properly closed by remote side or connection dropped
+        SSL_set_shutdown(socket.sslHandle, SSL_RECEIVED_SHUTDOWN)
     else:
       raiseSSLError("Cannot appease SSL.")
 

tests/async/tasyncdiscard.nim

@@ -10,7 +10,7 @@ discard """
 6
 '''
 """
-import asyncio, asyncdispatch, asyncnet
+import asyncdispatch, asyncnet
 
 proc main {.async.} =
   proc f: Future[int] {.async.} =

tests/async/tasynciossl.nim

@@ -1,92 +0,0 @@
-discard """
-  file: "tasynciossl.nim"
-  cmd: "nim $target --hints:on --define:ssl $options $file"
-  output: "20000"
-"""
-import sockets, asyncio, strutils, times
-
-var disp {.threadvar.}: PDispatcher
-disp = newDispatcher()
-var msgCount = 0
-
-when defined(ssl):
-  var ctx = newContext(verifyMode = CVerifyNone,
-      certFile = "tests/testdata/mycert.pem", keyFile = "tests/testdata/mycert.pem")
-
-  var ctx1 = newContext(verifyMode = CVerifyNone)
-
-const
-  swarmSize = 50
-  messagesToSend = 100
-
-proc swarmConnect(s: PAsyncSocket) =
-  #echo("Connected")
-  for i in 1..messagesToSend:
-    s.send("Message " & $i & "\c\L")
-  s.close()
-
-proc serverRead(s: PAsyncSocket) =
-  var line = ""
-  assert s.readLine(line)
-  if line != "":
-    #echo(line)
-    if line.startsWith("Message "):
-      msgCount.inc()
-    else:
-      assert(false)
-  else:
-    s.close()
-
-proc serverAccept(s: PAsyncSocket) =
-  var client: PAsyncSocket
-  new(client)
-  s.accept(client)
-  client.handleRead = serverRead
-  disp.register(client)
-
-proc launchSwarm(disp: var PDispatcher, port: TPort, count: int,
-                 buffered = true, useSSL = false) =
-  for i in 1..count:
-    var client = asyncSocket()
-    when defined(ssl):
-      if useSSL:
-        ctx1.wrapSocket(client)
-    client.handleConnect = swarmConnect
-    disp.register(client)
-    client.connect("localhost", port)
-
-proc createSwarm(port: TPort, buffered = true, useSSL = false) =
-  var server = asyncSocket()
-  when defined(ssl):
-    if useSSL:
-      ctx.wrapSocket(server)
-  server.handleAccept = serverAccept
-  disp.register(server)
-  server.bindAddr(port)
-  server.listen()
-  disp.launchSwarm(port, swarmSize, buffered, useSSL)
-
-when defined(ssl):
-  const serverCount = 4
-else:
-  const serverCount = 2
-
-createSwarm(TPort(10235))
-createSwarm(TPort(10236), false)
-
-when defined(ssl):
-  createSwarm(TPort(10237), true, true)
-  createSwarm(TPort(10238), false, true)
-
-var startTime = epochTime()
-while true:
-  if epochTime() - startTime >= 300.0:
-    break
-  if not disp.poll(): break
-  if disp.len == serverCount:
-    # Only the servers are left in the dispatcher. All clients finished,
-    # we need to therefore break.
-    break
-
-assert msgCount == (swarmSize * messagesToSend) * serverCount
-echo(msgCount)

tests/async/tasyncssl.nim

@@ -0,0 +1,66 @@
+discard """
+  file: "tasyncssl.nim"
+  cmd: "nim $target --hints:on --define:ssl $options $file"
+  output: "500"
+"""
+import asyncdispatch, asyncnet, net, strutils, os
+
+when defined(ssl):
+  var msgCount = 0
+
+  const
+    swarmSize = 10
+    messagesToSend = 50
+
+  var clientCount = 0
+
+  proc sendMessages(client: AsyncSocket) {.async.} =
+    for i in 0 .. <messagesToSend:
+      await send(client, "Message " & $i & "\c\L")
+
+  proc launchSwarm(port: Port) {.async.} =
+    for i in 0 .. <swarmSize:
+      var sock = newAsyncSocket()
+      var clientContext = newContext(verifyMode = CVerifyNone)
+      clientContext.wrapSocket(sock)
+      await connect(sock, "localhost", port)
+      await sendMessages(sock)
+      close(sock)
+
+  proc readMessages(client: AsyncSocket) {.async.} =
+    while true:
+      var line = await recvLine(client)
+      if line == "":
+        close(client)
+        inc(clientCount)
+        break
+      else:
+        if line.startswith("Message "):
+          inc(msgCount)
+        else:
+          doAssert false
+
+  proc createServer(port: Port) {.async.} =
+    let serverContext = newContext(verifyMode = CVerifyNone,
+                                   certFile = "tests/testdata/mycert.pem",
+                                   keyFile = "tests/testdata/mycert.pem")
+    var server = newAsyncSocket()
+    serverContext.wrapSocket(server)
+    server.setSockOpt(OptReuseAddr, true)
+    bindAddr(server, port)
+    server.listen()
+    while true:
+      let client = await accept(server)
+      serverContext.wrapConnectedSocket(client, handshakeAsServer)
+      asyncCheck readMessages(client)
+
+  asyncCheck createServer(Port(10335))
+  asyncCheck launchSwarm(Port(10335))
+  while true:
+    poll()
+    if clientCount == swarmSize: break
+
+  assert msgCount == swarmSize * messagesToSend
+  echo msgCount
+
+

tests/async/tasyncudp.nim

@@ -1,78 +0,0 @@
-discard """
-  file: "tasyncudp.nim"
-  output: "2000"
-"""
-import asyncio, sockets, strutils, times
-
-const
-  swarmSize = 5
-  messagesToSend = 200
-
-var
-  disp = newDispatcher()
-  msgCount = 0
-  currentClient = 0
-
-proc serverRead(s: PAsyncSocket) =
-  var data = ""
-  var address = ""
-  var port: TPort
-  if s.recvFromAsync(data, 9, address, port):
-    assert address == "127.0.0.1"
-    msgCount.inc()
-
-  discard """
-
-  var line = ""
-  assert s.recvLine(line)
-
-  if line == "":
-    assert(false)
-  else:
-    if line.startsWith("Message "):
-      msgCount.inc()
-    else:
-      assert(false)
-  """
-
-proc swarmConnect(s: PAsyncSocket) =
-  for i in 1..messagesToSend:
-    s.send("Message\c\L")
-
-proc createClient(disp: var PDispatcher, port: TPort,
-                  buffered = true) =
-  currentClient.inc()
-  var client = asyncSocket(typ = SOCK_DGRAM, protocol = IPPROTO_UDP,
-                           buffered = buffered)
-  client.handleConnect = swarmConnect
-  disp.register(client)
-  client.connect("localhost", port)
-
-proc createServer(port: TPort, buffered = true) =
-  var server = asyncSocket(typ = SOCK_DGRAM, protocol = IPPROTO_UDP,
-                           buffered = buffered)
-  server.handleRead = serverRead
-  disp.register(server)
-  server.bindAddr(port)
-
-let serverCount = 2
-
-createServer(TPort(10335), false)
-createServer(TPort(10336), true)
-var startTime = epochTime()
-while true:
-  if epochTime() - startTime >= 300.0:
-    break
-
-  if not disp.poll():
-    break
-
-  if (msgCount div messagesToSend) * serverCount == currentClient:
-    createClient(disp, TPort(10335), false)
-    createClient(disp, TPort(10336), true)
-
-  if msgCount == messagesToSend * serverCount * swarmSize:
-    break
-
-assert msgCount == messagesToSend * serverCount * swarmSize
-echo(msgCount)