Method get_chunk_manifest

atomic-remote/src/http/download.rs:171–236

Get the chunk manifest for a change. The chunk manifest lists all content chunks in a change with their blake3 hashes and sizes. This is the starting point for delta transfer negotiation — the receiver compares the manifest against its local chunk inventory to determine which chunks need to be transferred. # Arguments `hash` - The base32-encoded hash of the change. # Returns The [`ChunkManife

(&self, hash: &str)

    /// The [`ChunkManifest`] for the change, or `None` if the server
    /// doesn't support the `?manifest` endpoint (graceful degradation).
    pub async fn get_chunk_manifest(&self, hash: &str) -> RemoteResult<Option<ChunkManifest>> {
        let url = format!("{}?change={}&manifest", self.base_url, hash);
        debug!("GET chunk manifest: {}", url);

        let response = self
            .client
            .get(&url)
            .send()
            .await
            .map_err(|e| RemoteError::connection_failed(&url, e))?;

        crate::check_min_version_header(response.headers());
        let status = response.status();

        match status {
            StatusCode::OK => {
                let content_type = response
                    .headers()
                    .get(CONTENT_TYPE)
                    .and_then(|v| v.to_str().ok())
                    .unwrap_or("");

                // If the server returns JSON, it supports the manifest endpoint
                if content_type.contains("json") {
                    let text = response
                        .text()
                        .await
                        .map_err(|e| RemoteError::connection_failed(&url, e))?;

                    let manifest: ChunkManifest = serde_json::from_str(&text).map_err(|e| {
                        RemoteError::protocol(format!("Failed to parse chunk manifest: {}", e))
                    })?;

                    debug!(
                        "Got chunk manifest for {}: {} chunks, {} compressed",
                        hash,
                        manifest.chunk_count(),
                        manifest.total_compressed(),
                    );
                    Ok(Some(manifest))
                } else {
                    // Server returned the full change data instead of a manifest.
                    // This means it doesn't support ?manifest — graceful degradation.
                    debug!(
                        "Server doesn't support ?manifest (returned {}, not JSON)",
                        content_type
                    );
                    Ok(None)
                }
            }
            StatusCode::NOT_FOUND => Err(RemoteError::change_not_found(hash)),
            StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => {
                let msg = response.text().await.unwrap_or_default();
                Err(RemoteError::auth_failed(&url, msg))
            }
            // 400 or other errors may indicate the server doesn't support ?manifest
            StatusCode::BAD_REQUEST => {
                debug!("Server returned 400 for ?manifest — likely unsupported");