def __init__(self, io_threads=1):
if not io_threads >= 0:
raise ZMQError(EINVAL)
self._zmq_ctx = C.zmq_init(io_threads)
if self._zmq_ctx == ffi.NULL:
raise ZMQError(C.zmq_errno())
self._iothreads = io_threads
self._closed = False
self._sockets = set()
def __init__(self, io_threads=1):
if not io_threads >= 0:
raise ZMQError(EINVAL)
self._zmq_ctx = C.zmq_ctx_new()
if self._zmq_ctx == ffi.NULL:
raise ZMQError(C.zmq_errno())
C.zmq_ctx_set(self._zmq_ctx, IO_THREADS, io_threads)
self._closed = False
self._sockets = set()
def __init__(self, io_threads=1, shadow=None):
if shadow:
self._zmq_ctx = ffi.cast("void *", shadow)
self._shadow = True
else:
self._shadow = False
if not io_threads >= 0:
raise ZMQError(EINVAL)
self._zmq_ctx = C.zmq_ctx_new()
if self._zmq_ctx == ffi.NULL:
raise ZMQError(C.zmq_errno())
if not shadow:
C.zmq_ctx_set(self._zmq_ctx, IO_THREADS, io_threads)
self._closed = False
def poll(self, timeout=None, flags=POLLIN):
"""Poll the socket for events.
See :class:`Poller` to wait for multiple sockets at once.
Parameters
----------
timeout : int [default: None]
The timeout (in milliseconds) to wait for an event. If unspecified
(or specified None), will wait forever for an event.
flags : int [default: POLLIN]
POLLIN, POLLOUT, or POLLIN|POLLOUT. The event flags to poll for.
Returns
-------
events : int
The events that are ready and waiting,
0 if the timeout was reached with no events.
"""
if self.closed:
raise ZMQError(ENOTSUP)
p = self._poller_class()
p.register(self, flags)
evts = dict(p.poll(timeout))
# return 0 if no events, otherwise return event bitfield
return evts.get(self, 0)
def stop(self):
if self.watch == ffi.NULL:
raise ZMQError('Must start the Stopwatch before calling stop.')
else:
time = C.zmq_stopwatch_stop(self.watch)
self.watch = ffi.NULL
return time
def socket(self, socket_type, **kwargs):
"""Create a Socket associated with this Context.
Parameters
----------
socket_type : int
The socket type, which can be any of the 0MQ socket types:
REQ, REP, PUB, SUB, PAIR, DEALER, ROUTER, PULL, PUSH, etc.
kwargs:
will be passed to the __init__ method of the socket class.
"""
if self.closed:
raise ZMQError(ENOTSUP)
s = self._socket_class(self, socket_type, **kwargs)
for opt, value in self.sockopts.items():
try:
s.setsockopt(opt, value)
except ZMQError:
# ignore ZMQErrors, which are likely for socket options
# that do not apply to a particular socket type, e.g.
# SUBSCRIBE for non-SUB sockets.
pass
self._add_socket(s)
return s
def poll(self, timeout=None, flags=POLLIN):
"""poll the socket for events
The default is to poll forever for incoming
events. Timeout is in milliseconds, if specified.
Parameters
----------
timeout : int [default: None]
The timeout (in milliseconds) to wait for an event. If unspecified
(or secified None), will wait forever for an event.
flags : bitfield (int) [default: POLLIN]
The event flags to poll for (any combination of POLLIN|POLLOUT).
The default is to check for incoming events (POLLIN).
Returns
-------
events : bitfield (int)
The events that are ready and waiting. Will be 0 if no events were ready
by the time timeout was reached.
"""
if self.closed:
raise ZMQError(ENOTSUP)
p = self._poller_class()
p.register(self, flags)
evts = dict(p.poll(timeout))
# return 0 if no events, otherwise return event bitfield
return evts.get(self, 0)
def __init__(self, context, sock_type):
self.context = context
self.socket_type = sock_type
self._zmq_socket = C.zmq_socket(context._zmq_ctx, sock_type)
if self._zmq_socket == ffi.NULL:
raise ZMQError()
self._closed = False
self._ref = self.context._add_socket(self)
def initialize_opt_pointer(option, value, length=0):
from zmq.sugar.constants import int_sockopts, \
int64_sockopts, \
bytes_sockopts
if option in int64_sockopts:
return value_int64_pointer(value)
elif option in int_sockopts:
return value_int_pointer(value)
elif option in bytes_sockopts:
return value_binary_data(value, length)
else:
raise ZMQError(zmq.EINVAL)
def value_from_opt_pointer(option, opt_pointer, length=0):
from zmq.sugar.constants import int_sockopts, \
int64_sockopts, \
bytes_sockopts
if option in int64_sockopts:
return int(opt_pointer[0])
elif option in int_sockopts:
return int(opt_pointer[0])
elif option in bytes_sockopts:
return ffi.buffer(opt_pointer, length)[:]
else:
raise ZMQError(zmq.EINVAL)
def new_pointer_from_opt(option, length=0):
from zmq.sugar.constants import int_sockopts, \
int64_sockopts, \
bytes_sockopts
if option in int64_sockopts:
return new_int64_pointer()
elif option in int_sockopts:
return new_int_pointer()
elif option in bytes_sockopts:
return new_binary_data(length)
else:
raise ZMQError(zmq.EINVAL)
def __init__(self, context=None, socket_type=None, shadow=None):
self.context = context
if shadow is not None:
if isinstance(shadow, Socket):
shadow = shadow.underlying
self._zmq_socket = ffi.cast("void *", shadow)
self._shadow = True
else:
self._shadow = False
self._zmq_socket = C.zmq_socket(context._zmq_ctx, socket_type)
if self._zmq_socket == ffi.NULL:
raise ZMQError()
self._closed = False
def bind(self, address):
if isinstance(address, unicode):
address_b = address.encode('utf8')
else:
address_b = address
if isinstance(address, bytes):
address = address_b.decode('utf8')
rc = C.zmq_bind(self._zmq_socket, address_b)
if rc < 0:
if IPC_PATH_MAX_LEN and C.zmq_errno() == errno_mod.ENAMETOOLONG:
path = address.split('://', 1)[-1]
msg = ('ipc path "{0}" is longer than {1} '
'characters (sizeof(sockaddr_un.sun_path)).'.format(
path, IPC_PATH_MAX_LEN))
raise ZMQError(C.zmq_errno(), msg=msg)
elif C.zmq_errno() == errno_mod.ENOENT:
path = address.split('://', 1)[-1]
msg = 'No such file or directory for ipc path "{0}".'.format(
path)
raise ZMQError(C.zmq_errno(), msg=msg)
else:
_check_rc(rc)
def __init__(self, context=None, socket_type=None, shadow=None):
self.context = context
if shadow is not None:
self._zmq_socket = ffi.cast("void *", shadow)
self._shadow = True
else:
self._shadow = False
self._zmq_socket = C.zmq_socket(context._zmq_ctx, socket_type)
if self._zmq_socket == ffi.NULL:
raise ZMQError()
self._closed = False
if context:
self._ref = context._add_socket(self)
def bind(self, address):
rc = C.zmq_bind(self._zmq_socket, address)
if rc < 0:
if IPC_PATH_MAX_LEN and C.zmq_errno() == errno_mod.ENAMETOOLONG:
# py3compat: address is bytes, but msg wants str
if str is unicode:
address = address.decode('utf-8', 'replace')
path = address.split('://', 1)[-1]
msg = ('ipc path "{0}" is longer than {1} '
'characters (sizeof(sockaddr_un.sun_path)).'.format(
path, IPC_PATH_MAX_LEN))
raise ZMQError(C.zmq_errno(), msg=msg)
else:
_check_rc(rc)
def get(self, option, length=0):
from zmq.sugar.constants import bytes_sockopts
if option in bytes_sockopts:
length = 255
try:
low_level_data = new_pointer_from_opt(option, length=length)
except ValueError:
raise ZMQError(EINVAL)
low_level_value_pointer = low_level_data[0]
low_level_sizet_pointer = low_level_data[1]
rc = C.zmq_getsockopt(self._zmq_socket, option,
low_level_value_pointer, low_level_sizet_pointer)
_check_rc(rc)
return value_from_opt_pointer(option, low_level_value_pointer)
def set(self, option, value):
length = None
str_value = False
if isinstance(value, str):
length = len(value)
str_value = True
try:
low_level_data = initialize_opt_pointer(option, value, length)
except ValueError:
if not str_value:
raise ZMQError(EINVAL)
raise TypeError("Invalid Option")
low_level_value_pointer = low_level_data[0]
low_level_sizet = low_level_data[1]
rc = C.zmq_setsockopt(self._zmq_socket, option,
ffi.cast('void*', low_level_value_pointer),
low_level_sizet)
_check_rc(rc)
def test_socket_connect_error(get_by_name, register_socket, engage):
("SocketManager().connect() should get by name, register then "
"connect to the given address.")
# Background: the zmq socket will raise a ZMQError when .connect is called
socket = get_by_name.return_value
socket.connect.side_effect = ZMQError('boom')
# Given a zmq mock
zmq = Mock()
# And a context
context = Mock()
# And a socket manager
manager = SocketManager(zmq, context)
# When I call connect
when_called = manager.connect.when.called_with('foobar', 'bad-address',
'some-mechanism')
# Then it should have raised a SocketConnectError
when_called.should.have.raised(SocketConnectError)
def start(self):
if self.watch == ffi.NULL:
self.watch = C.zmq_stopwatch_start()
else:
raise ZMQError('Stopwatch is already runing.')
