MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-12-26 07:23:53 +01:00
Code Issues Releases Wiki Activity

ircd:Ⓜ️:dbs: Add event_auth column.

Browse source
This commit is contained in:
Jason Volk 2019-02-08 02:49:13 -08:00
parent cbe829368f
commit 2a431fa26a
2 changed files with 265 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
include/ircd/m/dbs.h
View file

@ -35,6 +35,7 @@ namespace ircd::m::dbs
extern db::column event_idx; // event_id => event_idx
extern db::column event_json; // event_idx => full json
extern db::index event_refs; // event_idx | event_idx
extern db::index event_auth; // event_idx | event_idx
extern db::index room_head; // room_id | event_id => event_idx
extern db::index room_events; // room_id | depth, event_idx => node_id
extern db::index room_joined; // room_id | origin, member => event_idx
@ -46,6 +47,10 @@ namespace ircd::m::dbs
string_view event_refs_key(const mutable_buffer &out, const event::idx &tgt, const event::idx &referer);
std::tuple<event::idx> event_refs_key(const string_view &amalgam);
constexpr size_t EVENT_AUTH_KEY_MAX_SIZE {sizeof(event::idx) + sizeof(event::idx)};
string_view event_auth_key(const mutable_buffer &out, const event::idx &tgt, const event::idx &referer);
std::tuple<event::idx> event_auth_key(const string_view &amalgam);
constexpr size_t ROOM_HEAD_KEY_MAX_SIZE {id::MAX_SIZE + 1 + id::MAX_SIZE};
string_view room_head_key(const mutable_buffer &out, const id::room &, const id::event &);
string_view room_head_key(const string_view &amalgam);
@ -91,6 +96,7 @@ struct ircd::m::dbs::write_opts
bool room_refs {true};
bool event_id {true};
bool event_refs {true};
bool event_auth {true};
bool json_source {false};
};
@ -191,6 +197,16 @@ namespace ircd::m::dbs::desc
extern const db::comparator events__event_refs__cmp;
extern const db::descriptor events__event_refs;
// events auth
extern conf::item<size_t> events__event_auth__block__size;
extern conf::item<size_t> events__event_auth__meta_block__size;
extern conf::item<size_t> events__event_auth__cache__size;
extern conf::item<size_t> events__event_auth__cache_comp__size;
extern conf::item<size_t> events__event_auth__bloom__bits;
extern const db::prefix_transform events__event_auth__pfx;
extern const db::comparator events__event_auth__cmp;
extern const db::descriptor events__event_auth;
// room head mapping sequence
extern conf::item<size_t> events__room_head__block__size;
extern conf::item<size_t> events__room_head__meta_block__size;
@ -246,6 +262,7 @@ namespace ircd::m::dbs
string_view _index_other(db::txn &, const event &, const write_opts &);
string_view _index_room(db::txn &, const event &, const write_opts &);
void _index_event_refs(db::txn &, const event &, const write_opts &);
void _index_event_auth(db::txn &, const event &, const write_opts &);
void _index_event_id(db::txn &, const event &, const write_opts &);
void _index_event(db::txn &, const event &, const write_opts &);
void _append_json(db::txn &, const event &, const write_opts &);

248
ircd/m_dbs.cc
View file

