Software `/` code `/` prosody

Annotate

util/async.lua @ 12828:f33887f925e1

net.server_epoll: Remove delay on last main loop iteration when quitting Main difference is that timers are not checked unconditionally before each poll, only when running out of previous poll results (hidden by util.poll). This removes a final poll at shutdown that usually delays the 'not quitting' condition check by one second.

author	Kim Alvefur <zash@zash.se>
date	Fri, 06 Jan 2023 04:38:39 +0100
parent	12310:91af1697ddd8
child	12975:d10957394a3c

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)
11962 9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	16 local next_tick = function (f)
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	17 f();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	18 end
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	19
8627 24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	20 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	21 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	22 -- 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	23 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	24 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	25 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	26 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	27 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	28 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	29 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	30
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	31 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	32 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	33 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	34 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	35 end
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("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	37 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	38 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	39 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	40 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	41 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	42 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	43 end
24b59a62acce util.async: Split runner_continue into smaller functions for easier testing and safety Matthew Wild <mwild1@gmail.com> parents: 8625 diff changeset	44
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	45 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	46 -- 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	47 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	48 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	49 return false;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	50 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	51 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	52 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	53 local err = state;
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	54 -- 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	55 -- 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	56 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	57 if not runner then
8629 ddb04cacb8b1 util.async: Bump log warnings to error level Matthew Wild <mwild1@gmail.com> parents: 8627 diff changeset	58 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	59 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	60 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	61 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	62 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	63 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	64 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	65 -- 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	66 -- 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	67 -- processed otherwise. FIXME: It's probably best to do this in a nexttick (0 timer).
11962 9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	68 next_tick(function ()
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	69 runner.state = "ready";
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	70 runner:run();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	71 end);
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	72 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	73 return true;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	74 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	75
12310 91af1697ddd8 util.async: Optionally allow too many 'done' callbacks Kim Alvefur <zash@zash.se> parents: 11962 diff changeset	76 local function waiter(num, allow_many)
8407 f652e1ea2f69 util.async: Factor out thread check into a function Kim Alvefur <zash@zash.se> parents: 8237 diff changeset	77 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	78 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	79 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	80 return function ()
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 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	82 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	83 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	84 end, function ()
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	85 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	86 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	87 runner_continue(thread);
12310 91af1697ddd8 util.async: Optionally allow too many 'done' callbacks Kim Alvefur <zash@zash.se> parents: 11962 diff changeset	88 elseif not allow_many and num < 0 then
5793 e8c79796ead9 util.async: waiter: Throw error if done() called too many times Kim Alvefur <zash@zash.se> parents: 5792 diff changeset	89 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	90 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	91 end;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	92 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	93
5797 a493b79cfad0 util.async: Make guarder() local Matthew Wild <mwild1@gmail.com> parents: 5796 diff changeset	94 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	95 local guards = {};
8655 ba6a6a04b46c util.async: Allow nil as a guard key Matthew Wild <mwild1@gmail.com> parents: 8651 diff changeset	96 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	97 return function (id, func)
8655 ba6a6a04b46c util.async: Allow nil as a guard key Matthew Wild <mwild1@gmail.com> parents: 8651 diff changeset	98 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	99 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	100 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	101 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	102 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 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	104 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	105 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	106 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	107 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	108 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	109 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	110 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	111 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	112 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	113 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	114 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	115 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	116 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	117 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	118 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	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 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	121 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	122 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	123 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	124 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	125 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	126 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	127 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	128
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	129 local function sleep(seconds)
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	130 if not schedule_task then
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	131 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	132 end
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	133 local wait, done = waiter();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	134 schedule_task(seconds, done);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	135 wait();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	136 end
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	137
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	138 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	139 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	140
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	141 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	142 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	143 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	144 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	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 end);
8927 ed0891383e78 util.async: Copy hooks from main thread into coroutines Matthew Wild <mwild1@gmail.com> parents: 8788 diff changeset	147 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	148 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	149 return thread;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	150 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	151
8681 0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	152 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	153 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	154 error(err);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	155 end
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	156 local function default_func(f) f(); end
5790 959163e4d631 util.async: Make functions local Matthew Wild <mwild1@gmail.com> parents: 5788 diff changeset	157 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	158 local id = new_id();
7a9b680a79fb util.async: Move runner id into log tag Kim Alvefur <zash@zash.se> parents: 8766 diff changeset	159 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	160 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	161 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	162 , runner_mt);
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	163 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	164
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	165 -- 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	166 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	167 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	168 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	169 --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	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 if self.state ~= "ready" then
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	172 -- 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	173 -- 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	174 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	175 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	176
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	177 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	178 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	179 --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	180 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	181 coroutine.close(thread);
69a4b0e3565f util.async: Call coroutine.close() on dead threads (Lua 5.4) Matthew Wild <mwild1@gmail.com> parents: 10928 diff changeset	182 end
8600 96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	183 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	184 -- 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	185 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	186 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	187 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	188
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	189 -- 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	190 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	191 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	192 --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	193 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	194 local consumed;
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	195 -- 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	196 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	197 local queued_input = q[i];
20a69ef5570c util.async: Rename variable to avoid name clash [luacheck] Kim Alvefur <zash@zash.se> parents: 7436 diff changeset	198 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	199 if not ok then
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	200 -- 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	201 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	202 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	203 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	204 elseif new_state == "wait" then
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	205 -- 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	206 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	207 break;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	208 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	209 end
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	210 -- 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	211 -- 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	212 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	213 -- 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	214 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	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
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	217 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	218 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	219 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	220 n = #q;
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	221 end
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	222 -- 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	223 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	224 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	225 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	226 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	227 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	228 else
66c3ad5d29ad util.async: Fix logic bug that prevented error watcher being called for runners Matthew Wild <mwild1@gmail.com> parents: 5793 diff changeset	229 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	230 end
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	231 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	232 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	233 end
8615 e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8613 diff changeset	234 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	235 return self:run();
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8613 diff changeset	236 end
5788 3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	237 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	238 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	239
7436 649b89b2c840 util.async: Add some more comments for clarity Matthew Wild <mwild1@gmail.com> parents: 7359 diff changeset	240 -- 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	241 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	242 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	243 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	244 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	245 end
3556f338caa3 util.async: New library to provide support around coroutine-based non-blocking functions Matthew Wild <mwild1@gmail.com> parents: diff changeset	246
8600 96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	247 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	248 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	249 end
96f20cf92b84 util.async: Add per-runner ids and add runner:log() method Matthew Wild <mwild1@gmail.com> parents: 8408 diff changeset	250
8766 01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	251 function runner_mt:onready(f)
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	252 self.watchers.ready = 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:onwaiting(f)
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	257 self.watchers.waiting = 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
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	261 function runner_mt:onerror(f)
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	262 self.watchers.error = f;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	263 return self;
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	264 end
01264bc60c2b util.async: Add helper methods for setting watchers Matthew Wild <mwild1@gmail.com> parents: 8685 diff changeset	265
8648 ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	266 local function ready()
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	267 return pcall(checkthread);
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	268 end
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8629 diff changeset	269
10928 79faf5b98395 util.async: Rename wait -> wait_for (w/compat) Matthew Wild <mwild1@gmail.com> parents: 10291 diff changeset	270 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	271 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	272 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	273 promise:next(
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	274 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	275 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	276 :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	277 async_wait();
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	278 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	279 return ret;
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	280 else
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	281 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	282 end
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	283 end
7b48b620164c util.async: Add function for waiting on promises and unpacking the results Kim Alvefur <zash@zash.se> parents: 9562 diff changeset	284
8649 9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	285 return {
9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	286 ready = ready;
9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	287 waiter = waiter;
9246f64d6f1e util.async: Add once() to create temporary runners Matthew Wild <mwild1@gmail.com> parents: 8648 diff changeset	288 guarder = guarder;
8651 1b7c5933b215 util.async: Add sleep() method Matthew Wild <mwild1@gmail.com> parents: 8649 diff changeset	289 runner = runner;
10928 79faf5b98395 util.async: Rename wait -> wait_for (w/compat) Matthew Wild <mwild1@gmail.com> parents: 10291 diff changeset	290 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	291 wait_for = wait_for;
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	292 sleep = sleep;
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	293
11962 9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	294 set_nexttick = function(new_next_tick) next_tick = new_next_tick; end;
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10931 diff changeset	295 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	296 };

prosody

f33887f925e1

util/async.lua

Software / code / prosody

Annotate

util/async.lua @ 12828:f33887f925e1

Software `/` code `/` prosody