mirror of
https://github.com/matrix-construct/construct
synced 2025-04-04 00:41:06 +02:00
ircd:Ⓜ️ Preliminary modular client sync system.
This commit is contained in:
Jason Volk
parent
ab121835af
commit
86911226ed
13 changed files with 1311 additions and 723 deletions
|
|
@ -59,6 +59,7 @@ namespace ircd::m::vm
|
|||
#include "visible.h"
|
||||
#include "feds.h"
|
||||
#include "app.h"
|
||||
#include "sync.h"
|
||||
|
||||
struct ircd::m::init
|
||||
{
|
||||
|
|
|
|||
109
include/ircd/m/sync.h
Normal file
109
include/ircd/m/sync.h
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
#pragma once
|
||||
#define HAVE_IRCD_M_SYNC_H
|
||||
|
||||
namespace ircd
|
||||
{
|
||||
struct client;
|
||||
}
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
struct args;
|
||||
struct stats;
|
||||
struct data;
|
||||
struct item;
|
||||
struct response;
|
||||
|
||||
extern log::log log;
|
||||
}
|
||||
|
||||
struct ircd::m::sync::item
|
||||
:instance_multimap<std::string, item, std::less<>>
|
||||
{
|
||||
using handle = std::function<bool (data &)>;
|
||||
|
||||
handle _polylog;
|
||||
handle _linear;
|
||||
handle _longpoll;
|
||||
|
||||
public:
|
||||
string_view name() const;
|
||||
|
||||
bool polylog(data &);
|
||||
bool linear(data &, const m::event &);
|
||||
bool longpoll(data &, const m::event &);
|
||||
|
||||
item(std::string name,
|
||||
handle polylog = {},
|
||||
handle linear = {},
|
||||
handle longpoll = {});
|
||||
|
||||
item(item &&) = delete;
|
||||
item(const item &) = delete;
|
||||
~item() noexcept;
|
||||
};
|
||||
|
||||
struct ircd::m::sync::data
|
||||
{
|
||||
sync::stats &stats;
|
||||
ircd::client &client;
|
||||
|
||||
// Range related
|
||||
const uint64_t &since;
|
||||
const uint64_t current;
|
||||
const uint64_t delta;
|
||||
|
||||
// User related
|
||||
const m::user user;
|
||||
const m::user::room user_room;
|
||||
const m::user::rooms user_rooms;
|
||||
|
||||
// Filter to use
|
||||
const std::string filter_buf;
|
||||
const m::filter filter;
|
||||
|
||||
// response state
|
||||
const std::unique_ptr<response> resp;
|
||||
json::stack out;
|
||||
bool committed() const;
|
||||
bool commit();
|
||||
|
||||
// apropos contextual
|
||||
ctx::mutex write_mutex;
|
||||
json::stack::member *member {nullptr};
|
||||
json::stack::object *object {nullptr};
|
||||
json::stack::array *array {nullptr};
|
||||
const m::event *event {nullptr};
|
||||
const m::room *room {nullptr};
|
||||
string_view membership;
|
||||
|
||||
// unsorted / misc
|
||||
uint64_t state_at {0};
|
||||
|
||||
data(sync::stats &stats,
|
||||
ircd::client &client,
|
||||
const m::user &user,
|
||||
const std::pair<event::idx, event::idx> &range,
|
||||
const string_view &filter_id);
|
||||
|
||||
data(data &&) = delete;
|
||||
data(const data &) = delete;
|
||||
~data() noexcept;
|
||||
};
|
||||
|
||||
struct ircd::m::sync::stats
|
||||
{
|
||||
ircd::timer timer;
|
||||
size_t flush_bytes {0};
|
||||
size_t flush_count {0};
|
||||
};
|
||||
327
ircd/m/m.cc
327
ircd/m/m.cc
|
|
@ -389,6 +389,333 @@ ircd::m::self::init::init(const string_view &origin)
|
|||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// m/sync.h
|
||||
//
|
||||
|
||||
decltype(ircd::m::sync::log)
|
||||
ircd::m::sync::log
|
||||
{
|
||||
"sync", 's'
|
||||
};
|
||||
|
||||
//
|
||||
// response
|
||||
//
|
||||
|
||||
struct ircd::m::sync::response
|
||||
{
|
||||
static conf::item<size_t> flush_hiwat;
|
||||
|
||||
sync::stats &stats;
|
||||
ircd::client &client;
|
||||
unique_buffer<mutable_buffer> buf;
|
||||
std::unique_ptr<resource::response::chunked> resp;
|
||||
bool committed;
|
||||
|
||||
const_buffer flush(const const_buffer &buf);
|
||||
void commit();
|
||||
|
||||
response(sync::stats &stats, ircd::client &client);
|
||||
~response() noexcept;
|
||||
};
|
||||
|
||||
decltype(ircd::m::sync::response::flush_hiwat)
|
||||
ircd::m::sync::response::flush_hiwat
|
||||
{
|
||||
{ "name", "ircd.m.sync.flush.hiwat" },
|
||||
{ "default", long(32_KiB) },
|
||||
};
|
||||
|
||||
//
|
||||
// response::response
|
||||
//
|
||||
|
||||
ircd::m::sync::response::response(sync::stats &stats,
|
||||
ircd::client &client)
|
||||
:stats
|
||||
{
|
||||
stats
|
||||
}
|
||||
,client
|
||||
{
|
||||
client
|
||||
}
|
||||
,buf
|
||||
{
|
||||
std::max(size_t(96_KiB), size_t(flush_hiwat))
|
||||
}
|
||||
,committed
|
||||
{
|
||||
false
|
||||
}
|
||||
{
|
||||
}
|
||||
|
||||
ircd::m::sync::response::~response()
|
||||
noexcept
|
||||
{
|
||||
}
|
||||
|
||||
ircd::const_buffer
|
||||
ircd::m::sync::response::flush(const const_buffer &buf)
|
||||
{
|
||||
if(!committed)
|
||||
return buf;
|
||||
|
||||
if(!resp)
|
||||
commit();
|
||||
|
||||
stats.flush_bytes += resp->write(buf);
|
||||
stats.flush_count++;
|
||||
return buf;
|
||||
}
|
||||
|
||||
void
|
||||
ircd::m::sync::response::commit()
|
||||
{
|
||||
static const string_view content_type
|
||||
{
|
||||
"application/json; charset=utf-8"
|
||||
};
|
||||
|
||||
assert(!resp);
|
||||
resp = std::make_unique<resource::response::chunked>
|
||||
(
|
||||
client, http::OK, content_type
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
// data
|
||||
//
|
||||
|
||||
ircd::m::sync::data::data(sync::stats &stats,
|
||||
ircd::client &client,
|
||||
const m::user &user,
|
||||
const std::pair<event::idx, event::idx> &range,
|
||||
const string_view &filter_id)
|
||||
:stats{stats}
|
||||
,client{client}
|
||||
,since
|
||||
{
|
||||
range.first
|
||||
}
|
||||
,current
|
||||
{
|
||||
range.second
|
||||
}
|
||||
,delta
|
||||
{
|
||||
current - since
|
||||
}
|
||||
,user
|
||||
{
|
||||
user
|
||||
}
|
||||
,user_room
|
||||
{
|
||||
user
|
||||
}
|
||||
,user_rooms
|
||||
{
|
||||
user
|
||||
}
|
||||
,filter_buf
|
||||
{
|
||||
filter_id?
|
||||
user.filter(std::nothrow, filter_id):
|
||||
std::string{}
|
||||
}
|
||||
,filter
|
||||
{
|
||||
json::object{filter_buf}
|
||||
}
|
||||
,resp
|
||||
{
|
||||
std::make_unique<response>(stats, client)
|
||||
}
|
||||
,out
|
||||
{
|
||||
resp->buf, std::bind(&response::flush, resp.get(), ph::_1), size_t(resp->flush_hiwat)
|
||||
}
|
||||
{
|
||||
}
|
||||
|
||||
ircd::m::sync::data::~data()
|
||||
noexcept
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
ircd::m::sync::data::commit()
|
||||
{
|
||||
assert(resp);
|
||||
const auto ret{resp->committed};
|
||||
resp->committed = true;
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool
|
||||
ircd::m::sync::data::committed()
|
||||
const
|
||||
{
|
||||
assert(resp);
|
||||
return resp->committed;
|
||||
}
|
||||
|
||||
//
|
||||
// item
|
||||
//
|
||||
|
||||
template<>
|
||||
decltype(ircd::m::sync::item::instance_multimap::map)
|
||||
ircd::m::sync::item::instance_multimap::map
|
||||
{};
|
||||
|
||||
//
|
||||
// item::item
|
||||
//
|
||||
|
||||
ircd::m::sync::item::item(std::string name,
|
||||
handle polylog,
|
||||
handle linear,
|
||||
handle longpoll)
|
||||
:instance_multimap
|
||||
{
|
||||
std::move(name)
|
||||
}
|
||||
,_polylog
|
||||
{
|
||||
std::move(polylog)
|
||||
}
|
||||
,_linear
|
||||
{
|
||||
std::move(linear)
|
||||
}
|
||||
,_longpoll
|
||||
{
|
||||
std::move(longpoll)
|
||||
}
|
||||
{
|
||||
log::debug
|
||||
{
|
||||
log, "Registered sync item(%p) '%s'",
|
||||
this,
|
||||
this->name()
|
||||
};
|
||||
}
|
||||
|
||||
ircd::m::sync::item::~item()
|
||||
noexcept
|
||||
{
|
||||
log::debug
|
||||
{
|
||||
log, "Unregistered sync item(%p) '%s'",
|
||||
this,
|
||||
this->name()
|
||||
};
|
||||
}
|
||||
|
||||
bool
|
||||
ircd::m::sync::item::longpoll(data &data,
|
||||
const m::event &event)
|
||||
try
|
||||
{
|
||||
const auto ret
|
||||
{
|
||||
_longpoll(data)
|
||||
};
|
||||
|
||||
return ret;
|
||||
}
|
||||
catch(const std::bad_function_call &)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
ircd::m::sync::item::linear(data &data,
|
||||
const m::event &event)
|
||||
try
|
||||
{
|
||||
const scope_restore<decltype(data.event)> theirs
|
||||
{
|
||||
data.event, &event
|
||||
};
|
||||
|
||||
const auto ret
|
||||
{
|
||||
_linear(data)
|
||||
};
|
||||
|
||||
return ret;
|
||||
}
|
||||
catch(const std::bad_function_call &)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
ircd::m::sync::item::polylog(data &data)
|
||||
try
|
||||
{
|
||||
#ifdef RB_DEBUG
|
||||
sync::stats stats{data.stats};
|
||||
stats.timer = {};
|
||||
#endif
|
||||
|
||||
const auto ret
|
||||
{
|
||||
_polylog(data)
|
||||
};
|
||||
|
||||
#ifdef RB_DEBUG
|
||||
thread_local char rembuf[128], iecbuf[64], tmbuf[32];
|
||||
log::debug
|
||||
{
|
||||
log, "polylog %s %s '%s' %s wc:%zu in %s",
|
||||
string(rembuf, ircd::remote(data.client)),
|
||||
string_view{data.user.user_id},
|
||||
name(),
|
||||
ircd::pretty(iecbuf, iec(data.stats.flush_bytes - stats.flush_bytes)),
|
||||
data.stats.flush_count - stats.flush_count,
|
||||
ircd::pretty(tmbuf, stats.timer.at<microseconds>(), true)
|
||||
};
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
catch(const std::bad_function_call &)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
catch(const std::exception &e)
|
||||
{
|
||||
thread_local char rembuf[128], iecbuf[64], tmbuf[32];
|
||||
log::derror
|
||||
{
|
||||
log, "polylog %s %s '%s' %s wc:%zu in %s :%s",
|
||||
string(rembuf, ircd::remote(data.client)),
|
||||
string_view{data.user.user_id},
|
||||
name(),
|
||||
ircd::pretty(iecbuf, iec(data.stats.flush_bytes)),
|
||||
data.stats.flush_count,
|
||||
ircd::pretty(tmbuf, data.stats.timer.at<milliseconds>(), true),
|
||||
e.what()
|
||||
};
|
||||
|
||||
throw;
|
||||
}
|
||||
|
||||
ircd::string_view
|
||||
ircd::m::sync::item::name()
|
||||
const
|
||||
{
|
||||
return this->instance_multimap::it->first;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// m/feds.h
|
||||
|
|
|
|||
|
|
@ -258,6 +258,28 @@ client_module_LTLIBRARIES += \
|
|||
client/client_thirdparty_protocols.la \
|
||||
###
|
||||
|
||||
#
|
||||
# client/sync/
|
||||
#
|
||||
|
||||
client_client_sync_account_data_la_SOURCES = client/sync/account_data.cc
|
||||
client_client_sync_presence_la_SOURCES = client/sync/presence.cc
|
||||
client_client_sync_rooms_account_data_la_SOURCES = client/sync/rooms/account_data.cc
|
||||
client_client_sync_rooms_receipt_la_SOURCES = client/sync/rooms/receipt.cc
|
||||
client_client_sync_rooms_state_la_SOURCES = client/sync/rooms/state.cc
|
||||
client_client_sync_rooms_timeline_la_SOURCES = client/sync/rooms/timeline.cc
|
||||
client_client_sync_rooms_unread_notifications_la_SOURCES = client/sync/rooms/unread_notifications.cc
|
||||
|
||||
client_module_LTLIBRARIES += \
|
||||
client/client_sync_account_data.la \
|
||||
client/client_sync_presence.la \
|
||||
client/client_sync_rooms_account_data.la \
|
||||
client/client_sync_rooms_receipt.la \
|
||||
client/client_sync_rooms_state.la \
|
||||
client/client_sync_rooms_timeline.la \
|
||||
client/client_sync_rooms_unread_notifications.la \
|
||||
###
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
# /_matrix/key/
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -12,9 +12,9 @@ namespace ircd::m::sync
|
|||
{
|
||||
struct args;
|
||||
struct stats;
|
||||
struct shortpoll;
|
||||
struct data;
|
||||
struct response;
|
||||
|
||||
extern log::log log;
|
||||
extern const string_view description;
|
||||
extern resource resource;
|
||||
extern resource::method method_get;
|
||||
|
|
@ -70,27 +70,14 @@ namespace ircd::m::sync::linear
|
|||
{
|
||||
extern conf::item<size_t> delta_max;
|
||||
|
||||
static bool handle(client &, shortpoll &, json::stack::object &);
|
||||
static bool handle(client &, data &, json::stack::object &);
|
||||
}
|
||||
|
||||
namespace ircd::m::sync::polylog
|
||||
{
|
||||
extern conf::item<bool> prefetch_state;
|
||||
extern conf::item<bool> prefetch_timeline;
|
||||
|
||||
static void room_state(shortpoll &, json::stack::object &, const m::room &);
|
||||
static m::event::id::buf room_timeline_events(shortpoll &, json::stack::array &, const m::room &, bool &limited);
|
||||
static void room_timeline(shortpoll &, json::stack::object &, const m::room &);
|
||||
static void room_ephemeral_events(shortpoll &, json::stack::array &, const m::room &);
|
||||
static void room_ephemeral(shortpoll &, json::stack::object &, const m::room &);
|
||||
static void room_account_data(shortpoll &, json::stack::object &, const m::room &);
|
||||
static void room_unread_notifications(shortpoll &, json::stack::object &, const m::room &);
|
||||
static void sync_room(shortpoll &, json::stack::object &, const m::room &, const string_view &membership);
|
||||
static void sync_rooms(shortpoll &, json::stack::object &, const string_view &membership);
|
||||
static void rooms(shortpoll &, json::stack::object &);
|
||||
static void presence(shortpoll &, json::stack::object &);
|
||||
static void account_data(shortpoll &, json::stack::object &);
|
||||
static bool handle(client &, shortpoll &, json::stack::object &);
|
||||
static void sync_room(data &, json::stack::object &, const m::room &);
|
||||
static void sync_rooms(data &, json::stack::object &, const string_view &membership);
|
||||
static bool handle(client &, data &, json::stack::object &);
|
||||
}
|
||||
|
||||
/// Argument parser for the client's /sync request
|
||||
|
|
@ -151,113 +138,3 @@ struct ircd::m::sync::args
|
|||
request.query.get("set_presence", true)
|
||||
};
|
||||
};
|
||||
|
||||
struct ircd::m::sync::stats
|
||||
{
|
||||
ircd::timer timer;
|
||||
size_t flush_bytes {0};
|
||||
size_t flush_count {0};
|
||||
};
|
||||
|
||||
struct ircd::m::sync::shortpoll
|
||||
{
|
||||
static conf::item<size_t> flush_hiwat;
|
||||
|
||||
shortpoll(ircd::client &client,
|
||||
const sync::args &args)
|
||||
:client{client}
|
||||
,args{args}
|
||||
{}
|
||||
|
||||
sync::stats stats;
|
||||
ircd::client &client;
|
||||
const sync::args &args;
|
||||
const resource::request &request
|
||||
{
|
||||
args.request
|
||||
};
|
||||
|
||||
const uint64_t &since
|
||||
{
|
||||
args.since
|
||||
};
|
||||
|
||||
const uint64_t current
|
||||
{
|
||||
m::vm::current_sequence
|
||||
};
|
||||
|
||||
const uint64_t delta
|
||||
{
|
||||
current - since
|
||||
};
|
||||
|
||||
const m::user user
|
||||
{
|
||||
request.user_id
|
||||
};
|
||||
|
||||
const std::string filter_buf
|
||||
{
|
||||
args.filter_id?
|
||||
user.filter(std::nothrow, args.filter_id):
|
||||
std::string{}
|
||||
};
|
||||
|
||||
const m::filter filter
|
||||
{
|
||||
json::object{filter_buf}
|
||||
};
|
||||
|
||||
const m::user::room user_room
|
||||
{
|
||||
user
|
||||
};
|
||||
|
||||
const m::user::rooms rooms
|
||||
{
|
||||
user
|
||||
};
|
||||
|
||||
uint64_t state_at
|
||||
{
|
||||
0
|
||||
};
|
||||
|
||||
bool committed
|
||||
{
|
||||
false
|
||||
};
|
||||
|
||||
unique_buffer<mutable_buffer> buf
|
||||
{
|
||||
std::max(size_t(96_KiB), size_t(flush_hiwat))
|
||||
};
|
||||
|
||||
std::unique_ptr<resource::response::chunked> response;
|
||||
json::stack out
|
||||
{
|
||||
buf, std::bind(&shortpoll::flush, this, ph::_1), size_t(flush_hiwat)
|
||||
};
|
||||
|
||||
void commit()
|
||||
{
|
||||
response = std::make_unique<resource::response::chunked>
|
||||
(
|
||||
client, http::OK, "application/json; charset=utf-8"
|
||||
);
|
||||
}
|
||||
|
||||
const_buffer flush(const const_buffer &buf)
|
||||
{
|
||||
if(!committed)
|
||||
return buf;
|
||||
|
||||
if(!response)
|
||||
commit();
|
||||
|
||||
stats.flush_bytes += response->write(buf);
|
||||
stats.flush_count++;
|
||||
return buf;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
64
modules/client/sync/account_data.cc
Normal file
64
modules/client/sync/account_data.cc
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Account Data"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static bool account_data_polylog(data &);
|
||||
extern item account_data;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::account_data)
|
||||
ircd::m::sync::account_data
|
||||
{
|
||||
"account_data",
|
||||
account_data_polylog
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::account_data_polylog(data &data)
|
||||
{
|
||||
json::stack::object out{*data.member};
|
||||
json::stack::member member{out, "events"};
|
||||
json::stack::array array{member};
|
||||
const m::room::state state{data.user_room};
|
||||
state.for_each("ircd.account_data", [&data, &array]
|
||||
(const m::event &event)
|
||||
{
|
||||
const auto &event_idx(index(event, std::nothrow));
|
||||
if(event_idx < data.since || event_idx > data.current)
|
||||
return;
|
||||
|
||||
json::stack::object object{array};
|
||||
|
||||
// type
|
||||
{
|
||||
json::stack::member member
|
||||
{
|
||||
object, "type", at<"state_key"_>(event)
|
||||
};
|
||||
}
|
||||
|
||||
// content
|
||||
{
|
||||
json::stack::member member
|
||||
{
|
||||
object, "content", at<"content"_>(event)
|
||||
};
|
||||
}
|
||||
});
|
||||
|
||||
return true;
|
||||
}
|
||||
114
modules/client/sync/presence.cc
Normal file
114
modules/client/sync/presence.cc
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Presence"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static bool presence_polylog(data &);
|
||||
extern item presence;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::presence)
|
||||
ircd::m::sync::presence
|
||||
{
|
||||
"presence",
|
||||
presence_polylog
|
||||
};
|
||||
|
||||
namespace ircd
|
||||
{
|
||||
ctx::pool::opts meepool_opts
|
||||
{
|
||||
256_KiB
|
||||
};
|
||||
|
||||
ctx::pool meepool
|
||||
{
|
||||
"meepool", meepool_opts
|
||||
};
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::presence_polylog(data &data)
|
||||
{
|
||||
json::stack::object out{*data.member};
|
||||
json::stack::member member{out, "events"};
|
||||
json::stack::array array{member};
|
||||
const m::user::mitsein mitsein
|
||||
{
|
||||
data.user
|
||||
};
|
||||
|
||||
ctx::mutex mutex;
|
||||
const auto closure{[&data, &array, &mutex]
|
||||
(const json::object &event)
|
||||
{
|
||||
// Lock the json::stack for the append operations. This mutex will only be
|
||||
// contended during a json::stack flush to the client; not during database
|
||||
// queries leading to this.
|
||||
const std::lock_guard<decltype(mutex)> l{mutex};
|
||||
json::stack::object object{array};
|
||||
|
||||
// sender
|
||||
json::stack::member
|
||||
{
|
||||
object, "sender", unquote(event.get("user_id"))
|
||||
};
|
||||
|
||||
// type
|
||||
json::stack::member
|
||||
{
|
||||
object, "type", json::value{"m.presence"}
|
||||
};
|
||||
|
||||
// content
|
||||
json::stack::member
|
||||
{
|
||||
object, "content", event
|
||||
};
|
||||
}};
|
||||
|
||||
const auto each_user{[&data, &closure]
|
||||
(const m::user::id &user_id)
|
||||
{
|
||||
const m::user user{user_id};
|
||||
const m::user::room user_room{user};
|
||||
//TODO: can't check event_idx cuz only closed presence content
|
||||
if(head_idx(std::nothrow, user_room) > data.since)
|
||||
m::presence::get(std::nothrow, user, closure);
|
||||
}};
|
||||
|
||||
//TODO: conf
|
||||
static const size_t fibers(24);
|
||||
string_view q[fibers];
|
||||
char buf[fibers][256];
|
||||
ctx::parallel<string_view> parallel
|
||||
{
|
||||
meepool, q, each_user
|
||||
};
|
||||
|
||||
const auto paraclosure{[¶llel, &q, &buf]
|
||||
(const m::user &u)
|
||||
{
|
||||
assert(parallel.snd < fibers);
|
||||
strlcpy(buf[parallel.snd], string_view{u.user_id});
|
||||
q[parallel.snd] = buf[parallel.snd];
|
||||
parallel();
|
||||
}};
|
||||
|
||||
mitsein.for_each("join", paraclosure);
|
||||
// mitsein.for_each("join", each_user);
|
||||
return true;
|
||||
}
|
||||
68
modules/client/sync/rooms/account_data.cc
Normal file
68
modules/client/sync/rooms/account_data.cc
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Room Account Data"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static bool room_account_data_polylog(data &);
|
||||
extern item room_account_data;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::room_account_data)
|
||||
ircd::m::sync::room_account_data
|
||||
{
|
||||
"rooms...account_data",
|
||||
room_account_data_polylog
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::room_account_data_polylog(data &data)
|
||||
{
|
||||
json::stack::object out{*data.member};
|
||||
json::stack::member member{out, "events"};
|
||||
json::stack::array array{member};
|
||||
const m::room::state state
|
||||
{
|
||||
data.user_room
|
||||
};
|
||||
|
||||
char typebuf[288]; //TODO: room_account_data_typebuf_size
|
||||
const auto type
|
||||
{
|
||||
m::user::_account_data_type(typebuf, data.room->room_id)
|
||||
};
|
||||
|
||||
state.for_each(type, [&data, &array]
|
||||
(const m::event &event)
|
||||
{
|
||||
const auto &event_idx(index(event, std::nothrow));
|
||||
if(event_idx < data.since || event_idx >= data.current)
|
||||
return;
|
||||
|
||||
json::stack::object object{array};
|
||||
|
||||
json::stack::member
|
||||
{
|
||||
object, "type", at<"state_key"_>(event)
|
||||
};
|
||||
|
||||
json::stack::member
|
||||
{
|
||||
object, "content", at<"content"_>(event)
|
||||
};
|
||||
});
|
||||
|
||||
return true;
|
||||
}
|
||||
99
modules/client/sync/rooms/receipt.cc
Normal file
99
modules/client/sync/rooms/receipt.cc
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Room Receipts"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static bool room_ephemeral_m_receipt_m_read_polylog(data &);
|
||||
extern item room_ephemeral_m_receipt_m_read;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::room_ephemeral_m_receipt_m_read)
|
||||
ircd::m::sync::room_ephemeral_m_receipt_m_read
|
||||
{
|
||||
"rooms...ephemeral",
|
||||
room_ephemeral_m_receipt_m_read_polylog
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::room_ephemeral_m_receipt_m_read_polylog(data &data)
|
||||
{
|
||||
const m::room &room{*data.room};
|
||||
const m::room::members members{room};
|
||||
const m::room::members::closure closure{[&]
|
||||
(const m::user::id &user_id)
|
||||
{
|
||||
static const m::event::fetch::opts fopts
|
||||
{
|
||||
m::event::keys::include
|
||||
{
|
||||
"event_id",
|
||||
"content",
|
||||
"sender",
|
||||
},
|
||||
};
|
||||
|
||||
const m::user user{user_id};
|
||||
m::user::room user_room{user};
|
||||
user_room.fopts = &fopts;
|
||||
if(head_idx(std::nothrow, user_room) <= data.since)
|
||||
return;
|
||||
|
||||
user_room.get(std::nothrow, "ircd.read", room.room_id, [&]
|
||||
(const m::event &event)
|
||||
{
|
||||
const auto &event_idx(index(event, std::nothrow));
|
||||
if(event_idx < data.since || event_idx >= data.current)
|
||||
return;
|
||||
|
||||
data.commit();
|
||||
json::stack::object object{*data.array};
|
||||
|
||||
// type
|
||||
json::stack::member
|
||||
{
|
||||
object, "type", "m.receipt"
|
||||
};
|
||||
|
||||
// content
|
||||
const json::object data
|
||||
{
|
||||
at<"content"_>(event)
|
||||
};
|
||||
|
||||
thread_local char buf[1024];
|
||||
const json::members reformat
|
||||
{
|
||||
{ unquote(data.at("event_id")),
|
||||
{
|
||||
{ "m.read",
|
||||
{
|
||||
{ at<"sender"_>(event),
|
||||
{
|
||||
{ "ts", data.at("ts") }
|
||||
}}
|
||||
}}
|
||||
}}
|
||||
};
|
||||
|
||||
json::stack::member
|
||||
{
|
||||
object, "content", json::stringify(mutable_buffer{buf}, reformat)
|
||||
};
|
||||
});
|
||||
}};
|
||||
|
||||
return true;
|
||||
}
|
||||
92
modules/client/sync/rooms/state.cc
Normal file
92
modules/client/sync/rooms/state.cc
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Room State"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static bool room_state_polylog(data &);
|
||||
extern item room_state;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::room_state)
|
||||
ircd::m::sync::room_state
|
||||
{
|
||||
"rooms...state",
|
||||
room_state_polylog
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::room_state_polylog(data &data)
|
||||
{
|
||||
static const m::event::keys::include default_keys
|
||||
{
|
||||
"content",
|
||||
"depth",
|
||||
"event_id",
|
||||
"origin_server_ts",
|
||||
"redacts",
|
||||
"room_id",
|
||||
"sender",
|
||||
"state_key",
|
||||
"type",
|
||||
};
|
||||
|
||||
static const m::event::fetch::opts fopts
|
||||
{
|
||||
default_keys
|
||||
};
|
||||
|
||||
json::stack::object out{*data.member};
|
||||
json::stack::member member
|
||||
{
|
||||
out, "events"
|
||||
};
|
||||
|
||||
json::stack::array array
|
||||
{
|
||||
member
|
||||
};
|
||||
|
||||
ctx::mutex mutex;
|
||||
const event::closure_idx each_idx{[&data, &array, &mutex]
|
||||
(const m::event::idx &event_idx)
|
||||
{
|
||||
assert(event_idx);
|
||||
const event::fetch event
|
||||
{
|
||||
event_idx, std::nothrow, &fopts
|
||||
};
|
||||
|
||||
if(!event.valid || at<"depth"_>(event) >= int64_t(data.state_at))
|
||||
return;
|
||||
|
||||
const std::lock_guard<decltype(mutex)> lock{mutex};
|
||||
array.append(event);
|
||||
data.commit();
|
||||
}};
|
||||
|
||||
const event::closure_idx _each_idx{[&data, &each_idx]
|
||||
(const m::event::idx &event_idx)
|
||||
{
|
||||
assert(event_idx);
|
||||
if(event_idx >= data.since && event_idx <= data.current)
|
||||
each_idx(event_idx);
|
||||
}};
|
||||
|
||||
const m::room &room{*data.room};
|
||||
const m::room::state state{room};
|
||||
state.for_each(_each_idx);
|
||||
return true;
|
||||
}
|
||||
124
modules/client/sync/rooms/timeline.cc
Normal file
124
modules/client/sync/rooms/timeline.cc
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Room Timeline"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static event::id::buf _room_timeline_events(data &, json::stack::array &, const m::room &, bool &);
|
||||
static bool room_timeline_polylog(data &);
|
||||
extern item room_timeline;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::room_timeline)
|
||||
ircd::m::sync::room_timeline
|
||||
{
|
||||
"rooms...timeline",
|
||||
room_timeline_polylog
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::room_timeline_polylog(data &data)
|
||||
{
|
||||
json::stack::object out{*data.member};
|
||||
|
||||
// events
|
||||
bool limited{false};
|
||||
m::event::id::buf prev;
|
||||
{
|
||||
json::stack::member member{out, "events"};
|
||||
json::stack::array array{member};
|
||||
prev = _room_timeline_events(data, array, *data.room, limited);
|
||||
}
|
||||
|
||||
// prev_batch
|
||||
json::stack::member
|
||||
{
|
||||
out, "prev_batch", string_view{prev}
|
||||
};
|
||||
|
||||
// limited
|
||||
json::stack::member
|
||||
{
|
||||
out, "limited", json::value{limited}
|
||||
};
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
ircd::m::event::id::buf
|
||||
ircd::m::sync::_room_timeline_events(data &data,
|
||||
json::stack::array &out,
|
||||
const m::room &room,
|
||||
bool &limited)
|
||||
{
|
||||
static const m::event::fetch::opts fopts
|
||||
{
|
||||
m::event::keys::include
|
||||
{
|
||||
"content",
|
||||
"depth",
|
||||
"event_id",
|
||||
"origin_server_ts",
|
||||
"prev_events",
|
||||
"redacts",
|
||||
"room_id",
|
||||
"sender",
|
||||
"state_key",
|
||||
"type",
|
||||
},
|
||||
};
|
||||
|
||||
// messages seeks to the newest event, but the client wants the oldest
|
||||
// event first so we seek down first and then iterate back up. Due to
|
||||
// an issue with rocksdb's prefix-iteration this iterator becomes
|
||||
// toxic as soon as it becomes invalid. As a result we have to copy the
|
||||
// event_id on the way down in case of renewing the iterator for the
|
||||
// way back. This is not a big deal but rocksdb should fix their shit.
|
||||
ssize_t i(0);
|
||||
m::event::id::buf event_id;
|
||||
m::room::messages it
|
||||
{
|
||||
room, &fopts
|
||||
};
|
||||
|
||||
for(; it && i < 10; --it, ++i)
|
||||
{
|
||||
event_id = it.event_id();
|
||||
if(it.event_idx() < data.since)
|
||||
break;
|
||||
|
||||
if(it.event_idx() > data.current)
|
||||
break;
|
||||
}
|
||||
|
||||
limited = i >= 10;
|
||||
if(i > 0)
|
||||
data.commit();
|
||||
|
||||
if(i > 0 && !it)
|
||||
it.seek(event_id);
|
||||
|
||||
if(i > 0 && it)
|
||||
{
|
||||
const m::event &event{*it};
|
||||
data.state_at = at<"depth"_>(event);
|
||||
}
|
||||
|
||||
if(i > 0)
|
||||
for(; it && i > -1; ++it, --i)
|
||||
out.append(*it);
|
||||
|
||||
return event_id;
|
||||
}
|
||||
89
modules/client/sync/rooms/unread_notifications.cc
Normal file
89
modules/client/sync/rooms/unread_notifications.cc
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
// Matrix Construct
|
||||
//
|
||||
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
||||
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
||||
//
|
||||
// Permission to use, copy, modify, and/or distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice is present in all copies. The
|
||||
// full license for this software is available in the LICENSE file.
|
||||
|
||||
ircd::mapi::header
|
||||
IRCD_MODULE
|
||||
{
|
||||
"Client Sync :Room Unread Notifications"
|
||||
};
|
||||
|
||||
namespace ircd::m::sync
|
||||
{
|
||||
static long _notification_count(const room &, const event::idx &a, const event::idx &b);
|
||||
static long _highlight_count(const room &, const user &u, const event::idx &a, const event::idx &b);
|
||||
static bool room_unread_notifications_polylog(data &);
|
||||
extern item room_unread_notifications;
|
||||
}
|
||||
|
||||
decltype(ircd::m::sync::room_unread_notifications)
|
||||
ircd::m::sync::room_unread_notifications
|
||||
{
|
||||
"rooms...unread_notifications",
|
||||
room_unread_notifications_polylog
|
||||
};
|
||||
|
||||
bool
|
||||
ircd::m::sync::room_unread_notifications_polylog(data &data)
|
||||
{
|
||||
auto &room{*data.room};
|
||||
m::event::id::buf last_read;
|
||||
if(!m::receipt::read(last_read, room.room_id, data.user))
|
||||
return false;
|
||||
|
||||
json::stack::object out{*data.member};
|
||||
const auto last_read_idx
|
||||
{
|
||||
index(last_read)
|
||||
};
|
||||
|
||||
// highlight_count
|
||||
json::stack::member
|
||||
{
|
||||
out, "highlight_count", json::value
|
||||
{
|
||||
_highlight_count(room, data.user, last_read_idx, data.current)
|
||||
}
|
||||
};
|
||||
|
||||
// notification_count
|
||||
json::stack::member
|
||||
{
|
||||
out, "notification_count", json::value
|
||||
{
|
||||
_notification_count(room, last_read_idx, data.current)
|
||||
}
|
||||
};
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
long
|
||||
ircd::m::sync::_notification_count(const room &room,
|
||||
const event::idx &a,
|
||||
const event::idx &b)
|
||||
{
|
||||
return m::count_since(room, a, a < b? b : a);
|
||||
}
|
||||
|
||||
long
|
||||
ircd::m::sync::_highlight_count(const room &r,
|
||||
const user &u,
|
||||
const event::idx &a,
|
||||
const event::idx &b)
|
||||
{
|
||||
using proto = size_t (const user &, const room &, const event::idx &, const event::idx &);
|
||||
|
||||
static mods::import<proto> count
|
||||
{
|
||||
"m_user", "highlighted_count__between"
|
||||
};
|
||||
|
||||
return count(u, r, a, a < b? b : a);
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue