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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
local serialize = require "util.serialization".serialize;
local array = require "util.array";
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 items = self.store[username or NULL];
if not items then
-- Store is empty
return 0;
end
items = array(items);
local count_before = #items;
if query then
if query.key then
items:filter(function (item)
return item.key ~= query.key;
end);
end
if query.with then
items:filter(function (item)
return item.with ~= query.with;
end);
end
if query.start then
items:filter(function (item)
return item.when < query.start;
end);
end
if query["end"] then
items:filter(function (item)
return item.when > query["end"];
end);
end
if query.truncate and #items > query.truncate then
if query.reverse then
-- Before: { 1, 2, 3, 4, 5, }
-- After: { 1, 2, 3 }
for i = #items, query.truncate + 1, -1 do
items[i] = nil;
end
else
-- Before: { 1, 2, 3, 4, 5, }
-- After: { 3, 4, 5 }
local offset = #items - query.truncate;
for i = 1, #items do
items[i] = items[i+offset];
end
end
end
end
local count = count_before - #items;
if count == 0 then
return 0; -- No changes, skip write
end
setmetatable(items, nil);
do -- re-index by key
for k in pairs(items) do
if type(k) == "string" then
items[k] = nil;
end
end
for i = 1, #items do
items[ items[i].key ] = i;
end
end
return count;
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
function driver:purge(user) -- luacheck: ignore 212/self
for _, store in pairs(memory) do
store[user] = nil;
end
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);
|
