Software `/` code `/` prosody

Annotate

util/async.lua @ 11961:542a9a503073

util.async: Add sleep() method with configurable scheduling backend No scheduler set by default, so it will error (we plan to initialize it in util.startup). We wanted to avoid a hard dependency on util.timer (which in turn depends on network backends, etc.), and we didn't add timer.sleep() because we didn't want to add a hard dependency on util.async for things that don't need it.

author	Matthew Wild <mwild1@gmail.com>
date	Mon, 29 Nov 2021 14:11:24 +0000
parent	10931:558f0555ba02
child	11962:9a70a543c727

rev	line source
8788 7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	1 local logger = require "util.logger";
7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	2 local log = logger.init("util.async");
8600 96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	3 local new_id = require "util.id".short;
9562 acf74ad0b795 Many things: switch from hacky multi-arg xpcall implementations to a standard util.xpcall Matthew Wild <mwild1@gmail.com> parents: 9177 diff changeset	4 local xpcall = require "util.xpcall".xpcall;
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	5
8407 f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	6 local function checkthread()
8408 b751bee6a829 util.async: Fix thread check to work correctly in Lua 5.2 Kim Alvefur <zash@zash.se> parents: 8407 diff changeset	7 local thread, main = coroutine.running();
b751bee6a829 util.async: Fix thread check to work correctly in Lua 5.2 Kim Alvefur <zash@zash.se> parents: 8407 diff changeset	8 if not thread or main then
8407 f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	9 error("Not running in an async context, see https://prosody.im/doc/developers/util/async");
f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	10 end
f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	11 return thread;
f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	12 end
f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	13
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	14 -- Configurable functions
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	15 local schedule_task = nil; -- schedule_task(seconds, callback)
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	16
8627 24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	17 local function runner_from_thread(thread)
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	18 local level = 0;
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	19 -- Find the 'level' of the top-most function (0 == current level, 1 == caller, ...)
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	20 while debug.getinfo(thread, level, "") do level = level + 1; end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	21 local name, runner = debug.getlocal(thread, level-1, 1);
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	22 if name ~= "self" or type(runner) ~= "table" or runner.thread ~= thread then
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	23 return nil;
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	24 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	25 return runner;
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	26 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	27
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	28 local function call_watcher(runner, watcher_name, ...)
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	29 local watcher = runner.watchers[watcher_name];
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	30 if not watcher then
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	31 return false;
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	32 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	33 runner:log("debug", "Calling '%s' watcher", watcher_name);
9562 acf74ad0b795 Many things: switch from hacky multi-arg xpcall implementations to a standard util.xpcall Matthew Wild <mwild1@gmail.com> parents: 9177 diff changeset	34 local ok, err = xpcall(watcher, debug.traceback, runner, ...);
8627 24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	35 if not ok then
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	36 runner:log("error", "Error in '%s' watcher: %s", watcher_name, err);
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	37 return nil, err;
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	38 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	39 return true;
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	40 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	41
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	42 local function runner_continue(thread)
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	43 -- ASSUMPTION: runner is in 'waiting' state (but we don't have the runner to know for sure)
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	44 if coroutine.status(thread) ~= "suspended" then -- This should suffice
8629 ddb04cacb8b1 util.async: Bump log warnings to error level Matthew Wild <mwild1@gmail.com> parents: 8627 diff changeset	45 log("error", "unexpected async state: thread not suspended");
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	46 return false;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	47 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	48 local ok, state, runner = coroutine.resume(thread);
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	49 if not ok then
8609 9f6ab206d741 util.async: Ensure runner is left in correct state after out-of-main-loop error (+tests) Matthew Wild <mwild1@gmail.com> parents: 8604 diff changeset	50 local err = state;
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	51 -- Running the coroutine failed, which means we have to find the runner manually,
649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	52 -- in order to inform the error handler
8627 24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	53 runner = runner_from_thread(thread);
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	54 if not runner then
8629 ddb04cacb8b1 util.async: Bump log warnings to error level Matthew Wild <mwild1@gmail.com> parents: 8627 diff changeset	55 log("error", "unexpected async state: unable to locate runner during error handling");
8613 dbb4788db8e3 util.async: Convert asserts to a return false (same as other unexpected behaviour) Matthew Wild <mwild1@gmail.com> parents: 8611 diff changeset	56 return false;
dbb4788db8e3 util.async: Convert asserts to a return false (same as other unexpected behaviour) Matthew Wild <mwild1@gmail.com> parents: 8611 diff changeset	57 end
8627 24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	58 call_watcher(runner, "error", debug.traceback(thread, err));
10930 69a4b0e3565f util.async: Call coroutine.close() on dead threads (Lua 5.4) Matthew Wild <mwild1@gmail.com> parents: 10928 diff changeset	59 runner.state = "ready";
8616 a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	60 return runner:run();
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	61 elseif state == "ready" then
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	62 -- If state is 'ready', it is our responsibility to update runner.state from 'waiting'.
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	63 -- We also have to :run(), because the queue might have further items that will not be
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	64 -- processed otherwise. FIXME: It's probably best to do this in a nexttick (0 timer).
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	65 runner.state = "ready";
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	66 runner:run();
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	67 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	68 return true;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	69 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	70
5790 959163e4d631 util.async: Make functions local Matthew Wild <mwild1@gmail.com> parents: 5788 diff changeset	71 local function waiter(num)
8407 f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	72 local thread = checkthread();
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	73 num = num or 1;
5792 aac4c6147647 util.async: waiter: Remove restriction about wait() being called before done() Matthew Wild <mwild1@gmail.com> parents: 5791 diff changeset	74 local waiting;
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	75 return function ()
5792 aac4c6147647 util.async: waiter: Remove restriction about wait() being called before done() Matthew Wild <mwild1@gmail.com> parents: 5791 diff changeset	76 if num == 0 then return; end -- already done
aac4c6147647 util.async: waiter: Remove restriction about wait() being called before done() Matthew Wild <mwild1@gmail.com> parents: 5791 diff changeset	77 waiting = true;
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	78 coroutine.yield("wait");
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	79 end, function ()
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	80 num = num - 1;
5792 aac4c6147647 util.async: waiter: Remove restriction about wait() being called before done() Matthew Wild <mwild1@gmail.com> parents: 5791 diff changeset	81 if num == 0 and waiting then
aac4c6147647 util.async: waiter: Remove restriction about wait() being called before done() Matthew Wild <mwild1@gmail.com> parents: 5791 diff changeset	82 runner_continue(thread);
5793 e8c79796ead9 util.async: waiter: Throw error if done() called too many times Kim Alvefur <zash@zash.se> parents: 5792 diff changeset	83 elseif num < 0 then
e8c79796ead9 util.async: waiter: Throw error if done() called too many times Kim Alvefur <zash@zash.se> parents: 5792 diff changeset	84 error("done() called too many times");
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	85 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	86 end;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	87 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	88
5797 a493b79cfad0 util.async: Make guarder() local Matthew Wild <mwild1@gmail.com> parents: 5796 diff changeset	89 local function guarder()
5796 0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	90 local guards = {};
8655 ba6a6a04b46c util.async: Allow nil as a guard key Matthew Wild <mwild1@gmail.com> parents: 8651 diff changeset	91 local default_id = {};
5796 0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	92 return function (id, func)
8655 ba6a6a04b46c util.async: Allow nil as a guard key Matthew Wild <mwild1@gmail.com> parents: 8651 diff changeset	93 id = id or default_id;
8407 f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	94 local thread = checkthread();
5796 0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	95 local guard = guards[id];
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	96 if not guard then
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	97 guard = {};
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	98 guards[id] = guard;
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	99 log("debug", "New guard!");
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	100 else
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	101 table.insert(guard, thread);
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	102 log("debug", "Guarded. %d threads waiting.", #guard)
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	103 coroutine.yield("wait");
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	104 end
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	105 local function exit()
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	106 local next_waiting = table.remove(guard, 1);
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	107 if next_waiting then
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	108 log("debug", "guard: Executing next waiting thread (%d left)", #guard)
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	109 runner_continue(next_waiting);
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	110 else
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	111 log("debug", "Guard off duty.")
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	112 guards[id] = nil;
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	113 end
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	114 end
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	115 if func then
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	116 func();
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	117 exit();
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	118 return;
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	119 end
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	120 return exit;
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	121 end;
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	122 end
0b66cb959161 util.async: Add guarder method, to create guards to ensure only a single runner can pass through a section of code at a time Matthew Wild <mwild1@gmail.com> parents: 5794 diff changeset	123
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	124 local function sleep(seconds)
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	125 if not schedule_task then
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	126 error("async.sleep() is not available - configure schedule function");
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	127 end
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	128 local wait, done = waiter();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	129 schedule_task(seconds, done);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	130 wait();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	131 end
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	132
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	133 local runner_mt = {};
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	134 runner_mt.__index = runner_mt;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	135
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	136 local function runner_create_thread(func, self)
7725 f928695a2af1 util.async: Add annotation to ignore warning [luacheck] Kim Alvefur <zash@zash.se> parents: 7724 diff changeset	137 local thread = coroutine.create(function (self) -- luacheck: ignore 432/self
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	138 while true do
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	139 func(coroutine.yield("ready", self));
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	140 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	141 end);
8927 ed0891383e78 util.async: Copy hooks from main thread into coroutines Matthew Wild <mwild1@gmail.com> parents: 8788 diff changeset	142 debug.sethook(thread, debug.gethook());
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	143 assert(coroutine.resume(thread, self)); -- Start it up, it will return instantly to wait for the first input
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	144 return thread;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	145 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	146
8681 0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	147 local function default_error_watcher(runner, err)
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	148 runner:log("error", "Encountered error: %s", err);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	149 error(err);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	150 end
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	151 local function default_func(f) f(); end
5790 959163e4d631 util.async: Make functions local Matthew Wild <mwild1@gmail.com> parents: 5788 diff changeset	152 local function runner(func, watchers, data)
8788 7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	153 local id = new_id();
7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	154 local _log = logger.init("runner" .. id);
8681 0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	155 return setmetatable({ func = func or default_func, thread = false, state = "ready", notified_state = "ready",
8788 7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	156 queue = {}, watchers = watchers or { error = default_error_watcher }, data = data, id = id, _log = _log; }
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	157 , runner_mt);
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	158 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	159
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	160 -- Add a task item for the runner to process
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	161 function runner_mt:run(input)
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	162 if input ~= nil then
8602 9901deadc068 util.async: Fix order of statements so queue count makes more sense Matthew Wild <mwild1@gmail.com> parents: 8601 diff changeset	163 table.insert(self.queue, input);
8976 92f0876b9230 MUC: Add config option to allow members to invite other members to the room (previously only owners/admins could do this) Matthew Wild <mwild1@gmail.com> parents: 8927 diff changeset	164 --self:log("debug", "queued new work item, %d items queued", #self.queue);
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	165 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	166 if self.state ~= "ready" then
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	167 -- The runner is busy. Indicate that the task item has been
649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	168 -- queued, and return information about the current runner state
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	169 return true, self.state, #self.queue;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	170 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	171
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	172 local q, thread = self.queue, self.thread;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	173 if not thread or coroutine.status(thread) == "dead" then
10930 69a4b0e3565f util.async: Call coroutine.close() on dead threads (Lua 5.4) Matthew Wild <mwild1@gmail.com> parents: 10928 diff changeset	174 --luacheck: ignore 143/coroutine
10931 558f0555ba02 util.async: Don't attempt to close thread if not created yet Matthew Wild <mwild1@gmail.com> parents: 10930 diff changeset	175 if thread and coroutine.close then
10930 69a4b0e3565f util.async: Call coroutine.close() on dead threads (Lua 5.4) Matthew Wild <mwild1@gmail.com> parents: 10928 diff changeset	176 coroutine.close(thread);
69a4b0e3565f util.async: Call coroutine.close() on dead threads (Lua 5.4) Matthew Wild <mwild1@gmail.com> parents: 10928 diff changeset	177 end
8600 96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	178 self:log("debug", "creating new coroutine");
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	179 -- Create a new coroutine for this runner
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	180 thread = runner_create_thread(self.func, self);
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	181 self.thread = thread;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	182 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	183
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	184 -- Process task item(s) while the queue is not empty, and we're not blocked
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	185 local n, state, err = #q, self.state, nil;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	186 self.state = "running";
8976 92f0876b9230 MUC: Add config option to allow members to invite other members to the room (previously only owners/admins could do this) Matthew Wild <mwild1@gmail.com> parents: 8927 diff changeset	187 --self:log("debug", "running main loop");
8603 dc5f3302a642 util.async: Bugfix, don't continue main loop while there is a pending error Matthew Wild <mwild1@gmail.com> parents: 8602 diff changeset	188 while n > 0 and state == "ready" and not err do
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	189 local consumed;
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	190 -- Loop through queue items, and attempt to run them
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	191 for i = 1,n do
7724 20a69ef5570c util.async: Rename variable to avoid name clash [luacheck] Kim Alvefur <zash@zash.se> parents: 7436 diff changeset	192 local queued_input = q[i];
20a69ef5570c util.async: Rename variable to avoid name clash [luacheck] Kim Alvefur <zash@zash.se> parents: 7436 diff changeset	193 local ok, new_state = coroutine.resume(thread, queued_input);
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	194 if not ok then
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	195 -- There was an error running the coroutine, save the error, mark runner as ready to begin again
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	196 consumed, state, err = i, "ready", debug.traceback(thread, new_state);
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	197 self.thread = nil;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	198 break;
5791 2c98061b6b1e util.async: runner: Fix check for new state to recognise transition to 'waiting' Matthew Wild <mwild1@gmail.com> parents: 5790 diff changeset	199 elseif new_state == "wait" then
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	200 -- Runner is blocked on waiting for a task item to complete
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	201 consumed, state = i, "waiting";
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	202 break;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	203 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	204 end
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	205 -- Loop ended - either queue empty because all tasks passed without blocking (consumed == nil)
649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	206 -- or runner is blocked/errored, and consumed will contain the number of tasks processed so far
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	207 if not consumed then consumed = n; end
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	208 -- Remove consumed items from the queue array
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	209 if q[n+1] ~= nil then
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	210 n = #q;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	211 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	212 for i = 1, n do
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	213 q[i] = q[consumed+i];
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	214 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	215 n = #q;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	216 end
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	217 -- Runner processed all items it can, so save current runner state
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	218 self.state = state;
5794 66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	219 if err or state ~= self.notified_state then
8604 1c8c7fd259c8 util.async: Log the non-error state as well when there is an error being processed Matthew Wild <mwild1@gmail.com> parents: 8603 diff changeset	220 self:log("debug", "changed state from %s to %s", self.notified_state, err and ("error ("..state..")") or state);
5794 66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	221 if err then
66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	222 state = "error"
66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	223 else
66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	224 self.notified_state = state;
66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	225 end
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	226 local handler = self.watchers[state];
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	227 if handler then handler(self, err); end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	228 end
8615 e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8613 diff changeset	229 if n > 0 then
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8613 diff changeset	230 return self:run();
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8613 diff changeset	231 end
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	232 return true, state, n;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	233 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	234
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	235 -- Add a task item to the queue without invoking the runner, even if it is idle
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	236 function runner_mt:enqueue(input)
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	237 table.insert(self.queue, input);
8602 9901deadc068 util.async: Fix order of statements so queue count makes more sense Matthew Wild <mwild1@gmail.com> parents: 8601 diff changeset	238 self:log("debug", "queued new work item, %d items queued", #self.queue);
8766 01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	239 return self;
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	240 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	241
8600 96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	242 function runner_mt:log(level, fmt, ...)
8788 7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	243 return self._log(level, fmt, ...);
8600 96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	244 end
96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	245
8766 01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	246 function runner_mt:onready(f)
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	247 self.watchers.ready = f;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	248 return self;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	249 end
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	250
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	251 function runner_mt:onwaiting(f)
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	252 self.watchers.waiting = f;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	253 return self;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	254 end
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	255
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	256 function runner_mt:onerror(f)
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	257 self.watchers.error = f;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	258 return self;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	259 end
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	260
8648 ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	261 local function ready()
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	262 return pcall(checkthread);
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	263 end
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	264
10928 79faf5b98395 util.async: Rename wait -> wait_for (w/compat) Matthew Wild <mwild1@gmail.com> parents: 10291 diff changeset	265 local function wait_for(promise)
10291 7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	266 local async_wait, async_done = waiter();
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	267 local ret, err = nil, nil;
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	268 promise:next(
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	269 function (r) ret = r; end,
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	270 function (e) err = e; end)
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	271 :finally(async_done);
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	272 async_wait();
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	273 if ret then
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	274 return ret;
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	275 else
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	276 return nil, err;
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	277 end
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	278 end
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	279
8649 9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	280 return {
9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	281 ready = ready;
9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	282 waiter = waiter;
9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	283 guarder = guarder;
8651 1b7c5933b215 util.async: Add sleep() method Matthew Wild <mwild1@gmail.com> parents: 8649 diff changeset	284 runner = runner;
10928 79faf5b98395 util.async: Rename wait -> wait_for (w/compat) Matthew Wild <mwild1@gmail.com> parents: 10291 diff changeset	285 wait = wait_for; -- COMPAT w/trunk pre-0.12
79faf5b98395 util.async: Rename wait -> wait_for (w/compat) Matthew Wild <mwild1@gmail.com> parents: 10291 diff changeset	286 wait_for = wait_for;
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	287 sleep = sleep;
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	288
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	289 set_schedule_function = function (new_schedule_function) schedule_task = new_schedule_function; end;
8649 9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	290 };

prosody

542a9a503073

util/async.lua

Software / code / prosody

Annotate

util/async.lua @ 11961:542a9a503073

Software `/` code `/` prosody