jcoffey-dev
7dae9b29fd
Upstream commit: 474dd0229cb20cf513036619781ed97bd8073c3f Enterprise-only files removed or emptied: 63 Enterprise-only snippets removed: 117 in 50 files Dangling module declarations removed: 5 Cargo edits turning enterprise off: 14 Verification: clean Enterprise feature gates left for rebuilt features: 19 in 18 files Produced by tools/fork/strip.py. The full report is in docs/fork/strip-reports/ on main.
239 lines
7.0 KiB
Rust
239 lines
7.0 KiB
Rust
/*
|
|
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
|
|
*/
|
|
|
|
pub mod bootstrap;
|
|
pub mod get;
|
|
pub mod local;
|
|
pub mod query;
|
|
pub mod write;
|
|
|
|
use crate::{
|
|
Deserialize, SerializeInfallible, U16_LEN, U32_LEN, U64_LEN,
|
|
write::key::{DeserializeBigEndian, KeySerializer},
|
|
};
|
|
use registry::{
|
|
pickle::{Pickle, PickledStream},
|
|
schema::{
|
|
prelude::{Object, ObjectInner, ObjectType, Property},
|
|
structs::{
|
|
ArchivedItem, DmarcInternalReport, Metric, SpamTrainingSample, Task, TlsInternalReport,
|
|
Trace,
|
|
},
|
|
},
|
|
types::{EnumImpl, ObjectImpl, id::ObjectId},
|
|
};
|
|
use types::id::Id;
|
|
|
|
pub struct RegistryObject<T: ObjectImpl> {
|
|
pub id: ObjectId,
|
|
pub object: T,
|
|
pub revision: u64,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct RegistryQuery {
|
|
pub(crate) object_type: ObjectType,
|
|
pub filters: Vec<RegistryFilter>,
|
|
pub(crate) start: RegistryQueryStart,
|
|
pub(crate) limit: Option<usize>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Default)]
|
|
pub struct RegistryObjectCounter(pub usize);
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub(crate) enum RegistryQueryStart {
|
|
Index(u64),
|
|
Anchor(u64),
|
|
None,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct RegistryFilter {
|
|
pub property: Property,
|
|
pub op: RegistryFilterOp,
|
|
pub value: RegistryFilterValue,
|
|
pub is_pk: bool,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Clone, Copy, Eq, Hash)]
|
|
pub struct ObjectIdVersioned {
|
|
pub object_id: ObjectId,
|
|
pub version: u32,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum RegistryFilterOp {
|
|
Equal,
|
|
GreaterThan,
|
|
GreaterEqualThan,
|
|
LowerThan,
|
|
LowerEqualThan,
|
|
TextMatch,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RegistryFilterValue {
|
|
String(String),
|
|
Bytes(Vec<u8>),
|
|
U64(u64),
|
|
U16(u16),
|
|
Boolean(bool),
|
|
}
|
|
|
|
impl Deserialize for Object {
|
|
fn deserialize_with_key(key: &[u8], bytes: &[u8]) -> trc::Result<Self> {
|
|
let revision = xxhash_rust::xxh3::xxh3_64(bytes);
|
|
ObjectType::from_id(key.deserialize_be_u16(0)?)
|
|
.and_then(|object_id| ObjectInner::unpickle(object_id, &mut PickledStream::new(bytes)?))
|
|
.map(|inner| Object { revision, inner })
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
|
|
fn deserialize(_: &[u8]) -> trc::Result<Self> {
|
|
unreachable!("Object deserialization requires the object type from the key")
|
|
}
|
|
}
|
|
|
|
impl Deserialize for Task {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Deserialize for SpamTrainingSample {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Deserialize for ArchivedItem {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Deserialize for TlsInternalReport {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Deserialize for DmarcInternalReport {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl SerializeInfallible for ObjectId {
|
|
fn serialize(&self) -> Vec<u8> {
|
|
KeySerializer::new(U16_LEN + U64_LEN)
|
|
.write(self.object().to_id())
|
|
.write(self.id().id())
|
|
.finalize()
|
|
}
|
|
}
|
|
|
|
impl Deserialize for ObjectId {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
let object_id = bytes.deserialize_be_u16(0)?;
|
|
let item_id = bytes.deserialize_be_u64(U16_LEN)?;
|
|
Ok(ObjectId::new(
|
|
ObjectType::from_id(object_id).ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})?,
|
|
Id::new(item_id),
|
|
))
|
|
}
|
|
}
|
|
|
|
impl SerializeInfallible for ObjectIdVersioned {
|
|
fn serialize(&self) -> Vec<u8> {
|
|
KeySerializer::new(U16_LEN + U64_LEN + U32_LEN)
|
|
.write(self.object_id.object().to_id())
|
|
.write(self.object_id.id().id())
|
|
.write(self.version)
|
|
.finalize()
|
|
}
|
|
}
|
|
|
|
impl Deserialize for ObjectIdVersioned {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
let object_id = ObjectId::deserialize(bytes)?;
|
|
let version = bytes.deserialize_be_u32(U16_LEN + U64_LEN)?;
|
|
Ok(Self { object_id, version })
|
|
}
|
|
}
|
|
|
|
impl Deserialize for Trace {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Deserialize for Metric {
|
|
fn deserialize(bytes: &[u8]) -> trc::Result<Self> {
|
|
PickledStream::new(bytes)
|
|
.and_then(|mut stream| Self::unpickle(&mut stream))
|
|
.ok_or_else(|| {
|
|
trc::EventType::Registry(trc::RegistryEvent::DeserializationError)
|
|
.into_err()
|
|
.caused_by(trc::location!())
|
|
.ctx(trc::Key::Value, bytes)
|
|
})
|
|
}
|
|
}
|