#6171

Committed 26 Jun 2025 09:47AM UTC coverage: 47.697% (-0.02%) from 47.718%

Build # #6171

Build Type

Committed by

Commit Message

go: bump github.com/pion/interceptor from 0.1.37 to 0.1.39 in /go

Bumps [github.com/pion/interceptor](https://github.com/pion/interceptor) from 0.1.37 to 0.1.39.
- [Release notes](https://github.com/pion/interceptor/releases)
- [Changelog](https://github.com/pion/interceptor/blob/master/.goreleaser.yml)
- [Commits](https://github.com/pion/interceptor/compare/v0.1.37...v0.1.39)

---
updated-dependencies:
- dependency-name: github.com/pion/interceptor
  dependency-version: 0.1.39
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #6222: go: bump github.com/pion/interceptor from 0.1.37 to 0.1.39 in /go

Run Details

4577 of 9596 relevant lines covered (47.7%)

1.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.57

/runtime/src/common/key_format.rs

use std::{convert::TryInto, mem::size_of};

use impl_trait_for_tuples::impl_for_tuples;

/// Size of the KeyFormat prefix.
const KEY_FORMAT_PREFIX_SIZE: usize = size_of::<u8>();

/// A key formatting helper trait to be used together with key-value
/// backends for constructing keys.
pub trait KeyFormat {
    /// The prefix that identifies the key format.
    fn prefix() -> u8;

    /// The minimum size of the encoded key.
    fn size() -> usize;

    /// Encode the given key format into a set of atoms.
    fn encode_atoms(self, atoms: &mut Vec<Vec<u8>>);

    /// Decode the given key format from data (without prefix).
    ///
    /// The caller must ensure that the size of the passed data is at
    /// least the minimum size returned by `size`.
    fn decode_atoms(data: &[u8]) -> Self
    where
        Self: Sized;

    /// Encode the first few atoms in the key format.
    ///
    /// This method can be used to construct key prefixes for iteration.
    /// Specifying a zero count will only generate the prefix.
    fn encode_partial(self, count: usize) -> Vec<u8>
    where
        Self: Sized,
    {
        let mut v = Vec::with_capacity(KEY_FORMAT_PREFIX_SIZE + Self::size());
        v.push(Self::prefix());

        if count == 0 {
            return v;
        }

        let mut atoms = Vec::new();
        self.encode_atoms(&mut atoms);
        for (included, mut atom) in atoms.into_iter().enumerate() {
            if included >= count {
                break;
            }
            v.append(&mut atom);
        }

        v
    }

    /// Encode the given key format.
    fn encode(self) -> Vec<u8>
    where
        Self: Sized,
    {
        self.encode_partial(usize::MAX)
    }

    /// Decode the given key format from data.
    ///
    /// The method may return `None` in case the key is of a different
    /// type as indicated by the prefix byte.
    fn decode(data: &[u8]) -> Option<Self>
    where
        Self: Sized,
    {
        assert!(!data.is_empty(), "key format: malformed input (empty data)");
        if data[0] != Self::prefix() {
            return None;
        }
        assert!(
            data.len() >= Self::size() + KEY_FORMAT_PREFIX_SIZE,
            "key format: malformed input"
        );

        Some(Self::decode_atoms(&data[1..]))
    }
}

/// Part of the KeyFormat to be used with key-value backends for constructing keys.
pub trait KeyFormatAtom {
    fn size() -> usize;

    fn encode_atom(self) -> Vec<u8>;

    fn decode_atom(data: &[u8]) -> Self
    where
        Self: Sized;
}

impl KeyFormatAtom for u64 {
    fn size() -> usize {
        8
    }

    fn encode_atom(self) -> Vec<u8> {
        self.to_be_bytes().to_vec()
    }

    fn decode_atom(data: &[u8]) -> Self
    where
        Self: Sized,
    {
        u64::from_be_bytes(data.try_into().expect("key_format: malformed u64 input"))
    }
}

impl KeyFormatAtom for u8 {
    fn size() -> usize {
        1
    }

    fn encode_atom(self) -> Vec<u8> {
        vec![self]
    }

    fn decode_atom(data: &[u8]) -> Self
    where
        Self: Sized,
    {
        assert!(!data.is_empty(), "key_format: malformed: u8 input");
        data[0]
    }
}

impl KeyFormatAtom for () {
    fn size() -> usize {
        0
    }

    fn encode_atom(self) -> Vec<u8> {
        Vec::new()
    }

    fn decode_atom(_: &[u8]) {}
}

#[impl_for_tuples(2, 10)]
impl KeyFormatAtom for Tuple {
    fn size() -> usize {
        for_tuples!( #( Tuple::size() )+* );
    }

    fn encode_atom(self) -> Vec<u8> {
        let mut atoms: Vec<Vec<u8>> = [for_tuples!( #( self.Tuple.encode_atom() ),* )].to_vec();

        atoms.into_iter().flatten().collect()
    }

    fn decode_atom(data: &[u8]) -> for_tuples!( ( #( Tuple ),* ) ) {
        assert!(
            data.len() >= Self::size(),
            "key format atom: malformed input"
        );

        let mut sizes: Vec<usize> = [for_tuples!( #( Tuple::size() ),* )].to_vec();
        sizes.reverse();
        let mut data = data.to_vec();

        /*
            (
                {
                    let x = T1::decode_atom(data.drain(0..T1::size()));
                    x
                },
                {
                    let x = T2::decode_atom(data.drain(0..T2::size()));
                    x
                }
                ...
            )
        */
        for_tuples!(
            (
                #(
                    {
                        let x = Tuple::decode_atom(data.drain(0..sizes.pop().unwrap()).as_slice());
                        x
                    }
                ),*
            )
        )
    }
}

/// Define a KeyFormat from KeyFormatAtom and a prefix.
///
/// # Examples
///
/// ```rust,ignore
/// key_format!(NewKeyFormatName, 0x01, InnerType);
/// ```
#[macro_export]
macro_rules! key_format {
    ($name:ident, $prefix:expr, $inner:ty) => {
        #[derive(Debug, Default, PartialEq, Eq, Clone)]
        struct $name($inner);

        impl KeyFormat for $name {
            fn prefix() -> u8 {
                $prefix
            }

            fn size() -> usize {
                <$inner>::size()
            }

            fn encode_atoms(self, atoms: &mut Vec<Vec<u8>>) {
                atoms.push(self.0.encode_atom());
            }

            fn decode_atoms(data: &[u8]) -> Self {
                Self(<$inner>::decode_atom(data))
            }
        }
    };
}

#[cfg(test)]
mod test {
    use rustc_hex::ToHex;

    use crate::common::crypto::hash::Hash;

    use super::*;

    #[derive(Debug, PartialEq)]
    struct Test1KeyFormat {
        h: Hash,
    }

    impl KeyFormat for Test1KeyFormat {
        fn prefix() -> u8 {
            b'T'
        }

        fn size() -> usize {
            32
        }

        fn encode_atoms(self, atoms: &mut Vec<Vec<u8>>) {
            atoms.push(self.h.as_ref().to_vec());
        }

        fn decode_atoms(data: &[u8]) -> Self {
            Self { h: data.into() }
        }
    }

    #[test]
    fn test_key_format() {
        let mut enc = Test1KeyFormat {
            h: Hash::empty_hash(),
        }
        .encode();
        assert_eq!(
            enc.to_hex::<String>(),
            "54c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a"
        );

        let dec = Test1KeyFormat::decode(&enc);
        assert_eq!(
            dec,
            Some(Test1KeyFormat {
                h: Hash::empty_hash()
            })
        );

        // Clear type.
        enc[0] = 0x00;
        let dec = Test1KeyFormat::decode(&enc);
        assert_eq!(dec, None);

        // Partial encoding.
        let enc = Test1KeyFormat {
            h: Hash::empty_hash(),
        }
        .encode_partial(0);
        assert_eq!(enc.to_hex::<String>(), "54");
    }

    #[test]
    fn test_key_format_atom() {
        key_format!(TestKeyFormat, 0x01, (u8, u64, u8, u64, u64));

        let key = TestKeyFormat((1, 2, 3, 4, 5));
        let enc = key.clone().encode();
        let dec = TestKeyFormat::decode(&enc);

        assert_eq!(dec, Some(key),)
    }
}

1	use std::{convert::TryInto, mem::size_of};
2
3	use impl_trait_for_tuples::impl_for_tuples;
4
5	/// Size of the KeyFormat prefix.
6	const KEY_FORMAT_PREFIX_SIZE: usize = size_of::<u8>();
7
8	/// A key formatting helper trait to be used together with key-value
9	/// backends for constructing keys.
10	pub trait KeyFormat {
11	/// The prefix that identifies the key format.
12	fn prefix() -> u8;
13
14	/// The minimum size of the encoded key.
15	fn size() -> usize;
16
17	/// Encode the given key format into a set of atoms.
18	fn encode_atoms(self, atoms: &mut Vec<Vec<u8>>);
19
20	/// Decode the given key format from data (without prefix).
21	///
22	/// The caller must ensure that the size of the passed data is at
23	/// least the minimum size returned by `size`.
24	fn decode_atoms(data: &[u8]) -> Self
25	where
26	Self: Sized;
27
28	/// Encode the first few atoms in the key format.
29	///
30	/// This method can be used to construct key prefixes for iteration.
31	/// Specifying a zero count will only generate the prefix.
32	fn encode_partial(self, count: usize) -> Vec<u8>	21✔
33	where
34	Self: Sized,
35	{
36	let mut v = Vec::with_capacity(KEY_FORMAT_PREFIX_SIZE + Self::size());	42✔
37	v.push(Self::prefix());	42✔
38
39	if count == 0 {	21✔
40	return v;	6✔
41	}
42
43	let mut atoms = Vec::new();	21✔
44	self.encode_atoms(&mut atoms);	21✔
45	for (included, mut atom) in atoms.into_iter().enumerate() {	63✔
46	if included >= count {	21✔
47	break;	×
48	}
49	v.append(&mut atom);	21✔
50	}
51
52	v	21✔
53	}
54
55	/// Encode the given key format.
56	fn encode(self) -> Vec<u8>	21✔
57	where
58	Self: Sized,
59	{
60	self.encode_partial(usize::MAX)	21✔
61	}
62
63	/// Decode the given key format from data.
64	///
65	/// The method may return `None` in case the key is of a different
66	/// type as indicated by the prefix byte.
67	fn decode(data: &[u8]) -> Option<Self>	8✔
68	where
69	Self: Sized,
70	{
71	assert!(!data.is_empty(), "key format: malformed input (empty data)");	8✔
72	if data[0] != Self::prefix() {	16✔
73	return None;	7✔
74	}
75	assert!(	×
76	data.len() >= Self::size() + KEY_FORMAT_PREFIX_SIZE,	×
77	"key format: malformed input"	×
78	);
79
80	Some(Self::decode_atoms(&data[1..]))	8✔
81	}
82	}
83
84	/// Part of the KeyFormat to be used with key-value backends for constructing keys.
85	pub trait KeyFormatAtom {
86	fn size() -> usize;
87
88	fn encode_atom(self) -> Vec<u8>;
89
90	fn decode_atom(data: &[u8]) -> Self
91	where
92	Self: Sized;
93	}
94
95	impl KeyFormatAtom for u64 {
96	fn size() -> usize {
97	8
98	}
99
100	fn encode_atom(self) -> Vec<u8> {	1✔
101	self.to_be_bytes().to_vec()	1✔
102	}
103
104	fn decode_atom(data: &[u8]) -> Self	1✔
105	where
106	Self: Sized,
107	{
108	u64::from_be_bytes(data.try_into().expect("key_format: malformed u64 input"))	1✔
109	}
110	}
111
112	impl KeyFormatAtom for u8 {
113	fn size() -> usize {
114	1
115	}
116
117	fn encode_atom(self) -> Vec<u8> {	1✔
118	vec![self]	1✔
119	}
120
121	fn decode_atom(data: &[u8]) -> Self	1✔
122	where
123	Self: Sized,
124	{
125	assert!(!data.is_empty(), "key_format: malformed: u8 input");	1✔
126	data[0]	2✔
127	}
128	}
129
130	impl KeyFormatAtom for () {
131	fn size() -> usize {
132	0
133	}
134
135	fn encode_atom(self) -> Vec<u8> {	1✔
136	Vec::new()	1✔
137	}
138
139	fn decode_atom(_: &[u8]) {}	×
140	}
141
142	#[impl_for_tuples(2, 10)]
143	impl KeyFormatAtom for Tuple {
144	fn size() -> usize {	5✔
145	for_tuples!( #( Tuple::size() )+* );
146	}
147
148	fn encode_atom(self) -> Vec<u8> {	5✔
149	let mut atoms: Vec<Vec<u8>> = [for_tuples!( #( self.Tuple.encode_atom() ),* )].to_vec();	18✔
150
151	atoms.into_iter().flatten().collect()	5✔
152	}
153
154	fn decode_atom(data: &[u8]) -> for_tuples!( ( #( Tuple ),* ) ) {	4✔
155	assert!(	1✔
156	data.len() >= Self::size(),
157	"key format atom: malformed input"
158	);
159
160	let mut sizes: Vec<usize> = [for_tuples!( #( Tuple::size() ),* )].to_vec();	4✔
161	sizes.reverse();	8✔
162	let mut data = data.to_vec();	4✔
163
164	/*
165	(
166	{
167	let x = T1::decode_atom(data.drain(0..T1::size()));
168	x
169	},
170	{
171	let x = T2::decode_atom(data.drain(0..T2::size()));
172	x
173	}
174	...
175	)
176	*/
177	for_tuples!(
178	(
179	#(
180	{
181	let x = Tuple::decode_atom(data.drain(0..sizes.pop().unwrap()).as_slice());	36✔
182	x	5✔
183	}
184	),*
185	)
186	)
187	}
188	}
189
190	/// Define a KeyFormat from KeyFormatAtom and a prefix.
191	///
192	/// # Examples
193	///
194	/// ```rust,ignore
195	/// key_format!(NewKeyFormatName, 0x01, InnerType);
196	/// ```
197	#[macro_export]
198	macro_rules! key_format {
199	($name:ident, $prefix:expr, $inner:ty) => {
200	#[derive(Debug, Default, PartialEq, Eq, Clone)]	14✔
201	struct $name($inner);	7✔
202
203	impl KeyFormat for $name {
204	fn prefix() -> u8 {
205	$prefix
206	}
207
208	fn size() -> usize {	18✔
209	<$inner>::size()	18✔
210	}
211
212	fn encode_atoms(self, atoms: &mut Vec<Vec<u8>>) {	18✔
213	atoms.push(self.0.encode_atom());	18✔
214	}
215
216	fn decode_atoms(data: &[u8]) -> Self {	7✔
217	Self(<$inner>::decode_atom(data))	7✔
218	}
219	}
220	};
221	}
222
223	#[cfg(test)]
224	mod test {
225	use rustc_hex::ToHex;
226
227	use crate::common::crypto::hash::Hash;
228
229	use super::*;
230
231	#[derive(Debug, PartialEq)]
232	struct Test1KeyFormat {
233	h: Hash,
234	}
235
236	impl KeyFormat for Test1KeyFormat {
237	fn prefix() -> u8 {
238	b'T'
239	}
240
241	fn size() -> usize {
242	32
243	}
244
245	fn encode_atoms(self, atoms: &mut Vec<Vec<u8>>) {
246	atoms.push(self.h.as_ref().to_vec());
247	}
248
249	fn decode_atoms(data: &[u8]) -> Self {
250	Self { h: data.into() }
251	}
252	}
253
254	#[test]
255	fn test_key_format() {
256	let mut enc = Test1KeyFormat {
257	h: Hash::empty_hash(),
258	}
259	.encode();
260	assert_eq!(
261	enc.to_hex::<String>(),
262	"54c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a"
263	);
264
265	let dec = Test1KeyFormat::decode(&enc);
266	assert_eq!(
267	dec,
268	Some(Test1KeyFormat {
269	h: Hash::empty_hash()
270	})
271	);
272
273	// Clear type.
274	enc[0] = 0x00;
275	let dec = Test1KeyFormat::decode(&enc);
276	assert_eq!(dec, None);
277
278	// Partial encoding.
279	let enc = Test1KeyFormat {
280	h: Hash::empty_hash(),
281	}
282	.encode_partial(0);
283	assert_eq!(enc.to_hex::<String>(), "54");
284	}
285
286	#[test]
287	fn test_key_format_atom() {
288	key_format!(TestKeyFormat, 0x01, (u8, u64, u8, u64, u64));
289
290	let key = TestKeyFormat((1, 2, 3, 4, 5));
291	let enc = key.clone().encode();
292	let dec = TestKeyFormat::decode(&enc);
293
294	assert_eq!(dec, Some(key),)
295	}
296	}

oasisprotocol / oasis-core / #6171

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous