nim-chronos/chronos/ioselects/ioselectors_epoll.nim

#
#
#            Nim's Runtime Library
#        (c) Copyright 2016 Eugene Kabanov
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

# This module implements Linux epoll().
import std/[deques, tables]
import stew/base10

when (NimMajor, NimMinor) < (1, 4):
  {.push raises: [Defect].}
else:
  {.push raises: [].}

type
  SelectorImpl[T] = object
    epollFd: cint
    sigFd: Opt[cint]
    pidFd: Opt[cint]
    fds: Table[int32, SelectorKey[T]]
    signals: Table[int32, SelectorKey[T]]
    processes: Table[int32, SelectorKey[T]]
    signalMask: Sigset
    virtualHoles: Deque[int32]
    virtualId: int32
    childrenExited: bool
    pendingEvents: Deque[ReadyKey]

  Selector*[T] = ref SelectorImpl[T]

  SelectEventImpl = object
    efd: cint

  SelectEvent* = ptr SelectEventImpl

proc getVirtualId[T](s: Selector[T]): SelectResult[int32] =
  if len(s.virtualHoles) > 0:
    ok(s.virtualHoles.popLast())
  else:
    if s.virtualId == low(int32):
      err(OSErrorCode(EMFILE))
    else:
      dec(s.virtualId)
      ok(s.virtualId)

proc isVirtualId(ident: int32): bool =
  ident < 0'i32

proc toString(key: int32|cint|SocketHandle|int): string =
  let fdi32 = when key is int32: key else: int32(key)
  if isVirtualId(fdi32):
    if fdi32 == -1:
      "InvalidIdent"
    else:
      "V" & Base10.toString(uint32(-fdi32))
  else:
    Base10.toString(uint32(fdi32))

template addKey[T](s: Selector[T], key: int32, skey: SelectorKey[T]) =
  if s.fds.hasKeyOrPut(key, skey):
    raiseAssert "Descriptor [" & key.toString() &
                "] is already registered in the selector!"

template getKey[T](s: Selector[T], key: int32): SelectorKey[T] =
  let
    defaultKey = SelectorKey[T](ident: InvalidIdent)
    pkey = s.fds.getOrDefault(key, defaultKey)
  doAssert(pkey.ident != InvalidIdent,
           "Descriptor [" & key.toString() &
           "] is not registered in the selector!")
  pkey

template checkKey[T](s: Selector[T], key: int32): bool =
  s.fds.contains(key)

proc addSignal[T](s: Selector[T], signal: int, skey: SelectorKey[T]) =
  if s.signals.hasKeyOrPut(int32(signal), skey):
    raiseAssert "Signal [" & $signal & "] is already registered in the selector"

template addProcess[T](s: Selector[T], pid: int, skey: SelectorKey[T]) =
  if s.processes.hasKeyOrPut(int32(pid), skey):
    raiseAssert "Process [" & $pid & "] is already registered in the selector"

proc freeKey[T](s: Selector[T], key: int32) =
  s.fds.del(key)
  if isVirtualId(key):
    s.virtualHoles.addFirst(key)

proc freeSignal[T](s: Selector[T], ident: int32) =
  s.signals.del(ident)

proc freeProcess[T](s: Selector[T], ident: int32) =
  s.processes.del(ident)

proc new*(t: typedesc[Selector], T: typedesc): SelectResult[Selector[T]] =
  var nmask: Sigset
  if sigemptyset(nmask) < 0:
    return err(osLastError())
  let epollFd = epoll_create(asyncEventsCount)
  if epollFd < 0:
    return err(osLastError())
  let selector = Selector[T](
    epollFd: epollFd,
    fds: initTable[int32, SelectorKey[T]](asyncInitialSize),
    signalMask: nmask,
    virtualId: -1'i32, # Should start with -1, because `InvalidIdent` == -1
    childrenExited: false,
    virtualHoles: initDeque[int32](),
    pendingEvents: initDeque[ReadyKey]()
  )
  ok(selector)

proc close2*[T](s: Selector[T]): SelectResult[void] =
  s.fds.clear()
  s.signals.clear()
  s.processes.clear()
  s.virtualHoles.clear()
  s.virtualId = -1'i32
  if handleEintr(osdefs.close(s.epollFd)) != 0:
    err(osLastError())
  else:
    ok()

