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.')