ref(api): Move chunk data types to submodule

 - Create a new `data_types` submodule under the `api` module.
 - Crate a `chunking` submodule under the `data_types` module.
 - Move all data types related to chunking from `src/api/mod.rs` to the `chunking` submodule, splitting their definitions further into submodules under `chunking`.

Ref #2077

src/api/data_types/chunking/artifact.rs

@@ -0,0 +1,24 @@
+use serde::{Deserialize, Serialize};
+use sha1_smol::Digest;
+
+use super::ChunkedFileState;
+
+#[derive(Debug, Serialize)]
+pub struct ChunkedArtifactRequest<'a> {
+ pub checksum: Digest,
+ pub chunks: &'a [Digest],
+ #[serde(skip_serializing_if = "Vec::is_empty")]
+ pub projects: Vec<String>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub version: Option<&'a str>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub dist: Option<&'a str>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AssembleArtifactsResponse {
+ pub state: ChunkedFileState,
+ pub missing_chunks: Vec<Digest>,
+ pub detail: Option<String>,
+}

src/api/data_types/chunking/compression.rs

@@ -0,0 +1,48 @@
+use std::fmt;
+
+use serde::{Deserialize, Deserializer};
+
+#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default)]
+pub enum ChunkCompression {
+ /// No compression should be applied
+ #[default]
+ Uncompressed = 0,
+ /// GZIP compression (including header)
+ Gzip = 10,
+ /// Brotli compression
+ Brotli = 20,
+}
+
+impl ChunkCompression {
+ pub(in crate::api) fn field_name(self) -> &'static str {
+ match self {
+ ChunkCompression::Uncompressed => "file",
+ ChunkCompression::Gzip => "file_gzip",
+ ChunkCompression::Brotli => "file_brotli",
+ }
+ }
+}
+
+impl fmt::Display for ChunkCompression {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self {
+ ChunkCompression::Uncompressed => write!(f, "uncompressed"),
+ ChunkCompression::Gzip => write!(f, "gzip"),
+ ChunkCompression::Brotli => write!(f, "brotli"),
+ }
+ }
+}
+
+impl<'de> Deserialize<'de> for ChunkCompression {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(match String::deserialize(deserializer)?.as_str() {
+ "gzip" => ChunkCompression::Gzip,
+ "brotli" => ChunkCompression::Brotli,
+ // We do not know this compression, so we assume no compression
+ _ => ChunkCompression::Uncompressed,
+ })
+ }
+}

src/api/data_types/chunking/dif.rs

@@ -0,0 +1,30 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+use sha1_smol::Digest;
+use symbolic::common::DebugId;
+
+use crate::api::DebugInfoFile;
+
+use super::ChunkedFileState;
+
+#[derive(Debug, Serialize)]
+pub struct ChunkedDifRequest<'a> {
+ pub name: &'a str,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub debug_id: Option<DebugId>,
+ pub chunks: &'a [Digest],
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChunkedDifResponse {
+ // TODO: Should this be public?
+ pub state: ChunkedFileState,
+ pub missing_chunks: Vec<Digest>,
+ pub detail: Option<String>,
+ pub dif: Option<DebugInfoFile>,
+}
+
+pub type AssembleDifsRequest<'a> = HashMap<Digest, ChunkedDifRequest<'a>>;
+pub type AssembleDifsResponse = HashMap<Digest, ChunkedDifResponse>;

src/api/data_types/chunking/file_state.rs

@@ -0,0 +1,29 @@
+use serde::Deserialize;
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub enum ChunkedFileState {
+ #[serde(rename = "error")]
+ Error,
+ #[serde(rename = "not_found")]
+ NotFound,
+ #[serde(rename = "created")]
+ Created,
+ #[serde(rename = "assembling")]
+ Assembling,
+ #[serde(rename = "ok")]
+ Ok,
+}
+
+impl ChunkedFileState {
+ pub fn is_finished(self) -> bool {
+ self == ChunkedFileState::Error || self == ChunkedFileState::Ok
+ }
+
+ pub fn is_pending(self) -> bool {
+ !self.is_finished()
+ }
+
+ pub fn is_err(self) -> bool {
+ self == ChunkedFileState::Error || self == ChunkedFileState::NotFound
+ }
+}

src/api/data_types/chunking/hash_algorithm.rs

@@ -0,0 +1,7 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
+pub enum ChunkHashAlgorithm {
+ #[serde(rename = "sha1")]
+ Sha1,
+}

