本文整理汇总了Python中zmq.POLLOUT属性的典型用法代码示例。如果您正苦于以下问题:Python zmq.POLLOUT属性的具体用法?Python zmq.POLLOUT怎么用?Python zmq.POLLOUT使用的例子?那么, 这里精选的属性代码示例或许可以为您提供帮助。您也可以进一步了解该属性所在类zmq
的用法示例。
在下文中一共展示了zmq.POLLOUT属性的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def __init__(self, ip_address, port_range):
"""
Parameters
----------
ip_address: str
IP address of the client (where Parsl runs)
port_range: tuple(int, int)
Port range for the comms between client and interchange
"""
self.context = zmq.Context()
self.zmq_socket = self.context.socket(zmq.DEALER)
self.zmq_socket.set_hwm(0)
self.port = self.zmq_socket.bind_to_random_port("tcp://{}".format(ip_address),
min_port=port_range[0],
max_port=port_range[1])
self.poller = zmq.Poller()
self.poller.register(self.zmq_socket, zmq.POLLOUT)
示例2: _handle_events
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def _handle_events(self, fd, events):
"""This method is the actual handler for IOLoop, that gets called whenever
an event on my socket is posted. It dispatches to _handle_recv, etc."""
if not self.socket:
gen_log.warning("Got events for closed stream %s", fd)
return
zmq_events = self.socket.EVENTS
try:
# dispatch events:
if zmq_events & zmq.POLLIN and self.receiving():
self._handle_recv()
if not self.socket:
return
if zmq_events & zmq.POLLOUT and self.sending():
self._handle_send()
if not self.socket:
return
# rebuild the poll state
self._rebuild_io_state()
except Exception:
gen_log.error("Uncaught exception in zmqstream callback",
exc_info=True)
raise
示例3: put
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def put(self, message):
""" This function needs to be fast at the same time aware of the possibility of
ZMQ pipes overflowing.
The timeout increases slowly if contention is detected on ZMQ pipes.
We could set copy=False and get slightly better latency but this results
in ZMQ sockets reaching a broken state once there are ~10k tasks in flight.
This issue can be magnified if each the serialized buffer itself is larger.
"""
timeout_ms = 0
while True:
socks = dict(self.poller.poll(timeout=timeout_ms))
if self.zmq_socket in socks and socks[self.zmq_socket] == zmq.POLLOUT:
# The copy option adds latency but reduces the risk of ZMQ overflow
self.zmq_socket.send_pyobj(message, copy=True)
return
else:
timeout_ms += 1
logger.debug("Not sending due to full zmq pipe, timeout: {} ms".format(timeout_ms))
示例4: put
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def put(self, message, max_timeout=1000):
""" This function needs to be fast at the same time aware of the possibility of
ZMQ pipes overflowing.
The timeout increases slowly if contention is detected on ZMQ pipes.
We could set copy=False and get slightly better latency but this results
in ZMQ sockets reaching a broken state once there are ~10k tasks in flight.
This issue can be magnified if each the serialized buffer itself is larger.
Parameters
----------
message : py object
Python object to send
max_timeout : int
Max timeout in milliseconds that we will wait for before raising an exception
Raises
------
zmq.EAGAIN if the send failed.
"""
timeout_ms = 0
current_wait = 0
logger.info("Putting task into queue")
while current_wait < max_timeout:
socks = dict(self.poller.poll(timeout=timeout_ms))
if self.zmq_socket in socks and socks[self.zmq_socket] == zmq.POLLOUT:
# The copy option adds latency but reduces the risk of ZMQ overflow
self.zmq_socket.send_pyobj(message, copy=True)
return
else:
timeout_ms += 1
logger.debug("Not sending due to full zmq pipe, timeout: {} ms".format(timeout_ms))
current_wait += timeout_ms
# Send has failed.
logger.debug("Remote side has been unresponsive for {}".format(current_wait))
raise zmq.error.Again
示例5: send_multipart
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def send_multipart(self, msg, flags=0, copy=True, track=False, callback=None, **kwargs):
"""Send a multipart message, optionally also register a new callback for sends.
See zmq.socket.send_multipart for details.
"""
kwargs.update(dict(flags=flags, copy=copy, track=track))
self._send_queue.put((msg, kwargs))
callback = callback or self._send_callback
if callback is not None:
self.on_send(callback)
else:
# noop callback
self.on_send(lambda *args: None)
self._add_io_state(zmq.POLLOUT)
示例6: _rebuild_io_state
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def _rebuild_io_state(self):
"""rebuild io state based on self.sending() and receiving()"""
if self.socket is None:
return
state = 0
if self.receiving():
state |= zmq.POLLIN
if self.sending():
state |= zmq.POLLOUT
self._state = state
self._update_handler(state)
示例7: _add_send_event
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def _add_send_event(self, kind, msg=None, kwargs=None, future=None):
"""Add a send event, returning the corresponding Future"""
f = future or self._Future()
if kind.startswith('send') and kwargs.get('flags', 0) & _zmq.DONTWAIT:
# short-circuit non-blocking calls
send = getattr(self._shadow_sock, kind)
try:
r = send(msg, **kwargs)
except Exception as e:
f.set_exception(e)
else:
f.set_result(r)
return f
# we add it to the list of futures before we add the timeout as the
# timeout will remove the future from recv_futures to avoid leaks
self._send_futures.append(
_FutureEvent(f, kind, kwargs=kwargs, msg=msg)
)
# Don't let the Future sit in _send_futures after it's done
f.add_done_callback(lambda f: self._remove_finished_future(f, self._send_futures))
if hasattr(_zmq, 'SNDTIMEO'):
timeout_ms = self._shadow_sock.sndtimeo
if timeout_ms >= 0:
self._add_timeout(f, timeout_ms * 1e-3)
if self._shadow_sock.EVENTS & POLLOUT:
# send immediately if we can
self._handle_send()
if self._send_futures:
self._add_io_state(POLLOUT)
return f
示例8: _handle_send
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def _handle_send(self):
if not self._shadow_sock.EVENTS & POLLOUT:
# event triggered, but state may have been changed between trigger and callback
return
f = None
while self._send_futures:
f, kind, kwargs, msg = self._send_futures.popleft()
f._pyzmq_popped = True
# skip any cancelled futures
if f.done():
f = None
else:
break
if not self._send_futures:
self._drop_io_state(POLLOUT)
if f is None:
return
if kind == 'poll':
# on poll event, just signal ready, nothing else.
f.set_result(None)
return
elif kind == 'send_multipart':
send = self._shadow_sock.send_multipart
elif kind == 'send':
send = self._shadow_sock.send
else:
raise ValueError("Unhandled send event type: %r" % kind)
kwargs['flags'] |= _zmq.DONTWAIT
try:
result = send(msg, **kwargs)
except Exception as e:
f.set_exception(e)
else:
f.set_result(result)
# event masking from ZMQStream
示例9: test_poll
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def test_poll(self):
a,b = self.create_bound_pair()
tic = time.time()
evt = a.poll(POLL_TIMEOUT)
self.assertEqual(evt, 0)
evt = a.poll(POLL_TIMEOUT, zmq.POLLOUT)
self.assertEqual(evt, zmq.POLLOUT)
msg = b'hi'
a.send(msg)
evt = b.poll(POLL_TIMEOUT)
self.assertEqual(evt, zmq.POLLIN)
msg2 = self.recv(b)
evt = b.poll(POLL_TIMEOUT)
self.assertEqual(evt, 0)
self.assertEqual(msg2, msg)
示例10: test_poll_raw
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def test_poll_raw(self):
@asyncio.coroutine
def test():
p = zaio.Poller()
# make a pipe
r, w = os.pipe()
r = os.fdopen(r, 'rb')
w = os.fdopen(w, 'wb')
# POLLOUT
p.register(r, zmq.POLLIN)
p.register(w, zmq.POLLOUT)
evts = yield from p.poll(timeout=1)
evts = dict(evts)
assert r.fileno() not in evts
assert w.fileno() in evts
assert evts[w.fileno()] == zmq.POLLOUT
# POLLIN
p.unregister(w)
w.write(b'x')
w.flush()
evts = yield from p.poll(timeout=1000)
evts = dict(evts)
assert r.fileno() in evts
assert evts[r.fileno()] == zmq.POLLIN
assert r.read(1) == b'x'
r.close()
w.close()
loop = asyncio.get_event_loop()
loop.run_until_complete(test())
示例11: test_pair
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def test_pair(self):
s1, s2 = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
# Sleep to allow sockets to connect.
wait()
poller = self.Poller()
poller.register(s1, zmq.POLLIN|zmq.POLLOUT)
poller.register(s2, zmq.POLLIN|zmq.POLLOUT)
# Poll result should contain both sockets
socks = dict(poller.poll())
# Now make sure that both are send ready.
self.assertEqual(socks[s1], zmq.POLLOUT)
self.assertEqual(socks[s2], zmq.POLLOUT)
# Now do a send on both, wait and test for zmq.POLLOUT|zmq.POLLIN
s1.send(b'msg1')
s2.send(b'msg2')
wait()
socks = dict(poller.poll())
self.assertEqual(socks[s1], zmq.POLLOUT|zmq.POLLIN)
self.assertEqual(socks[s2], zmq.POLLOUT|zmq.POLLIN)
# Make sure that both are in POLLOUT after recv.
s1.recv()
s2.recv()
socks = dict(poller.poll())
self.assertEqual(socks[s1], zmq.POLLOUT)
self.assertEqual(socks[s2], zmq.POLLOUT)
poller.unregister(s1)
poller.unregister(s2)
示例12: test_pubsub
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def test_pubsub(self):
s1, s2 = self.create_bound_pair(zmq.PUB, zmq.SUB)
s2.setsockopt(zmq.SUBSCRIBE, b'')
# Sleep to allow sockets to connect.
wait()
poller = self.Poller()
poller.register(s1, zmq.POLLIN|zmq.POLLOUT)
poller.register(s2, zmq.POLLIN)
# Now make sure that both are send ready.
socks = dict(poller.poll())
self.assertEqual(socks[s1], zmq.POLLOUT)
self.assertEqual(s2 in socks, 0)
# Make sure that s1 stays in POLLOUT after a send.
s1.send(b'msg1')
socks = dict(poller.poll())
self.assertEqual(socks[s1], zmq.POLLOUT)
# Make sure that s2 is POLLIN after waiting.
wait()
socks = dict(poller.poll())
self.assertEqual(socks[s2], zmq.POLLIN)
# Make sure that s2 goes into 0 after recv.
s2.recv()
socks = dict(poller.poll())
self.assertEqual(s2 in socks, 0)
poller.unregister(s1)
poller.unregister(s2)
示例13: test_poll_raw
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def test_poll_raw(self):
@gen.coroutine
def test():
p = future.Poller()
# make a pipe
r, w = os.pipe()
r = os.fdopen(r, 'rb')
w = os.fdopen(w, 'wb')
# POLLOUT
p.register(r, zmq.POLLIN)
p.register(w, zmq.POLLOUT)
evts = yield p.poll(timeout=1)
evts = dict(evts)
assert r.fileno() not in evts
assert w.fileno() in evts
assert evts[w.fileno()] == zmq.POLLOUT
# POLLIN
p.unregister(w)
w.write(b'x')
w.flush()
evts = yield p.poll(timeout=1000)
evts = dict(evts)
assert r.fileno() in evts
assert evts[r.fileno()] == zmq.POLLIN
assert r.read(1) == b'x'
r.close()
w.close()
self.loop.run_sync(test)
示例14: __state_changed
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def __state_changed(self, event=None, _evtype=None):
if self.closed:
self.__cleanup_events()
return
try:
# avoid triggering __state_changed from inside __state_changed
events = super(_Socket, self).getsockopt(zmq.EVENTS)
except zmq.ZMQError as exc:
self.__writable.set_exception(exc)
self.__readable.set_exception(exc)
else:
if events & zmq.POLLOUT:
self.__writable.set()
if events & zmq.POLLIN:
self.__readable.set()
示例15: _wait_write
# 需要导入模块: import zmq [as 别名]
# 或者: from zmq import POLLOUT [as 别名]
def _wait_write(self):
assert self.__writable.ready(), "Only one greenlet can be waiting on this event"
self.__writable = AsyncResult()
# timeout is because libzmq cannot be trusted to properly signal a new send event:
# this is effectively a maximum poll interval of 1s
tic = time.time()
dt = self._gevent_bug_timeout
if dt:
timeout = gevent.Timeout(seconds=dt)
else:
timeout = None
try:
if timeout:
timeout.start()
self.__writable.get(block=True)
except gevent.Timeout as t:
if t is not timeout:
raise
toc = time.time()
# gevent bug: get can raise timeout even on clean return
# don't display zmq bug warning for gevent bug (this is getting ridiculous)
if self._debug_gevent and timeout and toc-tic > dt and \
self.getsockopt(zmq.EVENTS) & zmq.POLLOUT:
print("BUG: gevent may have missed a libzmq send event on %i!" % self.FD, file=sys.stderr)
finally:
if timeout:
timeout.cancel()
self.__writable.set()