@ -36,6 +36,11 @@ decltype(ircd::m::dbs::event_refs)
ircd::m::dbs::event_refs
{};
/// Linkage for a reference to the event_auth column.
decltype(ircd::m::dbs::event_auth)
ircd::m::dbs::event_auth
{};
/// Linkage for a reference to the room_head column
decltype(ircd::m::dbs::room_head)
ircd::m::dbs::room_head
@ -140,6 +145,7 @@ ircd::m::dbs::init::init(std::string dbopts)
event_idx = db::column{*events, desc::events__event_idx.name};
event_json = db::column{*events, desc::events__event_json.name};
event_refs = db::index{*events, desc::events__event_refs.name};
event_auth = db::index{*events, desc::events__event_auth.name};
room_head = db::index{*events, desc::events__room_head.name};
room_events = db::index{*events, desc::events__room_events.name};
room_joined = db::index{*events, desc::events__room_joined.name};
@ -312,6 +318,9 @@ ircd::m::dbs::_index_event(db::txn &txn,
if(opts.event_id)
_index_event_id(txn, event, opts);
if(opts.event_auth)
_index_event_auth(txn, event, opts);
if(opts.event_refs)
_index_event_refs(txn, event, opts);
}
@ -366,6 +375,43 @@ ircd::m::dbs::_index_event_refs(db::txn &txn,
}
}
void
ircd::m::dbs::_index_event_auth(db::txn &txn,
const event &event,
const write_opts &opts)
{
if(!is_power_event(event))
return;
const event::prev &prev{event};
for(size_t i(0); i < prev.auth_events_count(); ++i)
{
const event::id &auth_id{prev.auth_event(i)};
const event::idx &auth_idx
{
m::index(auth_id, std::nothrow) // query
};
if(!auth_idx)
continue;
thread_local char buf[EVENT_AUTH_KEY_MAX_SIZE];
assert(opts.event_idx != 0 && auth_idx != 0);
const string_view &key
{
event_auth_key(buf, auth_idx, opts.event_idx)
};
db::txn::append
{
txn, dbs::event_auth,
{
opts.op, key, string_view{}
}
};
}
}
ircd::string_view
ircd::m::dbs::_index_room(db::txn &txn,
const event &event,
@ -1174,6 +1220,204 @@ ircd::m::dbs::desc::events__event_refs
size_t(events__event_refs__meta_block__size),
};
//
// event_auth
//
decltype(ircd::m::dbs::desc::events__event_auth__block__size)
ircd::m::dbs::desc::events__event_auth__block__size
{
{ "name", "ircd.m.dbs.events._event_auth.block.size" },
{ "default", 512L },
};
decltype(ircd::m::dbs::desc::events__event_auth__meta_block__size)
ircd::m::dbs::desc::events__event_auth__meta_block__size
{
{ "name", "ircd.m.dbs.events._event_auth.meta_block.size" },
{ "default", 512L },
};
decltype(ircd::m::dbs::desc::events__event_auth__cache__size)
ircd::m::dbs::desc::events__event_auth__cache__size
{
{
{ "name", "ircd.m.dbs.events._event_auth.cache.size" },
{ "default", long(16_MiB) },
}, []
{
const size_t &value{events__event_auth__cache__size};
db::capacity(db::cache(event_auth), value);
}
};
decltype(ircd::m::dbs::desc::events__event_auth__cache_comp__size)
ircd::m::dbs::desc::events__event_auth__cache_comp__size
{
{
{ "name", "ircd.m.dbs.events._event_auth.cache_comp.size" },
{ "default", long(0_MiB) },
}, []
{
const size_t &value{events__event_auth__cache_comp__size};
db::capacity(db::cache_compressed(event_auth), value);
}
};
decltype(ircd::m::dbs::desc::events__event_auth__bloom__bits)
ircd::m::dbs::desc::events__event_auth__bloom__bits
{
{ "name", "ircd.m.dbs.events._event_auth.bloom.bits" },
{ "default", 0L },
};
ircd::string_view
ircd::m::dbs::event_auth_key(const mutable_buffer &out,
const event::idx &tgt,
const event::idx &src)
{
assert(size(out) >= sizeof(event::idx) * 2);
event::idx *const &key
{
reinterpret_cast<event::idx *>(data(out))
};
key[0] = tgt;
key[1] = src;
return string_view
{
data(out), data(out) + sizeof(event::idx) * 2
};
}
std::tuple<ircd::m::event::idx>
ircd::m::dbs::event_auth_key(const string_view &amalgam)
{
const byte_view<event::idx> key
{
amalgam
};
return
{
key
};
}
const ircd::db::prefix_transform
ircd::m::dbs::desc::events__event_auth__pfx
{
"_event_auth",
[](const string_view &key)
{
return size(key) >= sizeof(event::idx) * 2;
},
[](const string_view &key)
{
assert(size(key) >= sizeof(event::idx));
return string_view
{
data(key), data(key) + sizeof(event::idx)
};
}
};
const ircd::db::comparator
ircd::m::dbs::desc::events__event_auth__cmp
{
"_event_auth",
// less
[](const string_view &a, const string_view &b)
{
static const size_t half(sizeof(event::idx));
static const size_t full(half * 2);
assert(size(a) >= half);
assert(size(b) >= half);
const event::idx *const key[2]
{
reinterpret_cast<const event::idx *>(data(a)),
reinterpret_cast<const event::idx *>(data(b)),
};
return
key[0][0] < key[1][0]? true:
key[0][0] > key[1][0]? false:
size(a) < size(b)? true:
size(a) > size(b)? false:
size(a) == half? false:
key[0][1] < key[1][1]? true:
false;
},
// equal
[](const string_view &a, const string_view &b)
{
return size(a) == size(b) && memcmp(data(a), data(b), size(a)) == 0;
}
};
const ircd::db::descriptor
ircd::m::dbs::desc::events__event_auth
{
// name
"_event_auth",
// explanation
R"(Inverse reference graph of events.
event_idx | event_idx => --
The first part of the key is the event being referenced. The second part
of the key is the event which refers to the first event somewhere in its
auth_events references.
The prefix transform is in effect; an event may be referenced multiple
times. We can find all the events we have which reference a target. The
database must contain both events (hence they have event::idx numbers).
The value is currently unused/empty.
)",
// typing (key, value)
{
typeid(uint64_t), typeid(string_view)
},
// options
{},
// comparator
events__event_auth__cmp,
// prefix transform
events__event_auth__pfx,
// drop column
false,
// cache size
bool(events_cache_enable)? -1 : 0, //uses conf item
// cache size for compressed assets
bool(events_cache_comp_enable)? -1 : 0,
// bloom filter bits
size_t(events__event_auth__bloom__bits),
// expect queries hit
true,
// block size
size_t(events__event_auth__block__size),
// meta_block size
size_t(events__event_auth__meta_block__size),
};
//
// room_head
//
@ -3320,6 +3564,10 @@ ircd::m::dbs::desc::events
// Reverse mapping of the event reference graph.
events__event_refs,
// event_idx | event_idx
// Reverse mapping of the auth reference graph.
events__event_auth,
// (room_id, (depth, event_idx)) => (state_root)
// Sequence of all events for a room, ever.
events__room_events,