src/api/data_types/chunking/mod.rs

@@ -0,0 +1,16 @@
+//! Data types used in the API for sending and receiving data
+//! from the server.
+
+mod artifact;
+mod compression;
+mod dif;
+mod file_state;
+mod hash_algorithm;
+mod upload;
+
+pub use self::artifact::{AssembleArtifactsResponse, ChunkedArtifactRequest};
+pub use self::compression::ChunkCompression;
+pub use self::dif::{AssembleDifsRequest, AssembleDifsResponse, ChunkedDifRequest};
+pub use self::file_state::ChunkedFileState;
+pub use self::hash_algorithm::ChunkHashAlgorithm;
+pub use self::upload::{ChunkUploadCapability, ChunkUploadOptions};

src/api/data_types/chunking/upload/capability.rs

@@ -0,0 +1,55 @@
+use serde::{Deserialize, Deserializer};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ChunkUploadCapability {
+ /// Chunked upload of debug files
+ DebugFiles,
+
+ /// Chunked upload of release files
+ ReleaseFiles,
+
+ /// Chunked upload of standalone artifact bundles
+ ArtifactBundles,
+
+ /// Like `ArtifactBundles`, but with deduplicated chunk
+ /// upload.
+ ArtifactBundlesV2,
+
+ /// Upload of PDBs and debug id overrides
+ Pdbs,
+
+ /// Upload of Portable PDBs
+ PortablePdbs,
+
+ /// Uploads of source archives
+ Sources,
+
+ /// Upload of BCSymbolMap and PList auxiliary DIFs
+ BcSymbolmap,
+
+ /// Upload of il2cpp line mappings
+ Il2Cpp,
+
+ /// Any other unsupported capability (ignored)
+ Unknown,
+}
+
+impl<'de> Deserialize<'de> for ChunkUploadCapability {
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(match String::deserialize(deserializer)?.as_str() {
+ "debug_files" => ChunkUploadCapability::DebugFiles,
+ "release_files" => ChunkUploadCapability::ReleaseFiles,
+ "artifact_bundles" => ChunkUploadCapability::ArtifactBundles,
+ "artifact_bundles_v2" => ChunkUploadCapability::ArtifactBundlesV2,
+ "pdbs" => ChunkUploadCapability::Pdbs,
+ "portablepdbs" => ChunkUploadCapability::PortablePdbs,
+ "sources" => ChunkUploadCapability::Sources,
+ "bcsymbolmaps" => ChunkUploadCapability::BcSymbolmap,
+ "il2cpp" => ChunkUploadCapability::Il2Cpp,
+ _ => ChunkUploadCapability::Unknown,
+ })
+ }
+}

src/api/data_types/chunking/upload/mod.rs

@@ -0,0 +1,7 @@
+use super::*;
+
+mod capability;
+mod options;
+
+pub use self::capability::ChunkUploadCapability;
+pub use self::options::ChunkUploadOptions;

src/api/data_types/chunking/upload/options.rs

@@ -0,0 +1,35 @@
+use serde::Deserialize;
+
+use super::{ChunkCompression, ChunkHashAlgorithm, ChunkUploadCapability};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChunkUploadOptions {
+ pub url: String,
+ #[serde(rename = "chunksPerRequest")]
+ pub max_chunks: u64,
+ #[serde(rename = "maxRequestSize")]
+ pub max_size: u64,
+ #[serde(default)]
+ pub max_file_size: u64,
+ #[serde(default)]
+ pub max_wait: u64,
+ pub hash_algorithm: ChunkHashAlgorithm,
+ pub chunk_size: u64,
+ pub concurrency: u8,
+ #[serde(default)]
+ pub compression: Vec<ChunkCompression>,
+ #[serde(default = "default_chunk_upload_accept")]
+ pub accept: Vec<ChunkUploadCapability>,
+}
+
+impl ChunkUploadOptions {
+ /// Returns whether the given capability is accepted by the chunk upload endpoint.
+ pub fn supports(&self, capability: ChunkUploadCapability) -> bool {
+ self.accept.contains(&capability)
+ }
+}
+
+fn default_chunk_upload_accept() -> Vec<ChunkUploadCapability> {
+ vec![ChunkUploadCapability::DebugFiles]
+}

src/api/data_types/mod.rs

@@ -0,0 +1,3 @@
+mod chunking;
+
+pub use self::chunking::*;