use crate::internal_protocol::{NAMESPACE_ID_BYTES, NAMESPACE_REVISION_BYTES, Opcode};
use crate::internal_core::request::RequestRetryPolicy;
#[path = "protocol_compat_v1.rs"]
mod compat_v1;
#[path = "operation_request.rs"]
mod operation_request;
pub(crate) use operation_request::OperationRequest;
#[derive(Debug, thiserror::Error)]
pub enum ProtocolError {
#[error(transparent)]
Wire(#[from] crate::internal_protocol::ProtocolError),
#[error("request flags contain unknown bits 0x{0:02x}")]
UnknownRequestFlags(u8),
#[error("if-absent and if-present conditions cannot be combined")]
ConflictingSetConditions,
#[error("SET TTL must be greater than zero milliseconds")]
InvalidSetTtl,
#[error("SET TTL is required by ExplicitTtl")]
MissingSetTtl,
#[error("SET TTL is not allowed by this expiration mode")]
UnexpectedSetTtl,
#[error("SET options are invalid")]
InvalidSetOptions,
#[error("namespace ID must be a positive non-zero u64")]
InvalidNamespaceId,
#[error("namespace name is invalid: {0}")]
InvalidNamespaceName(&'static str),
#[error("namespace policy is missing")]
MissingNamespacePolicy,
#[error("namespace policy is not allowed")]
UnexpectedNamespacePolicy,
#[error("namespace policy is invalid: {0}")]
InvalidNamespacePolicy(&'static str),
#[error("namespace revision must be positive")]
InvalidRevision,
}
type Result<T> = std::result::Result<T, ProtocolError>;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum SetCondition {
#[default]
Any,
IfAbsent,
IfPresent,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum ExpirationMode {
#[default]
Inherit,
NoExpiry,
ExplicitTtl,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum EvictionMode {
#[default]
Inherit,
Evictable,
EvictionProtected,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum OverridePolicy {
Allowed,
Disallowed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ExpirationDefault {
NoExpiry,
FixedTtl {
ttl_ms: u64,
},
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EvictionDefault {
Evictable,
EvictionProtected,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct NamespacePolicy {
pub default_expiration: ExpirationDefault,
pub expiration_override: OverridePolicy,
pub default_eviction: EvictionDefault,
pub eviction_override: OverridePolicy,
}
impl Default for NamespacePolicy {
fn default() -> Self {
Self {
default_expiration: ExpirationDefault::NoExpiry,
expiration_override: OverridePolicy::Allowed,
default_eviction: EvictionDefault::Evictable,
eviction_override: OverridePolicy::Allowed,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct NamespaceDescriptor {
pub namespace_id: u64,
pub revision: u64,
pub policy: NamespacePolicy,
}
impl NamespaceDescriptor {
pub fn encode(self) -> Result<Vec<u8>> {
if self.namespace_id == 0 {
return Err(ProtocolError::InvalidNamespaceId);
}
if self.revision == 0 {
return Err(ProtocolError::InvalidRevision);
}
let policy = self.policy.encode()?;
let mut payload =
Vec::with_capacity(NAMESPACE_ID_BYTES + NAMESPACE_REVISION_BYTES + policy.len());
payload.extend_from_slice(&self.namespace_id.to_be_bytes());
payload.extend_from_slice(&self.revision.to_be_bytes());
payload.extend_from_slice(&policy);
Ok(payload)
}
pub fn decode(input: &[u8]) -> Result<Self> {
let fixed = NAMESPACE_ID_BYTES + NAMESPACE_REVISION_BYTES;
if input.len() < fixed {
return Err(crate::internal_protocol::ProtocolError::FrameTooShort {
expected: fixed,
actual: input.len(),
}
.into());
}
let namespace_id = read_u64_be(input)?;
if namespace_id == 0 {
return Err(ProtocolError::InvalidNamespaceId);
}
let revision = read_u64_be(&input[NAMESPACE_ID_BYTES..])?;
if revision == 0 {
return Err(ProtocolError::InvalidRevision);
}
let (policy, policy_len) = compat_v1::decode_namespace_policy(&input[fixed..])?
.ok_or(ProtocolError::MissingNamespacePolicy)?;
if fixed + policy_len != input.len() {
return Err(crate::internal_protocol::ProtocolError::FrameLength {
expected: fixed + policy_len,
actual: input.len(),
}
.into());
}
Ok(Self {
namespace_id,
revision,
policy,
})
}
}
impl NamespacePolicy {
pub fn encode(self) -> Result<Vec<u8>> {
compat_v1::encode_namespace_policy(self)
}
#[cfg(feature = "ffi")]
pub(crate) fn from_wire_parts(flags: u8, ttl_ms: Option<u64>) -> Result<Self> {
compat_v1::decode_namespace_policy_parts(flags, ttl_ms)
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub(crate) struct SetWireOptions {
pub(crate) condition: SetCondition,
pub(crate) expiration_mode: ExpirationMode,
pub(crate) ttl_ms: Option<u64>,
pub(crate) eviction_mode: EvictionMode,
}
impl SetWireOptions {
pub(crate) const fn with_policies(
condition: SetCondition,
expiration_mode: ExpirationMode,
ttl_ms: Option<u64>,
eviction_mode: EvictionMode,
) -> Self {
Self {
condition,
expiration_mode,
ttl_ms,
eviction_mode,
}
}
#[cfg(feature = "ffi")]
pub(crate) fn from_wire_parts(flags: u8, ttl_ms: Option<u64>) -> Result<Self> {
compat_v1::decode_set_options(flags, ttl_ms)
}
}
fn generated_retry_policy(opcode: Opcode, create_if_missing: bool) -> RequestRetryPolicy {
use crate::internal_core::contract::OperationRetryMode;
match crate::internal_core::contract::operation_client_projection(opcode)
.map(|value| value.retry_mode)
{
Some(OperationRetryMode::Always) => RequestRetryPolicy::Always,
Some(OperationRetryMode::WhenNotCreating) if !create_if_missing => {
RequestRetryPolicy::Always
}
Some(OperationRetryMode::Never | OperationRetryMode::WhenNotCreating) | None => {
RequestRetryPolicy::Never
}
}
}
fn read_u64_be(input: &[u8]) -> Result<u64> {
let bytes: [u8; NAMESPACE_ID_BYTES] = input
.get(..NAMESPACE_ID_BYTES)
.ok_or(crate::internal_protocol::ProtocolError::FrameTooShort {
expected: NAMESPACE_ID_BYTES,
actual: input.len(),
})?
.try_into()
.expect("slice length checked");
Ok(u64::from_be_bytes(bytes))
}