ozzy-proto 0.5.0

Sans-I/O application protocol and message types for Ozzy.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Field and frame checks shared by the correlated control codecs.

use crate::{
    Envelope, EnvelopeLimits, GroupId, Opcode, Packet, append::Authority, data::CodecError,
    layout::Reader,
};

/// Require a correlated request or reply with this opcode.
pub(crate) fn command(
    envelope: Envelope,
    opcode: Opcode,
    response: bool,
) -> Result<(), CodecError> {
    if envelope.opcode != opcode
        || envelope.response != response
        || envelope.request_id.is_none()
        || envelope.session.is_none()
    {
        return Err(CodecError::Profile);
    }
    Ok(())
}

/// Check a metadata-only packet's command and frame bounds.
pub(crate) fn check(
    packet: Packet<'_>,
    opcode: Opcode,
    response: bool,
    limits: EnvelopeLimits,
) -> Result<(), CodecError> {
    command(packet.envelope, opcode, response)?;
    packet
        .envelope
        .validate_frames(packet.metadata.len(), packet.payload.len(), limits)?;
    if !packet.payload.is_empty() {
        return Err(CodecError::Length);
    }
    Ok(())
}

/// [`check`] a packet whose metadata has a fixed `length`.
pub(crate) fn check_exact(
    packet: Packet<'_>,
    opcode: Opcode,
    response: bool,
    length: usize,
    limits: EnvelopeLimits,
) -> Result<(), CodecError> {
    check(packet, opcode, response, limits)?;
    if packet.metadata.len() != length {
        return Err(CodecError::Length);
    }
    Ok(())
}

/// Clear `metadata` for an encoding of `length` bytes it can hold.
pub(crate) fn reserve(metadata: &mut Vec<u8>, length: usize) -> Result<(), CodecError> {
    if metadata.capacity() < length {
        return Err(CodecError::Capacity);
    }
    metadata.clear();
    Ok(())
}

pub(crate) fn encode_authority(metadata: &mut Vec<u8>, authority: Authority) {
    metadata.extend_from_slice(authority.group_id.as_bytes());
    metadata.extend_from_slice(&authority.config_epoch.to_be_bytes());
    metadata.extend_from_slice(&authority.view.to_be_bytes());
}

pub(crate) fn decode_authority(cursor: &mut Reader<'_>) -> Result<Authority, CodecError> {
    Ok(Authority {
        group_id: GroupId::from_bytes(cursor.array()?),
        config_epoch: cursor.u64()?,
        view: cursor.u64()?,
    })
}

/// Reject an all-zero identity.
pub(crate) fn nonzero(bytes: &[u8; 16]) -> Result<(), CodecError> {
    if bytes == &[0; 16] {
        return Err(CodecError::Identity);
    }
    Ok(())
}