proc new*(t: typedesc[SelectEvent]): SelectResult[SelectEvent] =
  let eFd = eventfd(0, EFD_CLOEXEC or EFD_NONBLOCK)
  if eFd == -1:
    return err(osLastError())
  var res = cast[SelectEvent](allocShared0(sizeof(SelectEventImpl)))
  res.efd = eFd
  ok(res)

proc trigger2*(event: SelectEvent): SelectResult[void] =
  var data: uint64 = 1
  let res = handleEintr(osdefs.write(event.efd, addr data, sizeof(uint64)))
  if res == -1:
    err(osLastError())
  elif res != sizeof(uint64):
    err(OSErrorCode(osdefs.EINVAL))
  else:
    ok()

proc close2*(event: SelectEvent): SelectResult[void] =
  let evFd = event.efd
  deallocShared(cast[pointer](event))
  let res = handleEintr(osdefs.close(evFd))
  if res == -1:
    err(osLastError())
  else:
    ok()

proc init(t: typedesc[EpollEvent], fdi: cint, events: set[Event]): EpollEvent =
  var res = uint32(EPOLLRDHUP)
  if Event.Read in events: res = res or uint32(EPOLLIN)
  if Event.Write in events: res = res or uint32(EPOLLOUT)
  if Event.Oneshot in events: res = res or uint32(EPOLLONESHOT)
  # We need this double conversion of type because otherwise in x64 environment
  # negative cint could be converted to big uint64.
  EpollEvent(events: res, data: EpollData(u64: uint64(uint32(fdi))))

proc registerHandle2*[T](s: Selector[T], fd: cint, events: set[Event],
                         data: T): SelectResult[void] =
  let skey = SelectorKey[T](ident: fd, events: events, param: 0, data: data)

  s.addKey(fd, skey)

  if events != {}:
    let epollEvents = EpollEvent.init(fd, events)
    if epoll_ctl(s.epollFd, EPOLL_CTL_ADD, fd, unsafeAddr(epollEvents)) != 0:
      s.freeKey(fd)
      return err(osLastError())
  ok()

proc updateHandle2*[T](s: Selector[T], fd: cint,
                       events: set[Event]): SelectResult[void] =
  const EventsMask = {Event.Timer, Event.Signal, Event.Process, Event.Vnode,
                      Event.User, Event.Oneshot, Event.Error}
  s.fds.withValue(int32(fd), pkey):
    doAssert(pkey[].events * EventsMask == {},
             "Descriptor [" & fd.toString() & "] could not be updated!")
    if pkey[].events != events:
      let epollEvents = EpollEvent.init(fd, events)
      if pkey[].events == {}:
        if epoll_ctl(s.epollFd, EPOLL_CTL_ADD, fd,
                     unsafeAddr(epollEvents)) != 0:
          return err(osLastError())
      else:
        if events != {}:
          if epoll_ctl(s.epollFd, EPOLL_CTL_MOD, fd,
                       unsafeAddr(epollEvents)) != 0:
            return err(osLastError())
        else:
          if epoll_ctl(s.epollFd, EPOLL_CTL_DEL, fd,
                       unsafeAddr epollEvents) != 0:
            return err(osLastError())
      pkey.events = events
  do:
    raiseAssert "Descriptor [" & fd.toString() &
                "] is not registered in the selector!"
  ok()

proc blockSignal[T](s: Selector[T], signal: int): SelectResult[bool] =
  let isMember = sigismember(s.signalMask, cint(signal))
  if isMember < 0:
    err(osLastError())
  elif isMember > 0:
    ok(false)
  else:
    var omask, nmask: Sigset
    if sigemptyset(nmask) < 0:
      return err(osLastError())
    if sigemptyset(omask) < 0:
      return err(osLastError())
    if sigaddset(nmask, cint(signal)) < 0:
      return err(osLastError())
    ? blockSignals(nmask, omask)
    if sigaddset(s.signalMask, cint(signal)) < 0:
      # Try to restore previous state of signals mask
      let errorCode = osLastError()
      discard unblockSignals(nmask, omask)
      return err(errorCode)
    ok(true)

proc unblockSignal[T](s: Selector[T], signal: int): SelectResult[bool] =
  let isMember = sigismember(s.signalMask, cint(signal))
  if isMember < 0:
    err(osLastError())
  elif isMember == 0:
    ok(false)
  else:
    var omask, nmask: Sigset
    if sigemptyset(nmask) < 0:
      return err(osLastError())
    if sigemptyset(omask) < 0:
      return err(osLastError())
    if sigaddset(nmask, cint(signal)) < 0:
      return err(osLastError())
    ? unblockSignals(nmask, omask)
    if sigdelset(s.signalMask, cint(signal)) < 0:
      # Try to restore previous state of signals mask
      let errorCode = osLastError()
      discard blockSignals(nmask, omask)
      return err(errorCode)
    ok(true)

template checkSignal(signal: int) =
  doAssert((signal >= 0) and (signal <= int(high(int32))),
           "Invalid signal value [" & $signal & "]")

proc registerSignalEvent[T](s: Selector[T], signal: int,
                            events: set[Event], param: int,
                            data: T): SelectResult[cint] =
  checkSignal(signal)

  let
    fdi32 = ? s.getVirtualId()
    selectorKey = SelectorKey[T](ident: signal, events: events,
                                param: param, data: data)
    signalKey = SelectorKey[T](ident: fdi32, events: events,
                               param: param, data: data)

  s.addKey(fdi32, selectorKey)
  s.addSignal(signal, signalKey)

  let mres =
    block:
      let res = s.blockSignal(signal)
      if res.isErr():
        s.freeKey(fdi32)
        s.freeSignal(int32(signal))
        return err(res.error())
      res.get()

  if not(mres):
    raiseAssert "Signal [" & $signal & "] could have only one handler at " &
                "the same time!"

  if s.sigFd.isSome():
    let res = signalfd(s.sigFd.get(), s.signalMask,
                       SFD_NONBLOCK or SFD_CLOEXEC)
    if res == -1:
      let errorCode = osLastError()
      s.freeKey(fdi32)
      s.freeSignal(int32(signal))
      discard s.unblockSignal(signal)
      return err(errorCode)
  else:
    let sigFd = signalfd(-1, s.signalMask, SFD_NONBLOCK or SFD_CLOEXEC)
    if sigFd == -1:
      let errorCode = osLastError()
      s.freeKey(fdi32)
      s.freeSignal(int32(signal))
      discard s.unblockSignal(signal)
      return err(errorCode)

    let fdKey = SelectorKey[T](ident: sigFd, events: {Event.Signal})
    s.addKey(sigFd, fdKey)

    let event = EpollEvent.init(sigFd, {Event.Read})
    if epoll_ctl(s.epollFd, EPOLL_CTL_ADD, sigFd, unsafeAddr(event)) != 0:
      let errorCode = osLastError()
      s.freeKey(fdi32)
      s.freeSignal(int32(signal))
      s.freeKey(sigFd)
      discard s.unblockSignal(signal)
      discard handleEintr(osdefs.close(sigFd))
      return err(errorCode)

    s.sigFd = Opt.some(sigFd)

  ok(cint(fdi32))

proc registerSignal*[T](s: Selector[T], signal: int,
                       data: T): SelectResult[cint] =
  registerSignalEvent(s, signal, {Event.Signal}, 0, data)

proc registerTimer2*[T](s: Selector[T], timeout: int, oneshot: bool,
                        data: T): SelectResult[cint] =
  let timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC or TFD_NONBLOCK)
  if timerFd == -1:
    return err(osLastError())

  let
    fdi32 = int32(timerFd)
    (key, event) =
      if oneshot:
        (
          SelectorKey[T](ident: timerFd, events: {Event.Timer, Event.Oneshot},
                         param: 0, data: data),
          EpollEvent.init(timerFd, {Event.Read, Event.Oneshot})
        )
      else:
        (
          SelectorKey[T](ident: timerFd, events: {Event.Timer},
                         param: 0, data: data),
          EpollEvent.init(timerFd, {Event.Read})
        )
  var timeStruct =
    if oneshot:
      Itimerspec(
        it_interval: Timespec(tv_sec: osdefs.Time(0), tv_nsec: 0),
        it_value: Timespec(tv_sec: osdefs.Time(timeout div 1_000),
                           tv_nsec: (timeout %% 1000) * 1_000_000)
      )
    else:
      Itimerspec(
        it_interval: Timespec(tv_sec: osdefs.Time(timeout div 1_000),
                              tv_nsec: 0),
        it_value: Timespec(tv_sec: osdefs.Time(timeout div 1_000),
                           tv_nsec: 0),
      )

  s.addKey(fdi32, key)

  var oldTs = Itimerspec()
  if timerfd_settime(timerFd, cint(0), timeStruct, oldTs) != 0:
    let errorCode = osLastError()
    s.freeKey(fdi32)
    discard handleEintr(osdefs.close(timerFd))
    return err(errorCode)

  if epoll_ctl(s.epollFd, EPOLL_CTL_ADD, timerFd, unsafeAddr(event)) != 0:
    let errorCode = osLastError()
    s.freeKey(fdi32)
    discard handleEintr(osdefs.close(timerFd))
    return err(errorCode)

  ok(cint(fdi32))

proc registerEvent2*[T](s: Selector[T], ev: SelectEvent,
                        data: T): SelectResult[cint] =
  doAssert(not(isNil(ev)))
  let
    key = SelectorKey[T](ident: ev.efd, events: {Event.User},
                         param: 0, data: data)
    event = EpollEvent.init(ev.efd, {Event.Read})

  s.addKey(ev.efd, key)

  if epoll_ctl(s.epollFd, EPOLL_CTL_ADD, ev.efd, unsafeAddr(event)) != 0:
    s.freeKey(ev.efd)
    return err(osLastError())

  ok(ev.efd)

template checkPid(pid: int) =
  when sizeof(int) == 8:
    doAssert(pid >= 0 and pid <= int(high(uint32)),
             "Invalid process idientified (pid) value")
  else:
    doAssert(pid >= 0 and pid <= high(int32),
             "Invalid process idientified (pid) value")

proc registerProcess*[T](s: Selector, pid: int, data: T): SelectResult[cint] =
  checkPid(pid)

  let
    fdi32 = ? s.getVirtualId()
    events = {Event.Process, Event.Oneshot}
    selectorKey = SelectorKey[T](ident: pid, events: events, param: 0,
                                 data: data)
    processKey = SelectorKey[T](ident: fdi32, events: events, param: 0,
                                data: data)

  s.addProcess(pid, processKey)
  s.addKey(fdi32, selectorKey)

  if s.pidFd.isNone():
    let res = registerSignalEvent(s, int(SIGCHLD), {Event.Signal}, 0, data)
    if res.isErr():
      s.freeKey(fdi32)
      s.freeProcess(int32(pid))
      return err(res.error())
    s.pidFd = Opt.some(cast[cint](res.get()))

  ok(cint(fdi32))

proc unregister2*[T](s: Selector[T], fd: cint): SelectResult[void] =
  let
    fdi32 = int32(fd)
    pkey = s.getKey(fdi32)

  if pkey.events != {}:
    if {Event.Read, Event.Write, Event.User} * pkey.events != {}:
      if epoll_ctl(s.epollFd, EPOLL_CTL_DEL, cint(pkey.ident), nil) != 0:
        return err(osLastError())

    elif Event.Timer in pkey.events:
      if Event.Finished notin pkey.events:
        if epoll_ctl(s.epollFd, EPOLL_CTL_DEL, fd, nil) != 0:
          let errorCode = osLastError()
          discard handleEintr(osdefs.close(fd))
          return err(errorCode)
      if handleEintr(osdefs.close(fd)) == -1:
        return err(osLastError())

    elif Event.Signal in pkey.events:
      if not(s.signals.hasKey(int32(pkey.ident))):
        raiseAssert "Signal " & pkey.ident.toString() &
                    " is not registered in the selector!"
      let sigFd =
        block:
          doAssert(s.sigFd.isSome(), "signalfd descriptor is missing")
          s.sigFd.get()

      s.freeSignal(int32(pkey.ident))

      if len(s.signals) > 0:
        let res = signalfd(sigFd, s.signalMask, SFD_NONBLOCK or SFD_CLOEXEC)
        if res == -1:
          let errorCode = osLastError()
          discard s.unblockSignal(pkey.ident)
          return err(errorCode)
      else:
        s.freeKey(sigFd)
        s.sigFd = Opt.none(cint)

        if epoll_ctl(s.epollFd, EPOLL_CTL_DEL, sigFd, nil) != 0:
          let errorCode = osLastError()
          discard handleEintr(osdefs.close(sigFd))
          discard s.unblockSignal(pkey.ident)
          return err(errorCode)

        if handleEintr(osdefs.close(sigFd)) != 0:
          let errorCode = osLastError()
          discard s.unblockSignal(pkey.ident)
          return err(errorCode)

      let mres = ? s.unblockSignal(pkey.ident)
      doAssert(mres, "Signal is not present in stored mask!")

    elif Event.Process in pkey.events:
      if not(s.processes.hasKey(int32(pkey.ident))):
        raiseAssert "Process " & pkey.ident.toString() &
                    " is not registered in the selector!"

      let pidFd =
        block:
          doAssert(s.pidFd.isSome(), "process descriptor is missing")
          s.pidFd.get()

      s.freeProcess(int32(pkey.ident))

      # We need to filter pending events queue for just unregistered process.
      if len(s.pendingEvents) > 0:
        s.pendingEvents =
          block:
            var res = initDeque[ReadyKey](len(s.pendingEvents))
            for item in s.pendingEvents.items():
              if item.fd != fdi32:
                res.addLast(item)
            res

      if len(s.processes) == 0:
        s.pidFd = Opt.none(cint)
        let res = s.unregister2(pidFd)
        if res.isErr():
          return err(res.error())

  s.freeKey(fdi32)
  ok()

proc unregister2*[T](s: Selector[T], event: SelectEvent): SelectResult[void] =
  s.unregister2(event.efd)

proc prepareKey[T](s: Selector[T], event: EpollEvent): Opt[ReadyKey] =
  let
    defaultKey = SelectorKey[T](ident: InvalidIdent)
    fdi32 =
      block:
        doAssert(event.data.u64 <= uint64(high(uint32)),
                 "Invalid user data value in epoll event object")
        cast[int32](event.data.u64)

  var
    pkey = s.getKey(fdi32)
    rkey = ReadyKey(fd: fdi32)

  if (event.events and EPOLLERR) != 0:
    rkey.events.incl(Event.Error)
    rkey.errorCode = OSErrorCode(ECONNRESET)

  if (event.events and EPOLLHUP) != 0 or (event.events and EPOLLRDHUP) != 0:
    rkey.events.incl(Event.Error)
    rkey.errorCode = OSErrorCode(ECONNRESET)

  if (event.events and EPOLLOUT) != 0:
    rkey.events.incl(Event.Write)

  if (event.events and EPOLLIN) != 0:
    if Event.Read in pkey.events:
      rkey.events.incl(Event.Read)

    elif Event.Timer in pkey.events:
      var data: uint64
      rkey.events.incl(Event.Timer)
      let res = handleEintr(osdefs.read(fdi32, addr data, sizeof(uint64)))
      if res != sizeof(uint64):
        rkey.events.incl(Event.Error)
        rkey.errorCode = osLastError()

    elif Event.Signal in pkey.events:
      var data: SignalFdInfo
      let res = handleEintr(osdefs.read(fdi32, addr data, sizeof(SignalFdInfo)))
      if res != sizeof(SignalFdInfo):
        # We could not obtain `signal` number so we can't report an error to
        # proper handler.
        return Opt.none(ReadyKey)
      if data.ssi_signo != uint32(SIGCHLD) or len(s.processes) == 0:
        let skey = s.signals.getOrDefault(cast[int32](data.ssi_signo),
                                          defaultKey)
        if skey.ident == InvalidIdent:
          # We do not have any handlers for received event so we can't report
          # an error to proper handler.
          return Opt.none(ReadyKey)
        rkey.events.incl(Event.Signal)
        rkey.fd = skey.ident
      else:
        # Indicate that SIGCHLD has been seen.
        s.childrenExited = true
        # Current signal processing.
        let pidKey = s.processes.getOrDefault(cast[int32](data.ssi_pid),
                                              defaultKey)
        if pidKey.ident == InvalidIdent:
          # We do not have any handlers with signal's pid.
          return Opt.none(ReadyKey)
        rkey.events.incl({Event.Process, Event.Oneshot, Event.Finished})
        rkey.fd = pidKey.ident
        # Mark process descriptor inside fds table as finished.
        var fdKey = s.fds.getOrDefault(int32(pidKey.ident), defaultKey)
        if fdKey.ident != InvalidIdent:
          fdKey.events.incl(Event.Finished)
          s.fds[int32(pidKey.ident)] = fdKey

    elif Event.User in pkey.events:
      var data: uint64
      let res = handleEintr(osdefs.read(fdi32, addr data, sizeof(uint64)))
      if res != sizeof(uint64):
        let errorCode = osLastError()
        if errorCode == EAGAIN:
          return Opt.none(ReadyKey)
        else:
          rkey.events.incl({Event.User, Event.Error})
          rkey.errorCode = errorCode
      else:
        rkey.events.incl(Event.User)

  if Event.Oneshot in rkey.events:
    if Event.Timer in rkey.events:
      if epoll_ctl(s.epollFd, EPOLL_CTL_DEL, fdi32, nil) != 0:
        rkey.events.incl(Event.Error)
        rkey.errorCode = osLastError()
      # we are marking key with `Finished` event, to avoid double decrease.
      rkey.events.incl(Event.Finished)
      pkey.events.incl(Event.Finished)
      s.fds[fdi32] = pkey

  ok(rkey)

