Import upstream v0.16.22, stripped

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.
2026-09-18 10:21:56 -07:00
commit 7dae9b29fd
1650 changed files with 485521 additions and 0 deletions
@@ -0,0 +1,238 @@
+/*
+ * 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)
+            })
+    }
+}