def __init__(
self,
flux_handle,
type_mask,
callback,
topic_glob="*",
match_tag=flux.constants.FLUX_MATCHTAG_NONE,
args=None,
):
self.flux_handle = flux_handle
self.callback = callback
self.args = args
self.wargs = ffi.new_handle(self)
if topic_glob is None or topic_glob == ffi.NULL:
topic_glob = ffi.NULL
elif isinstance(topic_glob, six.text_type):
topic_glob = topic_glob.encode("UTF-8")
elif not isinstance(topic_glob, six.binary_type):
errmsg = "Topic must be a string, not {}".format(type(topic_glob))
raise TypeError(errno.EINVAL, errmsg)
c_topic_glob = ffi.new("char[]", topic_glob)
match = ffi.new(
"struct flux_match *",
{"typemask": type_mask, "matchtag": match_tag, "topic_glob": c_topic_glob},
)
super(MessageWatcher, self).__init__(
raw.flux_msg_handler_create(
self.flux_handle.handle, match[0], message_handler_wrapper, self.wargs
)
)
def __init__(
self,
flux_handle,
type_mask,
callback,
topic_glob="*",
match_tag=flux.constants.FLUX_MATCHTAG_NONE,
args=None,
):
self.flux_handle = flux_handle
self.callback = callback
self.args = args
self.wargs = ffi.new_handle(self)
c_topic_glob = ffi.new("char[]", topic_glob)
match = ffi.new(
"struct flux_match *",
{
"typemask": type_mask,
"matchtag": match_tag,
"topic_glob": c_topic_glob
},
)
super(MessageWatcher, self).__init__(
raw.flux_msg_handler_create(self.flux_handle.handle, match[0],
message_handler_wrapper, self.wargs))
def __init__(
self,
flux_handle,
type_mask,
callback,
topic_glob="*",
match_tag=flux.constants.FLUX_MATCHTAG_NONE,
args=None,
):
self.callback = callback
self.args = args
self.wargs = ffi.new_handle(self)
if topic_glob is None or topic_glob == ffi.NULL:
topic_glob = ffi.NULL
elif isinstance(topic_glob, str):
topic_glob = topic_glob.encode("UTF-8")
elif not isinstance(topic_glob, bytes):
errmsg = "Topic must be a string, not {}".format(type(topic_glob))
raise TypeError(errno.EINVAL, errmsg)
c_topic_glob = ffi.new("char[]", topic_glob)
match = ffi.new(
"struct flux_match *",
{"typemask": type_mask, "matchtag": match_tag, "topic_glob": c_topic_glob},
)
super(MessageWatcher, self).__init__(
flux_handle,
raw.flux_msg_handler_create(
flux_handle.handle,
match[0],
lib.message_handler_wrapper,
self.wargs,
),
)
def then(self, callback, args):
def cb_then_wrapper(trash, arg):
rpc_handle = ffi.from_handle(arg)
callback(rpc_handle, rpc_handle.then_args)
# Save the callback to keep it from getting collected
self.then_cb = ffi.callback('flux_then_f', cb_then_wrapper)
self.then_args = args
return self.pimpl.then(self.then_cb, ffi.new_handle(self))
def then(self, callback, args):
def cb_then_wrapper(trash, arg):
rpc_handle = ffi.from_handle(arg)
callback(rpc_handle, rpc_handle.then_args)
# Save the callback to keep it from getting collected
self.then_cb = ffi.callback('flux_then_f', cb_then_wrapper)
self.then_args = args
return self.pimpl.then(self.then_cb, ffi.new_handle(self))
def __init__(self, flux_handle, after, callback, repeat=0, args=None, ):
self.fh = flux_handle
self.after = after
self.repeat = repeat
self.cb = callback
self.args = args
self.handle = None
wargs = ffi.new_handle(self)
self.handle = raw.flux_timer_watcher_create(
float(after), float(repeat), timeout_handler_wrapper, wargs)
def __init__(self, flux_handle, fd_int, events, callback, args=None):
self.fh = flux_handle
self.fd_int = fd_int
self.events = events
self.cb = callback
self.args = args
self.handle = None
wargs = ffi.new_handle(self)
self.handle = raw.flux_fd_watcher_create(
raw.flux_get_reactor(flux_handle),
self.fd_int, self.events, fd_handler_wrapper, wargs)
def __init__(self, flux_handle, fd_int, events, callback, args=None):
self.flux_handle = flux_handle
self.fd_int = fd_int
self.events = events
self.callback = callback
self.args = args
self.handle = None
self.wargs = ffi.new_handle(self)
super(FDWatcher, self).__init__(
raw.flux_fd_watcher_create(raw.flux_get_reactor(flux_handle),
self.fd_int, self.events,
fd_handler_wrapper, self.wargs))
def then(self, callback, arg=None, timeout=-1.0):
if self in _THEN_HANDLES:
raise EnvironmentError(
errno.EEXIST, "then callback already exists for this future")
self.then_cb = callback
self.then_arg = arg
self.cb_handle = ffi.new_handle(self)
self.pimpl.then(timeout, lib.continuation_callback, self.cb_handle)
# ensure that this future object is not garbage collected with a
# callback outstanding. Particularly important for anonymous calls.
# For example, `f.rpc.('topic').then(cb)`
_THEN_HANDLES.add(self)
def __init__(self, flux_handle, after, callback, repeat=0, args=None, ):
self.flux_handle = flux_handle
self.after = after
self.repeat = repeat
self.callback = callback
self.args = args
self.handle = None
self.wargs = ffi.new_handle(self)
super(TimerWatcher, self).__init__(
raw.flux_timer_watcher_create(
raw.flux_get_reactor(flux_handle),
float(after),
float(repeat),
timeout_handler_wrapper,
self.wargs))
def then(self, callback, arg=None, timeout=-1.0):
if self in _THEN_HANDLES:
raise EnvironmentError(
errno.EEXIST, "then callback already exists for this future"
)
self.then_cb = callback
self.then_arg = arg
self.cb_handle = ffi.new_handle(self)
self.pimpl.then(timeout, lib.continuation_callback, self.cb_handle)
# ensure that this future object is not garbage collected with a
# callback outstanding. Particularly important for anonymous calls.
# For example, `f.rpc.('topic').then(cb)`
_THEN_HANDLES.add(self)
def __init__(self, flux_handle, after, callback, repeat=0, args=None):
self.flux_handle = flux_handle
self.after = after
self.repeat = repeat
self.callback = callback
self.args = args
self.handle = None
self.wargs = ffi.new_handle(self)
super(TimerWatcher, self).__init__(
raw.flux_timer_watcher_create(
raw.flux_get_reactor(flux_handle),
float(after),
float(repeat),
lib.timeout_handler_wrapper,
self.wargs,
))
def __init__(self, flux_handle, type_mask, callback,
topic_glob='*',
match_tag=flux.FLUX_MATCHTAG_NONE,
args=None):
self.handle = None
self.fh = flux_handle
self.cb = callback
self.args = args
self.wargs = ffi.new_handle(self)
c_topic_glob = ffi.new('char[]', topic_glob)
match = ffi.new('struct flux_match *', {
'typemask': type_mask,
'matchtag': match_tag,
'topic_glob': c_topic_glob,
})
self.handle = raw.flux_msg_handler_create(self.fh.handle, match[0],
message_handler_wrapper,
self.wargs)
def __init__(self, flux_handle, signal_int, callback, args=None):
self.flux_handle = flux_handle
self.signal_int = signal_int
self.callback = callback
self.args = args
self.handle = None
self.wargs = ffi.new_handle(self)
super(SignalWatcher, self).__init__(
raw.flux_signal_watcher_create(
raw.flux_get_reactor(flux_handle),
self.signal_int,
lib.signal_handler_wrapper,
self.wargs,
))
# N.B.: check for error only after SignalWatcher object fully
# initialized to avoid 'no attribute self.handle' in __del__
# method.
if signal_int < 1 or signal_int >= signal.NSIG:
raise OSError(errno.EINVAL, "invalid signal number")
def __init__(self, flux_handle, type_mask, callback,
topic_glob='*',
match_tag=flux.constants.FLUX_MATCHTAG_NONE,
args=None):
self.flux_handle = flux_handle
self.callback = callback
self.args = args
self.wargs = ffi.new_handle(self)
c_topic_glob = ffi.new('char[]', topic_glob)
match = ffi.new('struct flux_match *', {
'typemask': type_mask,
'matchtag': match_tag,
'topic_glob': c_topic_glob,
})
super(MessageWatcher, self).__init__(
raw.flux_msg_handler_create(
self.flux_handle.handle,
match[0],
message_handler_wrapper,
self.wargs))
def __init__(self, flux_handle, type_mask, callback,
topic_glob='*',
match_tag=flux.FLUX_MATCHTAG_NONE,
bsize=0,
args=None):
self.handle = None
self.fh = flux_handle
self.cb = callback
self.args = args
wargs = ffi.new_handle(self)
c_topic_glob = ffi.new('char[]', topic_glob)
match = ffi.new('struct flux_match *', {
'typemask': type_mask,
'matchtag': match_tag,
'bsize': bsize,
'topic_glob': c_topic_glob,
})
self.handle = raw.flux_msg_watcher_create(match[0],
message_handler_wrapper,
wargs)
def then(self, callback, arg=None, timeout=-1.0):
if self in _THEN_HANDLES:
raise EnvironmentError(
errno.EEXIST, "then callback already exists for this future")
if callback is None:
raise ValueError("Callback cannot be None")
self.then_cb = callback
self.then_arg = arg
self.cb_handle = ffi.new_handle(self)
self.pimpl.then(timeout, lib.continuation_callback, self.cb_handle)
# ensure that this future object is not garbage collected with a
# callback outstanding. Particularly important for anonymous calls and
# streaming RPCs. For example, `f.rpc('topic').then(cb)`
_THEN_HANDLES[self] = 1
# return self to enable further chaining of the future.
# For example `f.rpc('topic').then(cb).wait_for(-1)
return self
