logbrew-cli 0.1.28

Developer-first observability command-line interface
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Upload-only dSYM archive integration fixtures.

use std::ffi::{OsStr, OsString};

use crate::support::upload_args;

pub(crate) fn dsym_upload_args(path: &OsStr, image_uuids: &[&str], dry_run: bool) -> Vec<OsString> {
    let mut args = upload_args(path);
    let _json = args.pop();
    for image_uuid in image_uuids {
        args.push(OsString::from("--expect-image-uuid"));
        args.push(OsString::from(image_uuid));
    }
    if dry_run {
        args.push(OsString::from("--dry-run"));
    }
    args.push(OsString::from("--json"));
    args
}

pub(crate) struct ZipFixtureEntry<'a> {
    name: &'a str,
    bytes: &'a [u8],
    unix_mode: u32,
}

impl<'a> ZipFixtureEntry<'a> {
    pub(crate) fn file(name: &'a str, bytes: &'a [u8]) -> Self {
        Self {
            name,
            bytes,
            unix_mode: 0o100_644,
        }
    }

    pub(crate) fn symlink(name: &'a str, target: &'a [u8]) -> Self {
        Self {
            name,
            bytes: target,
            unix_mode: 0o120_777,
        }
    }
}

pub(crate) fn stored_zip(
    entries: &[ZipFixtureEntry<'_>],
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let mut archive = Vec::new();
    let mut central = Vec::new();
    for entry in entries {
        let offset = u32::try_from(archive.len())?;
        let name = entry.name.as_bytes();
        let name_len = u16::try_from(name.len())?;
        let size = u32::try_from(entry.bytes.len())?;
        let checksum = crc32(entry.bytes);

        archive.extend_from_slice(0x0403_4b50u32.to_le_bytes().as_slice());
        for value in [20u16, 0, 0, 0, 0] {
            archive.extend_from_slice(value.to_le_bytes().as_slice());
        }
        for value in [checksum, size, size] {
            archive.extend_from_slice(value.to_le_bytes().as_slice());
        }
        archive.extend_from_slice(name_len.to_le_bytes().as_slice());
        archive.extend_from_slice(0u16.to_le_bytes().as_slice());
        archive.extend_from_slice(name);
        archive.extend_from_slice(entry.bytes);

        central.extend_from_slice(0x0201_4b50u32.to_le_bytes().as_slice());
        for value in [(3u16 << 8) | 20, 20, 0, 0, 0, 0] {
            central.extend_from_slice(value.to_le_bytes().as_slice());
        }
        for value in [checksum, size, size] {
            central.extend_from_slice(value.to_le_bytes().as_slice());
        }
        for value in [name_len, 0, 0, 0, 0] {
            central.extend_from_slice(value.to_le_bytes().as_slice());
        }
        central.extend_from_slice((entry.unix_mode << 16).to_le_bytes().as_slice());
        central.extend_from_slice(offset.to_le_bytes().as_slice());
        central.extend_from_slice(name);
    }
    let central_offset = u32::try_from(archive.len())?;
    let central_size = u32::try_from(central.len())?;
    archive.extend_from_slice(central.as_slice());
    archive.extend_from_slice(0x0605_4b50u32.to_le_bytes().as_slice());
    for value in [
        0u16,
        0,
        u16::try_from(entries.len())?,
        u16::try_from(entries.len())?,
    ] {
        archive.extend_from_slice(value.to_le_bytes().as_slice());
    }
    archive.extend_from_slice(central_size.to_le_bytes().as_slice());
    archive.extend_from_slice(central_offset.to_le_bytes().as_slice());
    archive.extend_from_slice(0u16.to_le_bytes().as_slice());
    Ok(archive)
}

fn crc32(bytes: &[u8]) -> u32 {
    let mut crc = u32::MAX;
    for byte in bytes {
        crc ^= u32::from(*byte);
        for _ in 0..8 {
            let mask = 0u32.wrapping_sub(crc & 1);
            crc = (crc >> 1) ^ (0xedb8_8320 & mask);
        }
    }
    !crc
}