chore: initial sanitized public snapshot

2026-07-18 16:01:12 +08:00
commit 7c6b6a3746
321 changed files with 76896 additions and 0 deletions
@@ -0,0 +1,177 @@
+use super::{
+    checksum::{streamed_checksum_verification, usize_to_u64},
+    model::{
+        HttpCompletionModel, HttpCompletionState, HttpResponseModel, HttpRetryAttemptDetailModel,
+        HttpSegmentProgressModel, HttpTransferProgressModel, HttpTransferTaskModel, ResponseBody,
+    },
+};
+
+impl HttpTransferTaskModel {
+    #[must_use]
+    /// Returns the effective requested offset for the task.
+    pub fn requested_offset(&self) -> u64 {
+        self.resume_state
+            .as_ref()
+            .map(|state| state.requested_offset)
+            .or_else(|| self.request.range.as_ref().map(|range| range.start))
+            .unwrap_or_default()
+    }
+
+    #[must_use]
+    /// Returns retry attempts enriched with resume and range context.
+    pub fn retry_attempt_details(&self) -> Vec<HttpRetryAttemptDetailModel> {
+        let requested_offset = self.requested_offset();
+        let requested_range = self.request.range;
+        let accepted_offset = self
+            .resume_state
+            .as_ref()
+            .and_then(|state| state.accepted_offset);
+        let resume_state = self.resume_state;
+
+        self.retry_attempts
+            .iter()
+            .copied()
+            .map(|base| HttpRetryAttemptDetailModel {
+                base,
+                requested_range,
+                requested_offset,
+                accepted_offset,
+                resume_state,
+            })
+            .collect()
+    }
+
+    #[must_use]
+    /// Builds a progress snapshot from the current task and optional response.
+    pub fn progress_snapshot(
+        &self,
+        response: Option<&HttpResponseModel>,
+    ) -> HttpTransferProgressModel {
+        let completion = response.map(HttpResponseModel::completion_model);
+        let completed_offset = response.map(HttpResponseModel::completed_length);
+        let (accepted_offset, resumed) = response.map_or_else(
+            || {
+                (
+                    self.resume_state
+                        .as_ref()
+                        .and_then(|state| state.accepted_offset),
+                    self.resume_state
+                        .as_ref()
+                        .is_some_and(|state| state.resumed),
+                )
+            },
+            |response| {
+                if response.status == 206 {
+                    let accepted_offset = response
+                        .content_range
+                        .as_ref()
+                        .and_then(|range| (!range.is_unsatisfied()).then_some(range.start));
+                    (
+                        accepted_offset,
+                        accepted_offset.is_some()
+                            || self
+                                .resume_state
+                                .as_ref()
+                                .is_some_and(|state| state.resumed),
+                    )
+                } else {
+                    (None, false)
+                }
+            },
+        );
+
+        HttpTransferProgressModel {
+            task_id: self.task_id.clone(),
+            request: self.request.clone(),
+            segment: HttpSegmentProgressModel {
+                requested_range: self.request.range,
+                requested_offset: self.requested_offset(),
+                accepted_offset,
+                completed_offset,
+                resumed,
+            },
+            retry_attempts: self.retry_attempt_details(),
+            max_connections: self.max_connections,
+            checksum_hook: self.checksum_hook.clone(),
+            completion,
+        }
+    }
+}
+
+impl HttpResponseModel {
+    #[must_use]
+    /// Returns the total payload length when the response exposes it.
+    pub fn total_length(&self) -> Option<u64> {
+        self.content_range
+            .as_ref()
+            .and_then(|range| range.total_size)
+            .or_else(|| match &self.body {
+                ResponseBody::Inline(bytes) => Some(usize_to_u64(bytes.len())),
+                ResponseBody::Streamed {
+                    expected_len,
+                    observed_len,
+                    ..
+                } => expected_len.or(*observed_len),
+                ResponseBody::Empty => None,
+            })
+    }
+
+    #[must_use]
+    /// Returns the completed payload length represented by the response.
+    pub fn completed_length(&self) -> u64 {
+        self.content_range
+            .as_ref()
+            .map(super::model::ContentRangeSpec::completed_length)
+            .or_else(|| match &self.body {
+                ResponseBody::Inline(bytes) => Some(usize_to_u64(bytes.len())),
+                ResponseBody::Streamed { observed_len, .. } => *observed_len,
+                ResponseBody::Empty => Some(0),
+            })
+            .unwrap_or_default()
+    }
+
+    #[must_use]
+    /// Returns inline body bytes when they are retained in memory.
+    pub fn body_bytes(&self) -> Option<&[u8]> {
+        match &self.body {
+            ResponseBody::Empty => Some(&[]),
+            ResponseBody::Inline(bytes) => Some(bytes),
+            ResponseBody::Streamed { .. } => None,
+        }
+    }
+
+    #[must_use]
+    /// Derives a completion summary from the response payload and metadata.
+    pub fn completion_model(&self) -> HttpCompletionModel {
+        let total_length = self.total_length();
+        let completed_length = self.completed_length();
+        let checksum_seen = self.checksum.is_some();
+        let checksum_verified = self.checksum.as_ref().is_some_and(|checksum| {
+            self.body_bytes()
+                .and_then(|bytes| checksum.verify_payload(bytes))
+                .or_else(|| streamed_checksum_verification(checksum, &self.body))
+                .unwrap_or_else(|| checksum.is_verified())
+        });
+        let terminal_success = (200..300).contains(&self.status);
+        let complete_enough = total_length.is_none_or(|total| completed_length >= total);
+        let state = if !terminal_success {
+            HttpCompletionState::Incomplete
+        } else if checksum_verified && complete_enough {
+            HttpCompletionState::Verified
+        } else if complete_enough {
+            HttpCompletionState::Complete
+        } else {
+            HttpCompletionState::Partial
+        };
+
+        HttpCompletionModel {
+            state,
+            total_length,
+            completed_length,
+            partial_content: self.partial_content,
+            terminal_success,
+            checksum_seen,
+            checksum_verified,
+        }
+    }
+}