make ssl optional

mainly for grpc insecure connections. It's not supported by web-browsers

src/hyperx/client.nim

@@ -1,5 +1,4 @@
 ## HTTP/2 client
-## WIP
 
 when not defined(ssl):
   {.error: "this lib needs -d:ssl".}
@@ -49,20 +48,22 @@ proc defaultSslContext(): SslContext {.raises: [HyperxConnError].} =
   return sslContext
 
 when not defined(hyperxTest):
-  proc newMySocket(): MyAsyncSocket {.raises: [HyperxConnError].} =
+  proc newMySocket(ssl: bool): MyAsyncSocket {.raises: [HyperxConnError].} =
     try:
       result = newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, buffered = true)
-      wrapSocket(defaultSslContext(), result)
+      if ssl:
+        wrapSocket(defaultSslContext(), result)
     except CatchableError as err:
       debugInfo err.getStackTrace()
       debugInfo err.msg
       raise newHyperxConnError(err.msg)
 
 proc newClient*(
   hostname: string,
-  port = Port 443
+  port = Port 443,
+  ssl = true
 ): ClientContext {.raises: [HyperxConnError].} =
-  newClient(ctClient, newMySocket(), hostname, port)
+  newClient(ctClient, newMySocket(ssl), hostname, port)
 
 type
   HttpMethod* = enum

src/hyperx/clientserver.nim

@@ -1,4 +1,4 @@
-## Functionality shared beetwen client and server
+## Functionality shared between client and server
 
 when not defined(ssl):
   {.error: "this lib needs -d:ssl".}

src/hyperx/server.nim

@@ -1,5 +1,4 @@
 ## HTTP/2 server
-## WIP
 
 when not defined(ssl):
   {.error: "this lib needs -d:ssl".}
@@ -53,12 +52,14 @@ proc defaultSslContext(
 
 when not defined(hyperxTest):
   proc newMySocket(
+    ssl: bool,
     certFile = "",
     keyFile = ""
   ): MyAsyncSocket {.raises: [HyperxConnError].} =
     try:
       result = newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, buffered = true)
-      wrapSocket(defaultSslContext(certFile, keyFile), result)
+      if ssl:
+        wrapSocket(defaultSslContext(certFile, keyFile), result)
     except CatchableError as err:
       debugInfo err.getStackTrace()
       debugInfo err.msg
@@ -75,10 +76,12 @@ proc newServer*(
   hostname: string,
   port: Port,
   sslCertFile = "",
-  sslKeyFile = ""
+  sslKeyFile = "",
+  ssl = true
 ): ServerContext =
   ServerContext(
     sock: newMySocket(
+      ssl,
       certFile = sslCertFile,
       keyFile = sslKeyFile
     ),
@@ -118,11 +121,12 @@ proc recvClient*(server: ServerContext): Future[ClientContext] {.async.} =
   try:
     # note OptNoDelay is inherited from server.sock
     let sock = await server.sock.accept()
-    when not defined(hyperxTest):
-      doAssert not sslContext.isNil
-    wrapConnectedSocket(
-      sslContext, sock, handshakeAsServer, server.hostname
-    )
+    if server.sock.isSsl:
+      when not defined(hyperxTest):
+        doAssert not sslContext.isNil
+      wrapConnectedSocket(
+        sslContext, sock, handshakeAsServer, server.hostname
+      )
     result = newClient(ctServer, sock, server.hostname)
   except CatchableError as err:
     debugInfo err.getStackTrace()

src/hyperx/testsocket.nim

@@ -17,8 +17,9 @@ type
     isConnected*: bool
     hostname*: string
     port*: Port
+    isSsl*: bool
 
-proc newMySocket*(certFile = "", keyFile = ""): TestSocket =
+proc newMySocket*(ssl: bool, certFile = "", keyFile = ""): TestSocket =
   TestSocket(
     recvData: newQueue[seq[byte]](1000),
     sentData: newQueue[seq[byte]](1000),
@@ -28,7 +29,8 @@ proc newMySocket*(certFile = "", keyFile = ""): TestSocket =
     sentIdx: 0,
     isConnected: false,
     hostname: "",
-    port: Port 0
+    port: Port 0,
+    isSsl: ssl
   )
 
 proc putRecvData*(s: TestSocket, data: seq[byte]) {.async.} =
@@ -108,7 +110,7 @@ proc listen*(s: TestSocket) =
   s.isConnected = true
 
 proc accept*(s: TestSocket): Future[TestSocket] {.async.} =
-  result = newMySocket()
+  result = newMySocket(s.isSsl)
   result.isConnected = true
 
 proc wrapConnectedSocket*(