def test_06_blocking_methods(self): future = Future(self.f.future_create(ffi.NULL, ffi.NULL)) self.assertFalse(future.is_ready()) with self.assertRaises(EnvironmentError) as cm: future.wait_for(timeout=0) self.assertEqual(cm.exception.errno, errno.ETIMEDOUT) future.pimpl.fulfill(ffi.NULL, ffi.NULL) self.assertTrue(future.is_ready()) try: future.wait_for(0) except EnvironmentError as e: self.fail("future.wait_for raised an unexpected exception: {}".format(e))
def cancel_async(flux_handle, jobid, reason=None): """Cancel a pending or or running job asynchronously :param flux_handle: handle for Flux broker from flux.Flux() :type flux_handle: Flux :param jobid: the job ID of the job to cancel :returns: a Future :rtype: Future """ if not reason: reason = ffi.NULL return Future(RAW.cancel(flux_handle, int(jobid), reason))
def kill_async(flux_handle, jobid, signum=None): """Send a signal to a running job asynchronously :param flux_handle: handle for Flux broker from flux.Flux() :type flux_handle: Flux :param jobid: the job ID of the job to kill :param signum: signal to send (default SIGTERM) :returns: a Future :rtype: Future """ if not signum: signum = signal.SIGTERM return Future(RAW.kill(flux_handle, int(jobid), signum))
def submit_async(flux_handle, jobspec, priority=lib.FLUX_JOB_PRIORITY_DEFAULT, flags=0): if isinstance(jobspec, six.text_type): jobspec = jobspec.encode("utf-8") elif jobspec is None or jobspec == ffi.NULL: # catch this here rather than in C for a better error message raise EnvironmentError(errno.EINVAL, "jobspec must not be None/NULL") elif not isinstance(jobspec, six.binary_type): raise TypeError("jobpsec must be a string (either binary or unicode)") future_handle = RAW.submit(flux_handle, jobspec, priority, flags) return Future(future_handle)
def cancel_async(flux_handle: Flux, jobid: Union[JobID, int], reason: Optional[str] = None): """Cancel a pending or or running job asynchronously Arguments: flux_handle: handle for Flux broker from flux.Flux() jobid: the job ID of the job to cancel reason: the textual reason associated with the cancelation Returns: Future: a future fulfilled when the cancelation completes """ if not reason: reason = ffi.NULL return Future(RAW.cancel(flux_handle, int(jobid), reason))
def test_08_future_from_future(self): orig_fut = Future(self.f.future_create(ffi.NULL, ffi.NULL)) new_fut = Future(orig_fut) self.assertFalse(new_fut.is_ready()) orig_fut.pimpl.fulfill(ffi.NULL, ffi.NULL) self.assertTrue(new_fut.is_ready()) orig_fut = self.f.rpc("broker.ping", payload=self.ping_payload) new_fut = Future(orig_fut) del orig_fut resp_payload = new_fut.get() # Future's `get` returns `None`, so just test that it is fulfilled self.assertTrue(new_fut.is_ready()) orig_fut = self.f.rpc("foo.bar") new_fut = Future(orig_fut) del orig_fut with self.assertRaises(EnvironmentError): resp_payload = new_fut.get()
import flux from flux.constants import FLUX_MSGTYPE_REQUEST from flux.future import Future parser = argparse.ArgumentParser() parser.add_argument('--fail', action='store_true') args = parser.parse_args() def validate_cb(fh, t, msg, arg): payload = {"success": not args.fail} if args.fail: payload['errstr'] = "Failed for test purposes" fh.respond(msg, payload) print(f"Responded to vlidation request with {payload}") fh.reactor_stop() fh = flux.Flux() service_reg_fut = Future(fh.service_register("dws")) watcher = fh.msg_watcher_create(validate_cb, FLUX_MSGTYPE_REQUEST, "dws.validate") watcher.start() service_reg_fut.get() print("DWS service registered") fh.reactor_run() watcher.stop() watcher.destroy()
def service_unregister(self, name): return Future(self.flux_service_unregister(name))