Class: ZMQ::Poller

Inherits:
Object
  • Object
show all
Defined in:
lib/zmq/poller.rb,
ext/rbczmq/poller.c

Instance Method Summary collapse

Instance Method Details

#poll(1) ⇒ Fixnum

Multiplexes input/output events in a level-triggered fashion over a set of registered sockets.

Examples

Supported timeout values :

-1 : block until any sockets are ready (no timeout)

0  : non-blocking poll
1  : block for up to 1 second (1000ms)

0.1 : block for up to 0.1 seconds (100ms)

poller = ZMQ::Poller.new             =>  ZMQ::Poller
poller.register(req)                 =>  true
poller.poll(1)                       =>  Fixnum

Returns:

  • (Fixnum) 


135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'ext/rbczmq/poller.c', line 135

VALUE rb_czmq_poller_poll(int argc, VALUE *argv, VALUE obj)
{
    VALUE tmout;
    size_t timeout;
    struct nogvl_poll_args args;
    int rc;
    ZmqGetPoller(obj);
    rb_scan_args(argc, argv, "01", &tmout);
    if (NIL_P(tmout)) tmout = INT2NUM(0);
    if (TYPE(tmout) != T_FIXNUM && TYPE(tmout) != T_FLOAT) rb_raise(rb_eTypeError, "wrong timeout type %s (expected Fixnum or Float)", RSTRING_PTR(rb_obj_as_string(tmout)));
    if (poller->poll_size == 0) return INT2NUM(0);
    if (poller->dirty == true) {
        rc = rb_czmq_poller_rebuild_pollset(poller);
        if (rc == -1) rb_raise(rb_eZmqError, "failed in rebuilding the pollset!");
    }
    timeout = (size_t)(((TYPE(tmout) == T_FIXNUM) ? FIX2LONG(tmout) : RFLOAT_VALUE(tmout)) * 1000); 
    if (timeout < 0) timeout = -1;

    args.items = poller->pollset;
    args.nitems = poller->poll_size;
    args.timeout = (long)timeout;

    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_poll, (void *)&args, RUBY_UBF_IO, 0);
    ZmqAssert(rc);
    if (rc == 0) {
        rb_ary_clear(poller->readables);
        rb_ary_clear(poller->writables);
    } else {
        rb_czmq_poller_rebuild_selectables(poller);
    }
    return INT2NUM(rc);
}

#poll_nonblock ⇒ Object

API sugar to poll non-blocking. Returns immediately if there’s no items in a ready state.



7
8
9
 
# File 'lib/zmq/poller.rb', line 7

def poll_nonblock
  poll(0)
end

#readables ⇒ Array

All poll items in a readable state after the last poll.

Examples

poller = ZMQ::Poller.new                          =>  ZMQ::Poller
poller.register(ZMQ::Pollitem(req, ZMQ::POLLIN))  =>  true
poller.poll(1)                                    =>  1
poller.readables                                  =>  [req]

Returns:

  • (Array) 


250
251
252
253
254
 
# File 'ext/rbczmq/poller.c', line 250

VALUE rb_czmq_poller_readables(VALUE obj)
{
    ZmqGetPoller(obj);
    return poller->readables;
}

#register(pollitem) ⇒ Boolean

Registers a poll item for a particular I/O event (ZMQ::POLLIN or ZMQ::POLLOUT) with this poller instance. ZMQ::Socket or Ruby IO instances will automatically be coerced to ZMQ::Pollitem instances with the default events mask (ZMQ::POLLIN | ZMQ::POLLOUT)

Examples

Supported events :

ZMQ::POLLIN : readable state ZMQ::POLLOUT : writable state

poller = ZMQ::Poller.new                              =>  ZMQ::Poller
poller.register(ZMQ::Pollitem.new(req, ZMQ::POLLIN))  =>  true

poller.register(pub_socket)                           =>  true
poller.register(STDIN)                                =>  true

Returns:

  • (Boolean) 


190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'ext/rbczmq/poller.c', line 190

VALUE rb_czmq_poller_register(VALUE obj, VALUE pollable)
{
    ZmqGetPoller(obj);
    pollable = rb_czmq_pollitem_coerce(pollable);
    ZmqGetPollitem(pollable);
    /* Let pollable item be verbose if poller is verbose */
    if (poller->verbose == true) rb_czmq_pollitem_set_verbose(pollable, Qtrue);
    rb_ary_push(poller->pollables, pollable);
    poller->poll_size++;
    poller->dirty = true;
    return pollable;
}

#register_readable(pollable) ⇒ Object

API sugar for registering a ZMQ::Socket or IO for readability



13
14
15
 
# File 'lib/zmq/poller.rb', line 13

def register_readable(pollable)
  register ZMQ::Pollitem.new(pollable, ZMQ::POLLIN)
end

#register_writable(pollable) ⇒ Object

API sugar for registering a ZMQ::Socket or IO for writability



19
20
21
 
# File 'lib/zmq/poller.rb', line 19

def register_writable(pollable)
  register ZMQ::Pollitem.new(pollable, ZMQ::POLLOUT)
end

#remove(pollitem) ⇒ Boolean

Removes a poll item from this poller. Deregisters the socket for any previously registered events. Note that we match on both poll items as well as pollable entities for all registered poll items.

Examples

poller = ZMQ::Poller.new             =>  ZMQ::Poller
poller.register(req)                 =>  true
poller.remove(req)                   =>  true

Returns:

  • (Boolean) 


217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'ext/rbczmq/poller.c', line 217

VALUE rb_czmq_poller_remove(VALUE obj, VALUE pollable)
{
    int pos;
    VALUE rpollable;
    ZmqGetPoller(obj);
    pollable = rb_czmq_pollitem_coerce(pollable);
    ZmqGetPollitem(pollable);
    for (pos = 0; pos < poller->poll_size; pos++) {
        rpollable = rb_ary_entry(poller->pollables, (long)pos);
        if (pollable == rpollable || rb_czmq_pollitem_pollable(pollable) == rb_czmq_pollitem_pollable(rpollable)) {
            rb_ary_delete(poller->pollables, rpollable);
            poller->poll_size--;
            poller->dirty = true;
            return rpollable;
        }
    }
    return Qfalse;
}

#verbose=(true) ⇒ nil

Logs poller activity to stdout - useful for debugging, but can be quite noisy with lots of activity.

Examples

poller = ZMQ::Poller.new    =>   ZMQ::Poller
poller.verbose = true   =>    nil

Returns:

  • (nil) 


288
289
290
291
292
293
294
295
 
# File 'ext/rbczmq/poller.c', line 288

static VALUE rb_czmq_poller_set_verbose(VALUE obj, VALUE level)
{
    bool vlevel;
    ZmqGetPoller(obj);
    vlevel = (level == Qtrue) ? true : false;
    poller->verbose = vlevel;
    return Qnil;
}

#writables ⇒ Array

All poll items in a writable state after the last poll.

Examples

poller = ZMQ::Poller.new                           =>  ZMQ::Poller
poller.register(ZMQ::Pollitem(req, ZMQ::POLLOUT))  =>  true
poller.poll(1)                                     =>  1
poller.writables                                   =>  [req]

Returns:

  • (Array) 


270
271
272
273
274
 
# File 'ext/rbczmq/poller.c', line 270

VALUE rb_czmq_poller_writables(VALUE obj)
{
    ZmqGetPoller(obj);
    return poller->writables;
}