2018-02-04 03:22:01 +01:00
|
|
|
// 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.
|
2017-09-26 06:42:07 +02:00
|
|
|
|
|
|
|
#pragma once
|
2017-10-25 18:47:03 +02:00
|
|
|
#define HAVE_IRCD_M_VM_H
|
2017-09-26 06:42:07 +02:00
|
|
|
|
2017-11-16 02:48:25 +01:00
|
|
|
/// Matrix Virtual Machine
|
|
|
|
///
|
2017-10-25 18:47:03 +02:00
|
|
|
namespace ircd::m::vm
|
2017-09-26 06:42:07 +02:00
|
|
|
{
|
2018-02-28 07:53:44 +01:00
|
|
|
struct error; // custom exception
|
2019-10-03 19:51:29 +02:00
|
|
|
struct init;
|
2018-02-28 07:53:44 +01:00
|
|
|
struct opts;
|
2018-05-07 01:04:51 +02:00
|
|
|
struct copts;
|
2017-11-16 02:48:25 +01:00
|
|
|
struct eval;
|
2018-04-16 23:21:54 +02:00
|
|
|
enum fault :uint;
|
2020-05-12 04:37:55 +02:00
|
|
|
enum phase :uint;
|
2018-02-28 07:53:44 +01:00
|
|
|
using fault_t = std::underlying_type<fault>::type;
|
2017-09-26 06:42:07 +02:00
|
|
|
|
2019-03-21 23:58:18 +01:00
|
|
|
extern const opts default_opts;
|
|
|
|
extern const copts default_copts;
|
|
|
|
extern log::log log;
|
|
|
|
extern ctx::dock dock;
|
|
|
|
extern bool ready;
|
2019-10-03 19:51:29 +02:00
|
|
|
|
|
|
|
string_view reflect(const fault &);
|
2020-05-12 04:37:55 +02:00
|
|
|
string_view reflect(const phase &);
|
2019-10-03 19:51:29 +02:00
|
|
|
http::code http_code(const fault &);
|
|
|
|
string_view loghead(const mutable_buffer &, const eval &);
|
|
|
|
string_view loghead(const eval &); // single tls buffer
|
|
|
|
|
2020-12-01 05:47:57 +01:00
|
|
|
fault execute(eval &, const vector_view<const event> &);
|
|
|
|
fault execute(eval &, const json::array &);
|
2019-10-03 19:51:29 +02:00
|
|
|
fault inject(eval &, json::iov &, const json::iov &);
|
2017-11-16 02:48:25 +01:00
|
|
|
}
|
|
|
|
|
2019-03-19 19:45:01 +01:00
|
|
|
namespace ircd::m::vm::sequence
|
|
|
|
{
|
2019-03-21 23:58:18 +01:00
|
|
|
extern ctx::dock dock;
|
2019-03-19 19:45:01 +01:00
|
|
|
extern uint64_t retired; // already written; always monotonic
|
|
|
|
extern uint64_t committed; // pending write; usually monotonic
|
|
|
|
extern uint64_t uncommitted; // evaluating; not monotonic
|
2019-03-26 04:17:49 +01:00
|
|
|
static size_t pending;
|
2019-03-19 19:45:01 +01:00
|
|
|
|
|
|
|
const uint64_t &get(const eval &);
|
2019-03-21 22:11:42 +01:00
|
|
|
uint64_t get(id::event::buf &); // [GET]
|
2019-03-19 19:45:01 +01:00
|
|
|
uint64_t max();
|
|
|
|
uint64_t min();
|
|
|
|
};
|
|
|
|
|
2019-10-03 19:51:29 +02:00
|
|
|
struct ircd::m::vm::init
|
|
|
|
{
|
|
|
|
init(), ~init() noexcept;
|
|
|
|
};
|
|
|
|
|
2018-02-08 22:23:01 +01:00
|
|
|
/// Event Evaluation Device
|
|
|
|
///
|
|
|
|
/// This object conducts the evaluation of an event or a tape of multiple
|
|
|
|
/// events. An event is evaluated in an attempt to execute it. Events which
|
|
|
|
/// fail during evaluation won't be executed; such is the case for events which
|
|
|
|
/// have already been executed, or events which are invalid or lead to invalid
|
|
|
|
/// transitions or actions of the machine etc.
|
|
|
|
///
|
|
|
|
struct ircd::m::vm::eval
|
2018-05-07 02:07:18 +02:00
|
|
|
:instance_list<eval>
|
2018-02-08 22:23:01 +01:00
|
|
|
{
|
2019-03-19 19:45:01 +01:00
|
|
|
static uint64_t id_ctr;
|
2019-03-21 23:58:18 +01:00
|
|
|
static uint executing;
|
|
|
|
static uint injecting;
|
2019-02-07 05:54:04 +01:00
|
|
|
|
2018-05-07 01:04:51 +02:00
|
|
|
const vm::opts *opts {&default_opts};
|
|
|
|
const vm::copts *copts {nullptr};
|
2019-03-19 19:45:01 +01:00
|
|
|
ctx::ctx *ctx {ctx::current};
|
2020-05-13 02:49:15 +02:00
|
|
|
vm::eval *parent {nullptr};
|
|
|
|
vm::eval *child {nullptr};
|
2019-03-19 19:45:01 +01:00
|
|
|
uint64_t id {++id_ctr};
|
2019-02-07 05:54:04 +01:00
|
|
|
uint64_t sequence {0};
|
2019-03-21 22:13:45 +01:00
|
|
|
std::shared_ptr<db::txn> txn;
|
2020-11-30 01:18:40 +01:00
|
|
|
unique_mutable_buffer buf;
|
2020-12-01 05:47:57 +01:00
|
|
|
size_t evaluated {0};
|
|
|
|
size_t accepted {0};
|
|
|
|
size_t faulted {0};
|
2019-02-07 05:54:04 +01:00
|
|
|
|
2020-09-14 00:23:42 +02:00
|
|
|
vector_view<const m::event> pdus;
|
2018-05-07 03:10:01 +02:00
|
|
|
const json::iov *issue {nullptr};
|
|
|
|
const event *event_ {nullptr};
|
2019-03-19 19:45:01 +01:00
|
|
|
string_view room_id;
|
2018-05-07 01:04:51 +02:00
|
|
|
event::id::buf event_id;
|
2019-03-19 19:45:01 +01:00
|
|
|
event::conforms report;
|
2019-07-10 11:14:38 +02:00
|
|
|
string_view room_version;
|
2020-05-13 01:31:54 +02:00
|
|
|
hook::base *hook {nullptr};
|
2020-05-12 04:37:55 +02:00
|
|
|
vm::phase phase {vm::phase(0)};
|
2020-03-22 01:23:08 +01:00
|
|
|
bool room_internal {false};
|
2019-03-19 19:45:01 +01:00
|
|
|
|
2020-02-21 00:39:06 +01:00
|
|
|
void mfetch_keys() const;
|
|
|
|
|
2018-05-08 01:08:52 +02:00
|
|
|
public:
|
2020-09-14 00:29:28 +02:00
|
|
|
operator const event::id::buf &() const
|
|
|
|
{
|
|
|
|
return event_id;
|
|
|
|
}
|
2018-02-08 22:23:01 +01:00
|
|
|
|
2018-05-07 01:04:51 +02:00
|
|
|
eval(const vm::opts &);
|
|
|
|
eval(const vm::copts &);
|
2018-02-28 07:53:44 +01:00
|
|
|
eval(const event &, const vm::opts & = default_opts);
|
2020-12-01 05:47:57 +01:00
|
|
|
eval(const vector_view<const m::event> &, const vm::opts & = default_opts);
|
|
|
|
eval(const json::array &, const vm::opts & = default_opts);
|
2018-05-07 01:04:51 +02:00
|
|
|
eval(json::iov &event, const json::iov &content, const vm::copts & = default_copts);
|
|
|
|
eval() = default;
|
2018-04-16 23:24:56 +02:00
|
|
|
eval(eval &&) = delete;
|
|
|
|
eval(const eval &) = delete;
|
2019-04-22 21:23:37 +02:00
|
|
|
eval &operator=(eval &&) = delete;
|
|
|
|
eval &operator=(const eval &) = delete;
|
2018-05-07 02:35:12 +02:00
|
|
|
~eval() noexcept;
|
2019-02-07 05:54:21 +01:00
|
|
|
|
2019-03-21 22:11:42 +01:00
|
|
|
static bool for_each(const ctx::ctx *const &, const std::function<bool (eval &)> &);
|
2020-05-13 02:49:15 +02:00
|
|
|
static eval *find_parent(const eval &, const ctx::ctx & = ctx::cur());
|
|
|
|
static eval *find_root(const eval &, const ctx::ctx & = ctx::cur());
|
2019-03-21 22:11:42 +01:00
|
|
|
static size_t count(const ctx::ctx *const &);
|
2020-05-13 02:27:44 +02:00
|
|
|
|
|
|
|
static bool for_each(const std::function<bool (eval &)> &);
|
|
|
|
static bool for_each_pdu(const std::function<bool (const event &)> &);
|
|
|
|
static const event *find_pdu(const eval &, const event::id &);
|
|
|
|
static const event *find_pdu(const event::id &);
|
2019-09-11 21:51:54 +02:00
|
|
|
static size_t count(const event::id &);
|
2019-02-07 05:54:21 +01:00
|
|
|
static eval *find(const event::id &);
|
|
|
|
static eval &get(const event::id &);
|
2020-05-13 02:27:44 +02:00
|
|
|
|
2019-03-19 19:45:01 +01:00
|
|
|
static bool sequnique(const uint64_t &seq);
|
|
|
|
static eval *seqnext(const uint64_t &seq);
|
|
|
|
static eval *seqmax();
|
|
|
|
static eval *seqmin();
|
|
|
|
static void seqsort();
|
2018-02-08 22:23:01 +01:00
|
|
|
};
|
|
|
|
|
2017-11-30 20:01:14 +01:00
|
|
|
/// Evaluation faults. These are reasons which evaluation has halted but may
|
|
|
|
/// continue after the user defaults the fault. They are basically types of
|
2018-02-28 07:53:44 +01:00
|
|
|
/// interrupts and traps, which are supposed to be recoverable. Only the
|
|
|
|
/// GENERAL protection fault (#gp) is an abort and is not supposed to be
|
|
|
|
/// recoverable. The fault codes have the form of bitflags so they can be
|
|
|
|
/// used in masks; outside of that case only one fault is dealt with at
|
|
|
|
/// a time so they can be switched as they appear in the enum.
|
2017-11-30 20:01:14 +01:00
|
|
|
///
|
|
|
|
enum ircd::m::vm::fault
|
|
|
|
:uint
|
|
|
|
{
|
2018-02-28 07:53:44 +01:00
|
|
|
ACCEPT = 0x00, ///< No fault.
|
|
|
|
EXISTS = 0x01, ///< Replaying existing event. (#ex)
|
2019-04-22 21:27:43 +02:00
|
|
|
GENERAL = 0x02, ///< General protection fault. (#gp)
|
|
|
|
INVALID = 0x04, ///< Non-conforming event format. (#ud)
|
|
|
|
AUTH = 0x08, ///< Auth rules violation. (#av)
|
2019-04-08 05:57:43 +02:00
|
|
|
STATE = 0x10, ///< Required state is missing (#st)
|
2018-02-28 07:53:44 +01:00
|
|
|
EVENT = 0x20, ///< Eval requires addl events in the ef register (#ef)
|
2017-11-30 20:01:14 +01:00
|
|
|
};
|
2018-02-28 07:53:44 +01:00
|
|
|
|
2020-05-12 04:37:55 +02:00
|
|
|
/// Evaluation phases
|
|
|
|
enum ircd::m::vm::phase
|
|
|
|
:uint
|
|
|
|
{
|
2020-05-12 23:50:31 +02:00
|
|
|
NONE, ///< No phase; not entered.
|
|
|
|
DUPCHK, ///< Duplicate check & hold.
|
|
|
|
EXECUTE, ///< Execution entered.
|
|
|
|
ISSUE, ///< Issue phase.
|
|
|
|
CONFORM, ///< Conformity check phase.
|
|
|
|
ACCESS, ///< Access control phase.
|
|
|
|
VERIFY, ///< Signature verification.
|
|
|
|
FETCH_AUTH, ///< Authentication events fetch phase.
|
|
|
|
AUTH_STATIC, ///< Static authentication phase.
|
|
|
|
FETCH_PREV, ///< Previous events fetch phase.
|
|
|
|
FETCH_STATE, ///< State events fetch phase.
|
|
|
|
PRECOMMIT, ///< Precommit sequence.
|
|
|
|
AUTH_RELA, ///< Relative authentication phase.
|
|
|
|
COMMIT, ///< Commit sequence.
|
|
|
|
AUTH_PRES, ///< Authentication phase.
|
|
|
|
EVALUATE, ///< Evaluation phase.
|
|
|
|
INDEX, ///< Indexing & transaction building phase.
|
|
|
|
POST, ///< Transaction-included effects phase.
|
|
|
|
WRITE, ///< Write transaction.
|
|
|
|
RETIRE, ///< Retire phase
|
|
|
|
NOTIFY, ///< Notifications phase.
|
|
|
|
EFFECTS, ///< Effects phase.
|
2020-05-12 04:37:55 +02:00
|
|
|
_NUM_
|
|
|
|
};
|
|
|
|
|
2018-02-28 07:53:44 +01:00
|
|
|
/// Evaluation Options
|
|
|
|
struct ircd::m::vm::opts
|
|
|
|
{
|
2019-04-22 21:25:50 +02:00
|
|
|
/// The remote server name which is conducting this eval.
|
|
|
|
string_view node_id;
|
|
|
|
|
|
|
|
/// The mxid of the user which is conducting this eval.
|
|
|
|
string_view user_id;
|
|
|
|
|
2020-01-07 01:22:30 +01:00
|
|
|
/// The txnid from the node conducting the eval.
|
|
|
|
string_view txn_id;
|
|
|
|
|
2020-05-12 04:37:55 +02:00
|
|
|
/// Enabled phases of evaluation.
|
|
|
|
std::bitset<num_of<vm::phase>()> phase {-1UL};
|
2019-03-09 21:08:05 +01:00
|
|
|
|
2019-05-12 00:30:40 +02:00
|
|
|
/// Custom write_opts to use during write.
|
|
|
|
dbs::write_opts wopts;
|
|
|
|
|
2018-05-28 04:56:04 +02:00
|
|
|
/// Broadcast to local clients (/sync stream).
|
|
|
|
bool notify_clients {true};
|
|
|
|
|
|
|
|
/// Broadcast to federation servers (/federation/send/).
|
|
|
|
bool notify_servers {true};
|
2018-02-28 07:53:44 +01:00
|
|
|
|
2018-03-13 03:34:54 +01:00
|
|
|
/// False to allow a dirty conforms report (not recommended).
|
|
|
|
bool conforming {true};
|
|
|
|
|
2020-05-12 04:37:55 +02:00
|
|
|
/// False to bypass all auth phases.
|
|
|
|
bool auth {true};
|
|
|
|
|
2020-05-12 05:24:54 +02:00
|
|
|
/// False to bypass all fetch phases.
|
|
|
|
bool fetch {true};
|
|
|
|
|
2018-03-13 03:34:54 +01:00
|
|
|
/// Mask of conformity failures to allow without considering dirty.
|
2018-02-28 07:53:44 +01:00
|
|
|
event::conforms non_conform;
|
|
|
|
|
2018-03-13 03:34:54 +01:00
|
|
|
/// If the event was already checked before the eval, set this to true
|
|
|
|
/// and include the report (see below).
|
|
|
|
bool conformed {false};
|
|
|
|
|
|
|
|
/// When conformed=true, this report will be included instead of generating
|
|
|
|
/// one during the eval. This is useful if a conformity check was already
|
|
|
|
/// done before eval.
|
|
|
|
event::conforms report;
|
|
|
|
|
2019-07-10 11:14:38 +02:00
|
|
|
/// Supply the room version; overrides/avoids any internal query.
|
|
|
|
string_view room_version;
|
|
|
|
|
2020-12-01 10:50:37 +01:00
|
|
|
/// When true, the event is expected to have its content; hash mismatch
|
|
|
|
/// is not permitted. When false, hash mismatch is permitted. When -1,
|
|
|
|
/// by default the origin server is allowed to redact the content.
|
|
|
|
int8_t require_content {-1};
|
|
|
|
|
2018-03-09 00:55:54 +01:00
|
|
|
/// Toggles whether event may be considered a "present event" and may
|
|
|
|
/// update the optimized present state table of the room if it is proper.
|
|
|
|
bool present {true};
|
|
|
|
|
2019-09-14 00:26:44 +02:00
|
|
|
/// Evaluate in EDU mode. Input must not have event_id and none will be
|
|
|
|
/// generated for it.
|
|
|
|
bool edu {false};
|
|
|
|
|
2018-02-28 07:53:44 +01:00
|
|
|
/// Bypass check for event having already been evaluated so it can be
|
|
|
|
/// replayed through the system (not recommended).
|
|
|
|
bool replays {false};
|
|
|
|
|
2020-03-17 19:21:27 +01:00
|
|
|
/// Bypass check for another evaluation of the same event_id already
|
|
|
|
/// occurring. If this is false (not recommended) two duplicate events
|
|
|
|
/// being evaluated may race through the core.
|
|
|
|
bool unique {true};
|
|
|
|
|
2020-08-31 22:32:22 +02:00
|
|
|
/// When true, events in array inputs are evaluated as they are provided
|
|
|
|
/// without any reordering before eval.
|
|
|
|
bool ordered {false};
|
|
|
|
|
2019-01-24 20:32:57 +01:00
|
|
|
/// If the input event has a reference to already-strung json we can use
|
|
|
|
/// that directly when writing to the DB. When this is false we will
|
|
|
|
/// re-stringify the event internally either from a referenced source or
|
|
|
|
/// the tuple if no source is referenced. This should only be set to true
|
|
|
|
/// if the evaluator already performed this and the json source is good.
|
|
|
|
bool json_source {false};
|
|
|
|
|
2020-02-21 00:39:06 +01:00
|
|
|
/// Whether to gather all unknown keys from an input vector of events and
|
|
|
|
/// perform a parallel/mass fetch before proceeding with the evals.
|
|
|
|
bool mfetch_keys {true};
|
|
|
|
|
2019-04-30 22:57:12 +02:00
|
|
|
/// Throws fault::EVENT if *all* of the prev_events do not exist locally.
|
|
|
|
/// This is used to enforce that at least one path is traversable. This
|
|
|
|
/// test is conducted after waiting if fetch_prev and fetch_prev_wait.
|
2019-05-20 00:22:49 +02:00
|
|
|
bool fetch_prev_any {false};
|
2019-04-30 22:57:12 +02:00
|
|
|
|
2019-04-22 21:27:43 +02:00
|
|
|
/// Throws fault::EVENT if *any* of the prev_events do not exist locally.
|
2019-04-30 22:57:12 +02:00
|
|
|
/// This is used to enforce that all references have been acquired; other
|
|
|
|
/// corollary conditions are similar to fetch_prev_any.
|
2019-04-22 21:27:43 +02:00
|
|
|
bool fetch_prev_all {false};
|
2019-03-27 21:45:21 +01:00
|
|
|
|
2020-04-17 23:01:58 +02:00
|
|
|
/// The number of iterations of the wait cycle which checks for missing
|
|
|
|
/// prev_events will iterate before issuing remote fetches for them.
|
|
|
|
/// The default is 0 which bypasses the functionality, and is recommended
|
|
|
|
/// when the evaluator is confident missing prev_events won't arrive
|
|
|
|
/// elsehow. Setting to -1 enables it with an auto/conf value.
|
|
|
|
size_t fetch_prev_wait_count {0};
|
|
|
|
|
|
|
|
/// Base time to wait for missing prev_events to arrive at the server by
|
|
|
|
/// some other means before issuing remote fetches for them. The waiting
|
|
|
|
/// occurs in a loop where prev_events satisfaction is checked at each
|
|
|
|
/// iteration. This value is multiplied by the number of iterations for
|
|
|
|
/// multiplicative backoff. The default of -1 is auto / conf.
|
|
|
|
milliseconds fetch_prev_wait_time {-1};
|
|
|
|
|
2019-09-05 22:17:04 +02:00
|
|
|
/// The limit on the number of events to backfill if any of the prev_events
|
|
|
|
/// are missing. -1 is auto / conf.
|
|
|
|
size_t fetch_prev_limit = -1;
|
|
|
|
|
2020-11-20 22:46:37 +01:00
|
|
|
/// Considers any missing prev_event as an indication of possible missing
|
|
|
|
/// state from a history we don't have; allowing a state acquisition. This
|
|
|
|
/// is not practical to apply by default as internal decisions are better.
|
|
|
|
bool fetch_state_any {false};
|
|
|
|
|
|
|
|
/// This option affects the behavior for a case where we are missing the
|
|
|
|
/// (depth - 1) prev_events reference, thus other resolved references
|
|
|
|
/// are not adjacent. Yet at the claimed depth there is no apparent gap
|
|
|
|
/// in the timeline. If true, we assume possible missing state in this
|
|
|
|
/// case, but by default that is far too unrealistic in practice.
|
|
|
|
bool fetch_state_shallow {false};
|
|
|
|
|
2018-04-16 23:24:56 +02:00
|
|
|
/// Evaluators can set this value to optimize the creation of the database
|
|
|
|
/// transaction where the event will be stored. This value should be set
|
|
|
|
/// to the amount of space the event consumes; the JSON-serialized size is
|
2018-04-17 02:28:26 +02:00
|
|
|
/// a good value here. Default of -1 will automatically use serialized().
|
|
|
|
size_t reserve_bytes = -1;
|
2018-04-16 23:24:56 +02:00
|
|
|
|
|
|
|
/// This value is added to reserve_bytes to account for indexing overhead
|
|
|
|
/// in the database transaction allocation. Most evaluators have little
|
|
|
|
/// reason to ever adjust this.
|
2018-06-04 00:18:53 +02:00
|
|
|
size_t reserve_index {1024};
|
2018-04-16 23:24:56 +02:00
|
|
|
|
2020-09-08 01:55:47 +02:00
|
|
|
/// Coarse limit for array evals. The counter is incremented for every
|
|
|
|
/// event; both accepted and faulted.
|
|
|
|
size_t limit = -1;
|
|
|
|
|
2018-02-28 07:53:44 +01:00
|
|
|
/// Mask of faults that are not thrown as exceptions out of eval(). If
|
|
|
|
/// masked, the fault is returned from eval(). By default, the EXISTS
|
2019-04-08 05:57:43 +02:00
|
|
|
/// fault is masked which means existing events won't kill eval loops.
|
2018-02-28 07:53:44 +01:00
|
|
|
fault_t nothrows
|
|
|
|
{
|
2019-04-08 05:57:43 +02:00
|
|
|
EXISTS
|
2018-02-28 07:53:44 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Mask of faults that are logged to the error facility in vm::log.
|
|
|
|
fault_t errorlog
|
|
|
|
{
|
2019-04-08 05:57:43 +02:00
|
|
|
~(EXISTS)
|
2018-02-28 07:53:44 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Mask of faults that are logged to the warning facility in vm::log
|
|
|
|
fault_t warnlog
|
|
|
|
{
|
|
|
|
EXISTS
|
|
|
|
};
|
|
|
|
|
|
|
|
/// Whether to log a debug message on successful eval.
|
|
|
|
bool debuglog_accept {false};
|
|
|
|
|
|
|
|
/// Whether to log an info message on successful eval.
|
|
|
|
bool infolog_accept {false};
|
2020-02-28 21:12:51 +01:00
|
|
|
|
|
|
|
opts() noexcept;
|
2018-02-28 07:53:44 +01:00
|
|
|
};
|
|
|
|
|
2018-04-06 08:07:55 +02:00
|
|
|
/// Extension structure to vm::opts which includes additional options for
|
|
|
|
/// commissioning events originating from this server which are then passed
|
2019-03-21 23:58:18 +01:00
|
|
|
/// through eval (this process is also known as issuing).
|
2018-05-07 01:04:51 +02:00
|
|
|
struct ircd::m::vm::copts
|
2018-04-06 08:07:55 +02:00
|
|
|
:opts
|
|
|
|
{
|
2018-09-06 04:32:14 +02:00
|
|
|
/// A matrix-spec opaque token from a client identifying this eval.
|
|
|
|
string_view client_txnid;
|
|
|
|
|
2019-08-17 09:44:14 +02:00
|
|
|
/// This bitmask covers all of the top-level properties of m::event
|
|
|
|
/// which will be generated internally during injection unless they
|
|
|
|
/// already exist. Clearing any of these bits will prevent the internal
|
|
|
|
/// generation of these properties (i.e. for EDU's).
|
|
|
|
event::keys::selection prop_mask
|
|
|
|
{
|
|
|
|
event::keys::include
|
|
|
|
{
|
|
|
|
"auth_events",
|
|
|
|
"depth",
|
|
|
|
"event_id",
|
|
|
|
"hashes",
|
|
|
|
"origin",
|
|
|
|
"origin_server_ts",
|
|
|
|
"prev_events",
|
|
|
|
"prev_state",
|
|
|
|
"signatures",
|
|
|
|
}
|
|
|
|
};
|
2018-05-12 11:27:39 +02:00
|
|
|
|
2019-08-17 09:44:14 +02:00
|
|
|
/// Call the issue hook or bypass
|
|
|
|
bool issue {true};
|
2018-05-12 11:27:39 +02:00
|
|
|
|
2018-04-06 08:07:55 +02:00
|
|
|
/// Whether to log a debug message before commit
|
|
|
|
bool debuglog_precommit {false};
|
|
|
|
|
|
|
|
/// Whether to log an info message after commit accepted
|
|
|
|
bool infolog_postcommit {false};
|
2020-02-28 21:12:51 +01:00
|
|
|
|
|
|
|
copts() noexcept;
|
2018-04-06 08:07:55 +02:00
|
|
|
};
|
|
|
|
|
2018-02-28 07:53:44 +01:00
|
|
|
struct ircd::m::vm::error
|
|
|
|
:m::error
|
|
|
|
{
|
|
|
|
vm::fault code;
|
|
|
|
|
2018-12-31 01:22:18 +01:00
|
|
|
template<class... args> error(const http::code &, const fault &, const string_view &fmt, args&&... a);
|
|
|
|
template<class... args> error(const fault &, const string_view &fmt, args&&... a);
|
2018-12-10 22:08:35 +01:00
|
|
|
template<class... args> error(const string_view &fmt, args&&... a);
|
2018-02-28 07:53:44 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
template<class... args>
|
2018-12-31 01:22:18 +01:00
|
|
|
ircd::m::vm::error::error(const string_view &fmt,
|
2018-02-28 07:53:44 +01:00
|
|
|
args&&... a)
|
2018-12-31 01:22:18 +01:00
|
|
|
:error
|
2018-02-28 07:53:44 +01:00
|
|
|
{
|
2018-12-31 01:22:18 +01:00
|
|
|
http::INTERNAL_SERVER_ERROR, fault::GENERAL, fmt, std::forward<args>(a)...
|
2018-02-28 07:53:44 +01:00
|
|
|
}
|
2018-12-31 01:22:18 +01:00
|
|
|
{}
|
|
|
|
|
|
|
|
template<class... args>
|
|
|
|
ircd::m::vm::error::error(const fault &code,
|
|
|
|
const string_view &fmt,
|
|
|
|
args&&... a)
|
|
|
|
:error
|
2018-02-28 07:53:44 +01:00
|
|
|
{
|
2019-03-09 22:51:03 +01:00
|
|
|
http_code(code), code, fmt, std::forward<args>(a)...
|
2018-02-28 07:53:44 +01:00
|
|
|
}
|
|
|
|
{}
|
|
|
|
|
|
|
|
template<class... args>
|
2018-12-31 01:22:18 +01:00
|
|
|
ircd::m::vm::error::error(const http::code &httpcode,
|
|
|
|
const fault &code,
|
|
|
|
const string_view &fmt,
|
2018-02-28 07:53:44 +01:00
|
|
|
args&&... a)
|
|
|
|
:m::error
|
|
|
|
{
|
2019-04-20 23:51:42 +02:00
|
|
|
child, httpcode, reflect(code), fmt, std::forward<args>(a)...
|
2018-02-28 07:53:44 +01:00
|
|
|
}
|
|
|
|
,code
|
|
|
|
{
|
2018-12-31 01:22:18 +01:00
|
|
|
code
|
2018-02-28 07:53:44 +01:00
|
|
|
}
|
|
|
|
{}
|