# Nimrod wrapper of 0mq
# Generated by c2nim with modifications and enhancement from Andreas Rumpf
# Original licence follows:
#
# Copyright (c) 2007-2011 iMatix Corporation
# Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
#
# This file is part of 0MQ.
#
# 0MQ is free software; you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# 0MQ is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Generated from zmq version 2.1.5
## Nimrod 0mq wrapper. This file contains the low level C wrappers as well as
## some higher level constructs. The higher level constructs are easily
## recognizable because they are the only ones that have documentation.
##
## Example of a client:
##
## .. code-block:: nimrod
## import zmq
##
## var connection = zmq.open("tcp://localhost:5555", server=false)
## echo("Connecting...")
## for i in 0..10:
## echo("Sending hello...", i)
## send(connection, "Hello")
## var reply = receive(connection)
## echo("Received ...", reply)
## close(connection)
##
## Example of a server:
##
## .. code-block:: nimrod
##
## import zmq
## var connection = zmq.open("tcp://*:5555", server=true)
## while True:
## var request = receive(connection)
## echo("Received: ", request)
## send(connection, "World")
## close(connection)
{.deadCodeElim: on.}
when defined(windows):
const
zmqdll* = "zmq.dll"
elif defined(macosx):
const
zmqdll* = "libzmq.dylib"
else:
const
zmqdll* = "libzmq.so"
# A number random enough not to collide with different errno ranges on
# different OSes. The assumption is that error_t is at least 32-bit type.
const
HAUSNUMERO* = 156384712
# On Windows platform some of the standard POSIX errnos are not defined.
ENOTSUP* = (HAUSNUMERO + 1)
EPROTONOSUPPORT* = (HAUSNUMERO + 2)
ENOBUFS* = (HAUSNUMERO + 3)
ENETDOWN* = (HAUSNUMERO + 4)
EADDRINUSE* = (HAUSNUMERO + 5)
EADDRNOTAVAIL* = (HAUSNUMERO + 6)
ECONNREFUSED* = (HAUSNUMERO + 7)
EINPROGRESS* = (HAUSNUMERO + 8)
# Native 0MQ error codes.
EFSM* = (HAUSNUMERO + 51)
ENOCOMPATPROTO* = (HAUSNUMERO + 52)
ETERM* = (HAUSNUMERO + 53)
EMTHREAD* = (HAUSNUMERO + 54)
# Maximal size of "Very Small Message". VSMs are passed by value
# to avoid excessive memory allocation/deallocation.
# If VMSs larger than 255 bytes are required, type of 'vsm_size'
# field in msg_t structure should be modified accordingly.
MAX_VSM_SIZE* = 30
POLLIN* = 1
POLLOUT* = 2
POLLERR* = 4
STREAMER* = 1
FORWARDER* = 2
QUEUE* = 3
PAIR* = 0
PUB* = 1
SUB* = 2
REQ* = 3
REP* = 4
DEALER* = 5
ROUTER* = 6
PULL* = 7
PUSH* = 8
XPUB* = 9
XSUB* = 10
XREQ* = DEALER # Old alias, remove in 3.x
XREP* = ROUTER # Old alias, remove in 3.x
UPSTREAM* = PULL # Old alias, remove in 3.x
DOWNSTREAM* = PUSH # Old alias, remove in 3.x
type
# Message types. These integers may be stored in 'content' member of the
# message instead of regular pointer to the data.
TMsgTypes* = enum
DELIMITER = 31,
VSM = 32
# Message flags. MSG_SHARED is strictly speaking not a message flag
# (it has no equivalent in the wire format), however, making it a flag
# allows us to pack the stucture tighter and thus improve performance.
TMsgFlags* = enum
MSG_MORE = 1,
MSG_SHARED = 128,
MSG_MASK = 129 # Merges all the flags
# A message. Note that 'content' is not a pointer to the raw data.
# Rather it is pointer to zmq::msg_content_t structure
# (see src/msg_content.hpp for its definition).
TMsg*{.pure, final.} = object
content*: pointer
flags*: char
vsm_size*: char
vsm_data*: array[0..MAX_VSM_SIZE - 1, char]
TFreeFn = proc (data, hint: pointer) {.noconv.}
TContext {.final, pure.} = object
PContext* = ptr TContext
# Socket Types
TSocket {.final, pure.} = object
PSocket* = ptr TSocket
# Socket options.
TSockOptions* = enum
HWM = 1,
SWAP = 3,
AFFINITY = 4,
IDENTITY = 5,
SUBSCRIBE = 6,
UNSUBSCRIBE = 7,
RATE = 8,
RECOVERY_IVL = 9,
MCAST_LOOP = 10,
SNDBUF = 11,
RCVBUF = 12,
RCVMORE = 13,
FD = 14,
EVENTS = 15,
theTYPE = 16,
LINGER = 17,
RECONNECT_IVL = 18,
BACKLOG = 19,
RECOVERY_IVL_MSEC = 20, # opt. recovery time, reconcile in 3.x
RECONNECT_IVL_MAX = 21
# Send/recv options.
TSendRecvOptions* = enum
NOBLOCK, SNDMORE
TPollItem*{.pure, final.} = object
socket*: PSocket
fd*: cint
events*: cshort
revents*: cshort
# Run-time API version detection
proc version*(major: var cint, minor: var cint, patch: var cint){.cdecl,
importc: "zmq_version", dynlib: zmqdll.}
#****************************************************************************
# 0MQ errors.
#****************************************************************************
# This function retrieves the errno as it is known to 0MQ library. The goal
# of this function is to make the code 100% portable, including where 0MQ
# compiled with certain CRT library (on Windows) is linked to an
# application that uses different CRT library.
proc errno*(): cint{.cdecl, importc: "zmq_errno", dynlib: zmqdll.}
# Resolves system errors and 0MQ errors to human-readable string.
proc strerror*(errnum: cint): cstring {.cdecl, importc: "zmq_strerror",
dynlib: zmqdll.}
#****************************************************************************
# 0MQ message definition.
#****************************************************************************
proc msg_init*(msg: var TMsg): cint{.cdecl, importc: "zmq_msg_init",
dynlib: zmqdll.}
proc msg_init*(msg: var TMsg, size: int): cint{.cdecl,
importc: "zmq_msg_init_size", dynlib: zmqdll.}
proc msg_init*(msg: var TMsg, data: cstring, size: int,
ffn: TFreeFn, hint: pointer): cint{.cdecl,
importc: "zmq_msg_init_data", dynlib: zmqdll.}
proc msg_close*(msg: var TMsg): cint {.cdecl, importc: "zmq_msg_close",
dynlib: zmqdll.}
proc msg_move*(dest, src: var TMsg): cint{.cdecl,
importc: "zmq_msg_move", dynlib: zmqdll.}
proc msg_copy*(dest, src: var TMsg): cint{.cdecl,
importc: "zmq_msg_copy", dynlib: zmqdll.}
proc msg_data*(msg: var TMsg): cstring {.cdecl, importc: "zmq_msg_data",
dynlib: zmqdll.}
proc msg_size*(msg: var TMsg): int {.cdecl, importc: "zmq_msg_size",
dynlib: zmqdll.}
#****************************************************************************
# 0MQ infrastructure (a.k.a. context) initialisation & termination.
#****************************************************************************
proc init*(io_threads: cint): PContext {.cdecl, importc: "zmq_init",
dynlib: zmqdll.}
proc term*(context: PContext): cint {.cdecl, importc: "zmq_term",
dynlib: zmqdll.}
#****************************************************************************
# 0MQ socket definition.
#****************************************************************************
proc socket*(context: PContext, theType: cint): PSocket {.cdecl,
importc: "zmq_socket", dynlib: zmqdll.}
proc close*(s: PSocket): cint{.cdecl, importc: "zmq_close", dynlib: zmqdll.}
proc setsockopt*(s: PSocket, option: cint, optval: pointer,
optvallen: int): cint {.cdecl, importc: "zmq_setsockopt",
dynlib: zmqdll.}
proc getsockopt*(s: PSocket, option: cint, optval: pointer,
optvallen: ptr int): cint{.cdecl,
importc: "zmq_getsockopt", dynlib: zmqdll.}
proc bindAddr*(s: PSocket, address: cstring): cint{.cdecl, importc: "zmq_bind",
dynlib: zmqdll.}
proc connect*(s: PSocket, address: cstring): cint{.cdecl,
importc: "zmq_connect", dynlib: zmqdll.}
proc send*(s: PSocket, msg: var TMsg, flags: cint): cint{.cdecl,
importc: "zmq_send", dynlib: zmqdll.}
proc recv*(s: PSocket, msg: var TMsg, flags: cint): cint{.cdecl,
importc: "zmq_recv", dynlib: zmqdll.}
#****************************************************************************
# I/O multiplexing.
#****************************************************************************
proc poll*(items: ptr TPollItem, nitems: cint, timeout: int): cint{.
cdecl, importc: "zmq_poll", dynlib: zmqdll.}
#****************************************************************************
# Built-in devices
#****************************************************************************
proc device*(device: cint, insocket, outsocket: PSocket): cint{.
cdecl, importc: "zmq_device", dynlib: zmqdll.}
type
EZmq* = object of ESynch ## exception that is raised if something fails
TConnection* {.pure, final.} = object ## a connection
c*: PContext ## the embedded context
s*: PSocket ## the embedded socket
TConnectionMode* = enum ## connection mode
conPAIR = 0,
conPUB = 1,
conSUB = 2,
conREQ = 3,
conREP = 4,
conDEALER = 5,
conROUTER = 6,
conPULL = 7,
conPUSH = 8,
conXPUB = 9,
conXSUB = 10
proc zmqError*() {.noinline, noreturn.} =
## raises EZmq with error message from `zmq.strerror`.
var e: ref EZmq
new(e)
e.msg = $strerror(errno())
raise e
proc open*(address: string, server: bool, mode: TConnectionMode = conDEALER,
numthreads = 4): TConnection =
## opens a new connection. If `server` is true, it uses `bindAddr` for the
## underlying socket, otherwise it opens the socket with `connect`.
result.c = init(cint(numthreads))
if result.c == nil: zmqError()
result.s = socket(result.c, cint(ord(mode)))
if result.s == nil: zmqError()
if server:
if bindAddr(result.s, address) != 0'i32: zmqError()
else:
if connect(result.s, address) != 0'i32: zmqError()
proc close*(c: TConnection) =
## closes the connection.
if close(c.s) != 0'i32: zmqError()
if term(c.c) != 0'i32: zmqError()
proc send*(c: TConnection, msg: string) =
## sends a message over the connection.
var m: TMsg
if msg_init(m, msg.len) != 0'i32: zmqError()
copyMem(msg_data(m), cstring(msg), msg.len)
if send(c.s, m, 0'i32) != 0'i32: zmqError()
discard msg_close(m)
proc receive*(c: TConnection): string =
## receives a message from a connection.
var m: TMsg
if msg_init(m) != 0'i32: zmqError()
if recv(c.s, m, 0'i32) != 0'i32: zmqError()
result = newString(msg_size(m))
copyMem(addr(result[0]), msg_data(m), result.len)
discard msg_close(m)