Mercurial > prosody-modules
view mod_storage_gdbm/mod_storage_gdbm.lua @ 4942:e7b9bc629ecc
mod_rest: Add special handling to catch MAM results from remote hosts
Makes MAM queries to remote hosts works.
As the comment says, MAM results from users' local archives or local
MUCs are returned via origin.send() which is provided in the event and
thus already worked. Results from remote hosts go via normal stanza
routing and events, which need this extra handling to catch.
This pattern of iq-set, message+, iq-result is generally limited to MAM.
Closest similar thing might be MUC join, but to really handle that you
would need the webhook callback mechanism.
author | Kim Alvefur <zash@zash.se> |
---|---|
date | Mon, 16 May 2022 19:47:09 +0200 |
parents | 95ad6e68e203 |
children |
line wrap: on
line source
-- mod_storage_gdbm -- Copyright (C) 2014-2015 Kim Alvefur -- -- This file is MIT/X11 licensed. -- -- Depends on lgdbm: -- http://webserver2.tecgraf.puc-rio.br/~lhf/ftp/lua/#lgdbm -- -- luacheck: globals open purge local gdbm = require"gdbm"; local path = require"util.paths"; local lfs = require"lfs"; local st = require"util.stanza"; local uuid = require"util.uuid".generate; local serialization = require"util.serialization"; local serialize = serialization.serialize; local deserialize = serialization.deserialize; local g_set, g_get, g_del = gdbm.replace, gdbm.fetch, gdbm.delete; local g_first, g_next = gdbm.firstkey, gdbm.nextkey; local empty = {}; local function id(v) return v; end local function is_stanza(s) return getmetatable(s) == st.stanza_mt; end local base_path = path.resolve_relative_path(prosody.paths.data, module.host); lfs.mkdir(base_path); local cache = {}; local keyval = {}; local keyval_mt = { __index = keyval, suffix = ".db" }; function keyval:set(user, value) if type(value) == "table" and next(value) == nil then value = nil; end if value ~= nil then value = serialize(value); end local ok, err = (value and g_set or g_del)(self._db, user or "@", value); if not ok then return nil, err; end return true; end function keyval:get(user) local data, err = g_get(self._db, user or "@"); if not data then return nil, err; end return deserialize(data); end local function g_keys(db, key) return (key == nil and g_first or g_next)(db, key); end function keyval:users() return g_keys, self._db, nil; end local archive = {}; local archive_mt = { __index = archive, suffix = ".adb" }; archive.get = keyval.get; archive.set = keyval.set; function archive:append(username, key, value, when, with) if type(when) ~= "number" then when, with, value = value, when, with; end key = key or uuid(); local meta = self:get(username); if not meta then meta = {}; end local i = meta[key] or #meta+1; local type; if is_stanza(value) then type, value = "stanza", st.preserialize(value); end meta[i] = { key = key, when = when, with = with, type = type }; meta[key] = i; local prefix = (username or "@") .. "#"; local ok, err = self:set(prefix..key, value); if not ok then return nil, err; end ok, err = self:set(username, meta); if not ok then return nil, err; end return key; end local deserialize_map = { stanza = st.deserialize; }; function archive:find(username, query) query = query or empty; local meta = self:get(username) or empty; local prefix = (username or "@") .. "#"; local reverse = query.reverse; local step = reverse and -1 or 1; local first = meta[query.after]; local last = meta[query.before]; -- we don't want to include the actual 'after' or 'before' item if first then first = first + 1; end if last then last = last - 1; end first, last = first or 1, last or #meta; if reverse then first, last = last, first; end local limit = query.limit; local count = 0; return function () if limit and count >= limit then return end local item, value; for i = first, last, step do item = meta[i]; if (not query.with or item.with == query.with) and (not query.start or item.when >= query.start) and (not query["end"] or item.when <= query["end"]) then first = i + step; count = count + 1; value = self:get(prefix..item.key); return item.key, (deserialize_map[item.type] or id)(value), item.when, item.with; end end end end local drivers = { keyval = keyval_mt; archive = archive_mt; } function open(_, store, typ) typ = typ or "keyval"; local driver_mt = drivers[typ]; if not driver_mt then return nil, "unsupported-store"; end local db_path = path.join(base_path, store) .. driver_mt.suffix; local db = cache[db_path]; if not db then db = assert(gdbm.open(db_path, "c")); cache[db_path] = db; end return setmetatable({ _db = db; _path = db_path; store = store, type = typ }, driver_mt); end function purge(_, user) for dir in lfs.dir(base_path) do local name, ext = dir:match("^(.-)%.a?db$"); if ext == ".db" then open(_, name, "keyval"):set(user, nil); elseif ext == ".adb" then open(_, name, "archive"):delete(user); end end return true; end function module.unload() for db_path, db in pairs(cache) do module:log("debug", "Closing db at %q", db_path); gdbm.reorganize(db); gdbm.sync(db); gdbm.close(db); end end module:provides"storage";