proc checkProcesses[T](s: Selector[T]) =
  # If SIGCHLD has been seen we need to check all processes we are monitoring
  # for completion, because in Linux SIGCHLD could be masked.
  # You can get more information in article "Signalfd is useless" -
  # https://ldpreload.com/blog/signalfd-is-useless?reposted-on-request
  if not(s.childrenExited):
    return

  let
    defaultKey = SelectorKey[T](ident: InvalidIdent)
    flags = WNOHANG or WNOWAIT or WSTOPPED or WEXITED
  s.childrenExited = false
  for pid, pidKey in s.processes.pairs():
    var fdKey = s.fds.getOrDefault(int32(pidKey.ident), defaultKey)
    if fdKey.ident != InvalidIdent:
      if Event.Finished notin fdKey.events:
        var sigInfo = SigInfo()
        let res = handleEintr(osdefs.waitid(P_PID, cast[Id](pid),
                                            sigInfo, flags))
        if (res == 0) and (cint(sigInfo.si_pid) == cint(pid)):
          fdKey.events.incl(Event.Finished)
          let rkey = ReadyKey(fd: pidKey.ident, events: fdKey.events)
          s.pendingEvents.addLast(rkey)
          s.fds[int32(pidKey.ident)] = fdKey

proc selectInto2*[T](s: Selector[T], timeout: int,
                     readyKeys: var openArray[ReadyKey]
                    ): SelectResult[int] =
  var
    queueEvents: array[asyncEventsCount, EpollEvent]
    k: int = 0

  verifySelectParams(timeout, -1, int(high(cint)))

  let
    maxEventsCount = min(len(queueEvents), len(readyKeys))
    maxPendingEventsCount = min(maxEventsCount, len(s.pendingEvents))
    maxNewEventsCount = max(maxEventsCount - maxPendingEventsCount, 0)

  let
    eventsCount =
      if maxNewEventsCount > 0:
        let res = handleEintr(epoll_wait(s.epollFd, addr(queueEvents[0]),
                                         cint(maxNewEventsCount),
                                         cint(timeout)))
        if res < 0:
          return err(osLastError())
        res
      else:
        0

  s.childrenExited = false

  for i in 0 ..< eventsCount:
    let rkey = s.prepareKey(queueEvents[i]).valueOr: continue
    readyKeys[k] = rkey
    inc(k)

  s.checkProcesses()

  let pendingEventsCount = min(len(readyKeys) - eventsCount,
                               len(s.pendingEvents))

  for i in 0 ..< pendingEventsCount:
    readyKeys[k] = s.pendingEvents.popFirst()
    inc(k)

  ok(k)

proc select2*[T](s: Selector[T], timeout: int): SelectResult[seq[ReadyKey]] =
  var res = newSeq[ReadyKey](asyncEventsCount)
  let count = ? selectInto2(s, timeout, res)
  res.setLen(count)
  ok(res)

proc newSelector*[T](): Selector[T] {.
     raises: [Defect, OSError].} =
  let res = Selector.new(T)
  if res.isErr(): raiseOSError(res.error())
  res.get()

proc close*[T](s: Selector[T]) {.
     raises: [Defect, IOSelectorsException].} =
  let res = s.close2()
  if res.isErr(): raiseIOSelectorsError(res.error())

proc newSelectEvent*(): SelectEvent {.
     raises: [Defect, IOSelectorsException].} =
  let res = SelectEvent.new()
  if res.isErr(): raiseIOSelectorsError(res.error())
  res.get()

proc trigger*(event: SelectEvent) {.
     raises: [Defect, IOSelectorsException].} =
  let res = event.trigger2()
  if res.isErr(): raiseIOSelectorsError(res.error())

proc close*(event: SelectEvent) {.
     raises: [Defect, IOSelectorsException].} =
  let res = event.close2()
  if res.isErr(): raiseIOSelectorsError(res.error())

proc registerHandle*[T](s: Selector[T], fd: cint | SocketHandle,
                        events: set[Event], data: T) {.
    raises: [Defect, IOSelectorsException].} =
  let res = registerHandle2(s, fd, events, data)
  if res.isErr(): raiseIOSelectorsError(res.error())

proc updateHandle*[T](s: Selector[T], fd: cint | SocketHandle,
                      events: set[Event]) {.
    raises: [Defect, IOSelectorsException].} =
  let res = updateHandle2(s, fd, events)
  if res.isErr(): raiseIOSelectorsError(res.error())

proc unregister*[T](s: Selector[T], fd: cint | SocketHandle) {.
     raises: [Defect, IOSelectorsException].} =
  let res = unregister2(s, fd)
  if res.isErr(): raiseIOSelectorsError(res.error())

proc unregister*[T](s: Selector[T], event: SelectEvent) {.
    raises: [Defect, IOSelectorsException].} =
  let res = unregister2(s, event)
  if res.isErr(): raiseIOSelectorsError(res.error())

proc registerTimer*[T](s: Selector[T], timeout: int, oneshot: bool,
                       data: T): cint {.
    discardable, raises: [Defect, IOSelectorsException].} =
  let res = registerTimer2(s, timeout, oneshot, data)
  if res.isErr(): raiseIOSelectorsError(res.error())
  res.get()

proc registerEvent*[T](s: Selector[T], event: SelectEvent,
                       data: T) {.
     raises: [Defect, IOSelectorsException].} =
  let res = registerEvent2(s, event, data)
  if res.isErr(): raiseIOSelectorsError(res.error())

proc selectInto*[T](s: Selector[T], timeout: int,
                    readyKeys: var openArray[ReadyKey]): int {.
     raises: [Defect, IOSelectorsException].} =
  let res = selectInto2(s, timeout, readyKeys)
  if res.isErr(): raiseIOSelectorsError(res.error())
  res.get()

proc select*[T](s: Selector[T], timeout: int): seq[ReadyKey] =
  let res = select2(s, timeout)
  if res.isErr(): raiseIOSelectorsError(res.error())
  res.get()

proc contains*[T](s: Selector[T], fd: SocketHandle|cint): bool {.inline.} =
  s.checkKey(int32(fd))

proc setData*[T](s: Selector[T], fd: SocketHandle|cint, data: T): bool =
  s.fds.withValue(int32(fd), skey):
    skey[].data = data
    return true
  do:
    return false

template withData*[T](s: Selector[T], fd: SocketHandle|cint, value,
                      body: untyped) =
  s.fds.withValue(int32(fd), skey):
    var value = addr(skey[].data)
    body

template withData*[T](s: Selector[T], fd: SocketHandle|cint, value, body1,
                      body2: untyped) =
  s.fds.withValue(int32(fd), skey):
    var value = addr(skey[].data)
    body1
  do:
    body2

proc getFd*[T](s: Selector[T]): cint = s.epollFd