Reference

lib_version()

Get the libzmq version number.

Exception thrown by the recv*() methods if rcvtimeo is set and a receive times out, or a Poller. The timeout itself can be obtained from the timeout_secs property of the exception.

A ZMQ socket.

Socket(ctx::Context, typ::Integer)

Create a socket in a given context.

Socket(typ::Integer)

Create a socket of a certain type.

Socket(f::Function, args...)

Do-block constructor.

Base.isopen(socket::Socket)

Base.close(socket::Socket)

Sockets.bind(socket::Socket, endpoint::AbstractString)

Bind the socket to an endpoint. Note that the endpoint must be formatted as described here. e.g. tcp://127.0.0.1:42000.

Sockets.connect(socket::Socket, endpoint::AbstractString)

Connect the socket to an endpoint.

recv(socket::Socket)

Return a Message object representing a message received from a ZMQ Socket (without making a copy of the message data).

If rcvtimeo is set then a TimeoutError will be thrown upon timeout. Note that because of the integration with Julia's event loop there is some overhead to using timeouts, on the order of ~10μs. All other recv*() methods also respect rcvtimeo.

recv(socket::Socket, ::Type{T})

Receive a message of type T (typically a String, Vector{UInt8}, or isbits type) from a ZMQ Socket. (Makes a copy of the message data; you can alternatively use recv(socket) to work with zero-copy bytearray-like representation for large messages.)

recv_multipart(socket::Socket, ::Type{T}) -> Vector{T}

Receive a multipart message of a specific type T. This behaves in the same way as recv(::Socket, ::Type).

recv_multipart(socket::Socket) -> Vector{Message}

Receive a multipart message as a sequence of zero-copy Message's. See recv(::Socket).

send(socket::Socket, data; more=false)

Send data over socket. A more=true keyword argument can be passed to indicate that data is a portion of a larger multipart message. data can be any isbits type, a Vector of isbits elements, a String, or a Message object to perform zero-copy sends of large arrays.

send(socket::Socket, zmsg::Message; more::Bool=false)

Zero-copy version of Sockets.send(socket, data) using a user-allocated Message.

send_multipart(socket::Socket, parts)

Send a multipart message composed of the elements in parts. parts may be any object that supports getindex(), eachindex(), and lastindex().

PAIR socket.

PUB socket.

SUB socket.

REQ socket.

REP socket.

DEALER socket.

ROUTER socket.

PULL socket.

PUSH socket.

XPUB socket.

XSUB socket.

XREQ socket.

XREP socket.

UPSTREAM socket.

DOWNSTREAM socket.

mutable struct Message <: AbstractArray{UInt8, 1}

High-level Message object for sending/receiving ZMQ messages in shared buffers. As an AbstractArray, it supports common (non-resizeable) array behaviour.

Examples

julia> using ZMQ

julia> m = Message("foo");

julia> Char(m[1])            # Array indexing
'f': ASCII/Unicode U+0066 (category Ll: Letter, lowercase)

julia> m[end] = Int('g');    # Array assignment

julia> unsafe_string(m)      # Conversion to string (only do this if you know the message is a string)
"fog"

julia> IOBuffer(m)           # Create a zero-copy IOBuffer
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=3, maxsize=Inf, ptr=1, mark=-1)

Message()

Create an empty message (for receive).

Message(len::Integer)

Create a message with a given buffer size (for send).

Message(origin::Any, m::Ptr{T}, len::Integer) where {T}

Low-level function to create a message (for send) with an existing data buffer, without making a copy. The origin parameter should be the Julia object that is the origin of the data, so that we can hold a reference to it until ZMQ is done with the buffer.

Message(m::String)

Create a message with a string as a buffer (for send). Note: the Message now "owns" the string, it must not be resized, or even written to after the message is sent.

Message(p::SubString{String})

Create a message with a sub-string as a buffer (for send). Note: the same ownership semantics as for Message(m::String) apply.

Message(a::T) where T <: DenseVector

Create a message with an array as a buffer (for send). Note: the same ownership semantics as for Message(m::String) apply.

Usually a will be a 1D Array/Vector, but on Julia 1.11+ it can also be a Memory.

Message(io::IOBuffer)

Create a message with an IOBuffer as a buffer (for send). Note: the same ownership semantics as for Message(m::String) apply.

isfreed(m::Message)

Check whether zeromq has called our free-function, i.e. whether we are safe to reclaim ownership of any buffer object the Message was created with.

A Poller can wait on multiple sockets simultaneously for them to be ready for reading or writing.

Examples

poller = Poller([sock1, sock2])
while true
    try
        result::PollResult = wait(poller; timeout=0.1)
        if ZMQ.recv(result.socket, String) == "exit"
            break
        end
    catch ex
        if !isa(ex, ZMQ.TimeoutError)
            rethrow()
        end
    end
end

close(poller)

Poller(sockets::Vector{Socket})

Create a Poller that monitors read events (ZMQ_POLLIN) for the given sockets.

Poller(items::Vector{PollItem})

Create a Poller from PollItem's. This offers the most flexibility since you can specify which events to monitor for each socket.

Poller(f::Function, args)

Do-constructor that will call f(poller) and clean up the Poller afterwards.

wait(poller::Poller; timeout::Real=-1) -> PollResult

Wait for an event on one of the sockets monitored by poller and return a PollResult.

Throws

• ArgumentError: if poller is closed.
• TimeoutError: if a positive timeout is given and an event is not received in time.
• ErrorException: if the poller was closed while waiting.

close(poller::Poller)

Close a Poller. It does not close the pollers sockets. This function is threadsafe and can be called at any time.

PollItem(socket::Socket; readable=true, writable=false)

This object can be passed to a Poller to indicate whether the poller should wait for socket to become readable (ZMQ_POLLIN) or writable (ZMQ_POLLOUT).

This object represents an event on a socket. It's returned by wait(::Poller).

The fields are:

• socket::Socket
• readable::Bool
• writable::Bool

context()

Return the default ZMQ context (of type Context), initializing it if this has not been done already. (This context is automatically closed when Julia exits.)