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
86
87
88
89
90
91
92

use bytes::{Bytes, BytesMut};

use crate::v2::{
    read::{Section, SectionError},
    Tag,
};

#[derive(Debug, Default, Clone)]
pub(crate) struct Decoder {
    position: usize,
}

impl Decoder {
    pub(crate) fn new(position: usize) -> Self {
        Decoder { position }
    }

    pub(crate) fn position(&self) -> usize {
        self.position
    }

    pub(crate) fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Section>, DecodeError> {
        let header_size = std::mem::size_of::<u8>() + std::mem::size_of::<u64>();

        if src.len() < header_size {
            return Ok(None);
        }

        let tag = src[0];
        let mut length = [0_u8; 8];
        length.copy_from_slice(&src[1..9]);
        let length: usize = u64::from_le_bytes(length).try_into().unwrap();

        if src.len() < header_size + length {
            // We haven't read the entire section yet
            src.reserve(header_size + length);
            return Ok(None);
        }

        let _header = src.split_to(header_size);
        let data = src.split_to(length).freeze();
        self.position += header_size + data.len();

        match Section::parse(tag, data.clone().into()) {
            Ok(s) => Ok(Some(s)),
            Err(error) => Err(DecodeError { error, tag, data }),
        }
    }
}

#[derive(Debug, thiserror::Error)]
#[error("Unable to parse the {} section", Tag::display(*tag))]
pub struct DecodeError {
    #[source]
    pub error: SectionError,
    pub tag: u8,
    pub data: Bytes,
}

#[cfg(test)]
mod tests {
    use crate::{metadata::Manifest, v2::Tag};

    use super::*;

    #[test]
    fn parse_a_single_section() {
        let manifest = Manifest {
            entrypoint: Some("Python".to_string()),
            ..Default::default()
        };
        let serialized_manifest = serde_cbor::to_vec(&manifest).unwrap();
        let section = crate::v2::write::Section::new(
            Tag::Manifest,
            serialized_manifest.clone(),
            crate::v2::ChecksumAlgorithm::None,
        );
        let mut buffer = BytesMut::new();
        section.write_to(&mut buffer);
        let mut decoder = Decoder::default();

        let decoded = decoder.decode(&mut buffer).unwrap().unwrap();

        assert!(buffer.is_empty());
        let reader = match decoded {
            Section::Manifest(r) => r,
            _ => unreachable!(),
        };
        assert_eq!(reader.bytes().as_slice(), &serialized_manifest);
        assert_eq!(decoder.position, 1 + 8 + serialized_manifest.len());
    }
}