multiasync eedee

import nativesockets
import asyncdispatch
import net

const content = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
const response = "HTTP/1.1 200 OK\r\LContent-Length: " & $content.len & "\r\LConnection:keep-alive\r\L\r\L" & content

proc Idle() {.async.} =
    while true:
        await sleepAsync(100)

type
    MultiAsyncCore = ref object
        Workers: seq[Worker]
        Listener: Socket


    Worker = ref object
        SockChan: Channel[Socket]
        FCore: MultiAsyncCore


proc NewMultiAsyncCore*(port: int, address = "127.0.0.1"): MultiAsyncCore =
    var fcb = MultiAsyncCore()
    fcb.Workers = @[]

    fcb.Listener = newSocket()
    fcb.Listener.bindAddr(Port(port), address)
    fcb.Listener.listen()

    #GC_unref(fcb)-
    #GC_unref(fcb.Listener)
    #GC_unref(fcb.Workers)
    return fcb

proc NewWorker(fc: MultiAsyncCore): Worker =
    var wb = Worker()
    wb.SockChan.open()
    wb.FCore = fc
    #GC_unref(wb)
    return wb

proc HandleSock(sock: AsyncFD) {.async.} =
    while true:
        let data = await sock.recv(1024)
        if data.len != 0:
            discard sock.send(response)
        else:
            sock.closeSocket()
            break

proc Run(worker: Worker) {.thread.} =
    discard Idle()
    while true:
        let sockTuple = worker.SockChan.tryRecv()
        if sockTuple.dataAvailable:
            #GC_unref(sockTuple.msg)
            var afd = sockTuple.msg.getFd.AsyncFD()
            register(afd)
            discard HandleSock(afd)
        else:
            poll(1)

proc AddWorker*(fc: MultiAsyncCore, num=3) =
    var threads = newSeq[Thread[Worker]](num)
    for thread in threads.mitems:
        var worker = NewWorker(fc)
        fc.Workers.add(worker)
        thread.createThread(Run, worker)

proc Accept(fc: MultiAsyncCore, worker: Worker) =
    try:
        var client: Socket = newSocket()
        accept(fc.Listener, client)
        #GC_unref(client)
        client.getFd().setBlocking(false)
        worker.SockChan.send(client)
    except:
        discard

proc Run*(fc: MultiAsyncCore) =
    while true:
        for worker in fc.Workers:
            fc.Accept(worker)

var fcv = NewMultiAsyncCore(80)
fcv.AddWorker(3) # 1 thread per core minus the listener loop.
fcv.Run()