add on/off for network emulator

Signed-off-by: Csaba Kiraly <csaba.kiraly@gmail.com>

libp2pdht/private/eth/p2p/discoveryv5/transport.nim

@@ -20,62 +20,63 @@ const
   responseTimeout* = 4.seconds ## timeout for the response of a request-response
   ## call
 
-type
+when(true): #enable network emulator
-  DatagramCallback* = proc(transp: DatagramTransport,
+  type
-                           remote: TransportAddress): Future[void] {.
+    DatagramCallback* = proc(transp: DatagramTransport,
-                      gcsafe, raises: [Defect].}
+                            remote: TransportAddress): Future[void] {.
+                        gcsafe, raises: [Defect].}
 
-  DatagramTransport = ref object
+    DatagramTransport = ref object
-    udata*: pointer                 # User-driven pointer
+      udata*: pointer                 # User-driven pointer
-    local: TransportAddress         # Local address
+      local: TransportAddress         # Local address
-    function: DatagramCallback      # Receive data callback
+      function: DatagramCallback      # Receive data callback
-    ingress: Deque[seq[byte]]
+      ingress: Deque[seq[byte]]
 
-var network = initTable[Port, DatagramTransport]()
+  var network = initTable[Port, DatagramTransport]()
 
-proc `$`*(transp: DatagramTransport): string =
+  proc `$`*(transp: DatagramTransport): string =
-  $transp.local
+    $transp.local
 
-proc sendTo*[T](transp: DatagramTransport, remote: TransportAddress,
+  proc sendTo*[T](transp: DatagramTransport, remote: TransportAddress,
-             msg: sink seq[T], msglen = -1) {.async.} =
+              msg: sink seq[T], msglen = -1) {.async.} =
-  echo "sending to ", remote
+    #echo "sending to ", remote
-  {.gcsafe.}:
+    {.gcsafe.}:
-    network[remote.port].ingress.addLast(msg)
+      network[remote.port].ingress.addLast(msg)
-    # call the callback on remote
+      # call the callback on remote
-    asyncCheck network[remote.port].function(network[remote.port], transp.local)
+      asyncCheck network[remote.port].function(network[remote.port], transp.local)
 
 
-proc getMessage*(t: DatagramTransport,): seq[byte] {.
+  proc getMessage*(t: DatagramTransport,): seq[byte] {.
-    raises: [Defect, CatchableError].} =
+      raises: [Defect, CatchableError].} =
-  echo "getMessage "
+    #echo "getMessage "
-  t.ingress.popFirst()
+    t.ingress.popFirst()
 
-proc close*(transp: DatagramTransport) =
+  proc close*(transp: DatagramTransport) =
-  echo "close"
+    echo "close"
 
-proc closed*(transp: DatagramTransport): bool {.inline.} =
+  proc closed*(transp: DatagramTransport): bool {.inline.} =
-  result = false
+    result = false
 
-proc closeWait*(transp: DatagramTransport) {.async.} =
+  proc closeWait*(transp: DatagramTransport) {.async.} =
-  echo "closeWait "
+    echo "closeWait "
 
-proc getUserData*[T](transp: DatagramTransport): T {.inline.} =
+  proc getUserData*[T](transp: DatagramTransport): T {.inline.} =
-  ## Obtain user data stored in ``transp`` object.
+    ## Obtain user data stored in ``transp`` object.
-  result = cast[T](transp.udata)
+    result = cast[T](transp.udata)
 
-proc newDatagramTransport*[T](cbproc: DatagramCallback,
+  proc newDatagramTransport*[T](cbproc: DatagramCallback,
-                           udata: ref T,
+                            udata: ref T,
-                           local: TransportAddress = AnyAddress,
+                            local: TransportAddress = AnyAddress,
-                           ): DatagramTransport {.
+                            ): DatagramTransport {.
-    raises: [Defect, CatchableError].} =
+      raises: [Defect, CatchableError].} =
-  echo "new"
+    echo "new"
-  result = DatagramTransport()
+    result = DatagramTransport()
-  GC_ref(udata)
+    GC_ref(udata)
-  result.udata = cast[pointer](udata)
+    result.udata = cast[pointer](udata)
-  result.local = local
+    result.local = local
-  result.function = cbproc
+    result.function = cbproc
-  {.gcsafe.}:
+    {.gcsafe.}:
-    network[local.port] = result
+      network[local.port] = result
 
 
 type