1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
local serialize = require "util.serialization".serialize;
local envload = require "util.envload".envload;
local st = require "util.stanza";
local is_stanza = st.is_stanza or function (s) return getmetatable(s) == st.stanza_mt end
local auto_purge_enabled = module:get_option_boolean("storage_memory_temporary", false);
local auto_purge_stores = module:get_option_set("storage_memory_temporary_stores", {});
local memory = setmetatable({}, {
__index = function(t, k)
local store = module:shared(k)
t[k] = store;
return store;
end
});
local function NULL() return nil end
local function _purge_store(self, username)
self.store[username or NULL] = nil;
return true;
end
local keyval_store = {};
keyval_store.__index = keyval_store;
function keyval_store:get(username)
return (self.store[username or NULL] or NULL)();
end
function keyval_store:set(username, data)
if data ~= nil then
data = envload("return "..serialize(data), "=(data)", {});
end
self.store[username or NULL] = data;
return true;
end
keyval_store.purge = _purge_store;
local archive_store = {};
archive_store.__index = archive_store;
function archive_store:append(username, key, value, when, with)
if is_stanza(value) then
value = st.preserialize(value);
value = envload("return xml"..serialize(value), "=(stanza)", { xml = st.deserialize })
else
value = envload("return "..serialize(value), "=(data)", {});
end
local a = self.store[username or NULL];
if not a then
a = {};
self.store[username or NULL] = a;
end
local v = { key = key, when = when, with = with, value = value };
if not key then
key = tostring(a):match"%x+$"..tostring(v):match"%x+$";
v.key = key;
end
if a[key] then
table.remove(a, a[key]);
end
local i = #a+1;
a[i] = v;
a[key] = i;
return key;
end
local function archive_iter (a, start, stop, step, limit, when_start, when_end, match_with)
local item, when, with;
local count = 0;
coroutine.yield(true); -- Ready
for i = start, stop, step do
item = a[i];
when, with = item.when, item.with;
if when >= when_start and when_end >= when and (not match_with or match_with == with) then
coroutine.yield(item.key, item.value(), when, with);
count = count + 1;
if limit and count >= limit then return end
end
end
end
function archive_store:find(username, query)
local a = self.store[username or NULL] or {};
local start, stop, step = 1, #a, 1;
local qstart, qend, qwith = -math.huge, math.huge;
local limit;
if query then
module:log("debug", "query included")
if query.reverse then
start, stop, step = stop, start, -1;
if query.before then
start = a[query.before];
end
elseif query.after then
start = a[query.after];
end
limit = query.limit;
qstart = query.start or qstart;
qend = query["end"] or qend;
qwith = query.with;
end
if not start then return nil, "invalid-key"; end
local iter = coroutine.wrap(archive_iter);
iter(a, start, stop, step, limit, qstart, qend, qwith);
return iter;
end
function archive_store:delete(username, query)
if not query or next(query) == nil then
self.store[username or NULL] = nil;
return true;
end
local old = self.store[username or NULL];
if not old then return true; end
local qstart = query.start or -math.huge;
local qend = query["end"] or math.huge;
local qwith = query.with;
local new = {};
self.store[username or NULL] = new;
local t;
for i = 1, #old do
i = old[i];
t = i.when;
if not(qstart >= t and qend <= t and (not qwith or i.with == qwith)) then
self:append(username, i.key, i.value(), t, i.with);
end
end
if #new == 0 then
self.store[username or NULL] = nil;
end
return true;
end
archive_store.purge = _purge_store;
local stores = {
keyval = keyval_store;
archive = archive_store;
}
local driver = {};
function driver:open(store, typ) -- luacheck: ignore 212/self
local store_mt = stores[typ or "keyval"];
if store_mt then
return setmetatable({ store = memory[store] }, store_mt);
end
return nil, "unsupported-store";
end
if auto_purge_enabled then
module:hook("resource-unbind", function (event)
local user_bare_jid = event.session.username.."@"..event.session.host;
if not prosody.bare_sessions[user_bare_jid] then -- User went offline
module:log("debug", "Clearing store for offline user %s", user_bare_jid);
local f, s, v;
if auto_purge_stores:empty() then
f, s, v = pairs(memory);
else
f, s, v = auto_purge_stores:items();
end
for store_name in f, s, v do
if memory[store_name] then
memory[store_name][event.session.username] = nil;
end
end
end
end);
end
module:provides("storage", driver);
|
