hodl

NicoHinderling · NicoHinderling · commit c1625f1295e4 · 2025-05-29T16:17:48.000-07:00
diff --git a/.env.local b/.env.local
@@ -0,0 +1,3 @@
+SENTRY_ORG=emerge-tools
+SENTRY_PROJECT=hackernews-ios
+SENTRY_AUTH_TOKEN=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
diff --git a/.sentryclirc b/.sentryclirc
@@ -1 +1,2 @@
-; this stub prevents global .sentryclirc from being loaded
+[auth]
+token=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
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,6 +6,18 @@ version = "2.46.0"
 edition = "2021"
 rust-version = "1.86"
 
+[lib]
+name = "sentry_cli"
+path = "src/lib.rs"
+
+[[bin]]
+name = "test_full_upload"
+path = "test_full_upload.rs"
+
+[[bin]]
+name = "test_mobile_app_upload"
+path = "test_mobile_app_upload.rs"
+
 [dependencies]
 anylog = "0.6.3"
 anyhow = { version = "1.0.69", features = ["backtrace"] }
diff --git a/README_TEST.md b/README_TEST.md
@@ -0,0 +1,60 @@
+# Sentry CLI Upload Test
+
+This is a test program that reuses the existing sentry-cli codebase to test the upload process against a local Sentry service.
+
+## Building and Running
+
+1. **Build the test binary:**
+   ```bash
+   cargo build --bin test_sentry_upload
+   ```
+
+2. **Run the test:**
+   ```bash
+   cargo run --bin test_sentry_upload
+   ```
+   
+   Or run the compiled binary directly:
+   ```bash
+   ./target/debug/test_sentry_upload
+   ```
+
+## What it tests
+
+The test program performs the following tests against your local Sentry service:
+
+1. **Authentication Test** - Verifies the auth token works
+2. **Chunk Upload Options Test** - Checks `/organizations/{org}/chunk-upload/` endpoint
+3. **Artifact Bundle Assembly Test** - Tests `/organizations/{org}/artifactbundle/assemble/` endpoint  
+4. **Sourcemap Upload Test** - Performs actual file upload using the existing upload logic
+
+## Configuration
+
+The test is configured for:
+- **Base URL:** `http://localhost:8000`
+- **Organization:** `sentry`
+- **Project:** `internal`
+- **Auth Token:** Your provided token
+- **Test File:** `/Users/nicolashinderling/emerge-dev/emerge/web/.next/server/edge-instrumentation.js.map`
+
+You can modify these values in the `main()` function of `test_sentry_upload.rs`.
+
+## Output
+
+The test will show:
+- ✅/❌ Status indicators for each test
+- Server capabilities (which ChunkUploadCapability features are supported)
+- Upload method used (artifact bundle vs chunked vs legacy)
+- Detailed error messages if anything fails
+
+## API Endpoints Tested
+
+1. **GET** `/api/0/organizations/{org}/chunk-upload/`
+   - Discovers server capabilities
+   - Returns chunk upload configuration
+
+2. **POST** `/api/0/organizations/{org}/artifactbundle/assemble/`
+   - Assembles uploaded chunks into artifact bundles
+   - Tests the artifact bundle flow
+
+The test reuses the exact same code paths as the real `sentry-cli sourcemaps upload` command, so it's a comprehensive test of the upload functionality. 
diff --git a/src/api/data_types/chunking/artifact.rs b/src/api/data_types/chunking/artifact.rs
@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use sha1_smol::Digest;
+use std::collections::HashMap;
 
 use super::ChunkedFileState;
 
@@ -13,16 +14,85 @@ pub struct ChunkedArtifactRequest<'a> {
     pub version: Option<&'a str>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub dist: Option<&'a str>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub filename: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub project_id: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct AssembleArtifactsResponse {
+pub struct ChunkedArtifactResponse {
     pub state: ChunkedFileState,
     pub missing_chunks: Vec<Digest>,
     pub detail: Option<String>,
 }
 
+#[derive(Debug, Serialize)]
+#[serde(transparent)]
+pub struct AssembleArtifactsRequest<'a>(HashMap<Digest, ChunkedArtifactRequest<'a>>);
+
+impl<'a, T> FromIterator<T> for AssembleArtifactsRequest<'a>
+where
+    T: Into<ChunkedArtifactRequest<'a>>,
+{
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        Self(
+            iter.into_iter()
+                .map(|obj| obj.into())
+                .map(|r| (r.checksum, r))
+                .collect(),
+        )
+    }
+}
+
+pub type AssembleArtifactsResponse = ChunkedArtifactResponse;
+
+#[derive(Debug, Serialize)]
+pub struct ChunkedPreprodArtifactRequest<'a> {
+    pub checksum: Digest,
+    pub chunks: &'a [Digest],
+    // Optional metadata fields that the server supports
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub build_version: Option<&'a str>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub build_number: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub build_configuration: Option<&'a str>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub date_built: Option<&'a str>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extras: Option<serde_json::Value>,
+}
+
+impl<'a> ChunkedPreprodArtifactRequest<'a> {
+    /// Create a new ChunkedPreprodArtifactRequest with the required fields.
+    pub fn new(checksum: Digest, chunks: &'a [Digest]) -> Self {
+        Self {
+            checksum,
+            chunks,
+            build_version: None,
+            build_number: None,
+            build_configuration: None,
+            date_built: None,
+            extras: None,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChunkedPreprodArtifactResponse {
+    pub state: ChunkedFileState,
+    pub missing_chunks: Vec<Digest>,
+    pub detail: Option<String>,
+}
+
+pub type AssemblePreprodArtifactsResponse = HashMap<Digest, ChunkedPreprodArtifactResponse>;
+
 fn version_is_empty(version: &Option<&str>) -> bool {
     match version {
         Some(v) => v.is_empty(),
diff --git a/src/api/data_types/chunking/mod.rs b/src/api/data_types/chunking/mod.rs
@@ -8,7 +8,10 @@ mod file_state;
 mod hash_algorithm;
 mod upload;
 
-pub use self::artifact::{AssembleArtifactsResponse, ChunkedArtifactRequest};
+pub use self::artifact::{
+    AssembleArtifactsRequest, AssembleArtifactsResponse, ChunkedArtifactRequest, ChunkedArtifactResponse,
+    ChunkedPreprodArtifactRequest, ChunkedPreprodArtifactResponse,
+};
 pub use self::compression::ChunkCompression;
 pub use self::dif::{AssembleDifsRequest, AssembleDifsResponse, ChunkedDifRequest};
 pub use self::file_state::ChunkedFileState;
diff --git a/src/api/data_types/chunking/upload/capability.rs b/src/api/data_types/chunking/upload/capability.rs
@@ -11,6 +11,9 @@ pub enum ChunkUploadCapability {
     /// Chunked upload of standalone artifact bundles
     ArtifactBundles,
 
+    /// Chunked upload of preprocessed artifact bundles (@nico: unclear if this new enum is actually needed)
+    PreprocessedArtifactBundles,
+
     /// Like `ArtifactBundles`, but with deduplicated chunk
     /// upload.
     ArtifactBundlesV2,
@@ -30,6 +33,9 @@ pub enum ChunkUploadCapability {
     /// Upload of il2cpp line mappings
     Il2Cpp,
 
+    /// Upload of preprod artifacts (mobile app archives, etc.)
+    PreprodArtifacts,
+
     /// Any other unsupported capability (ignored)
     Unknown,
 }
@@ -43,12 +49,14 @@ impl<'de> Deserialize<'de> for ChunkUploadCapability {
             "debug_files" => ChunkUploadCapability::DebugFiles,
             "release_files" => ChunkUploadCapability::ReleaseFiles,
             "artifact_bundles" => ChunkUploadCapability::ArtifactBundles,
+            "preprocessed_artifact_bundles" => ChunkUploadCapability::PreprocessedArtifactBundles,
             "artifact_bundles_v2" => ChunkUploadCapability::ArtifactBundlesV2,
             "pdbs" => ChunkUploadCapability::Pdbs,
             "portablepdbs" => ChunkUploadCapability::PortablePdbs,
             "sources" => ChunkUploadCapability::Sources,
             "bcsymbolmaps" => ChunkUploadCapability::BcSymbolmap,
             "il2cpp" => ChunkUploadCapability::Il2Cpp,
+            "preprod_artifacts" => ChunkUploadCapability::PreprodArtifacts,
             _ => ChunkUploadCapability::Unknown,
         })
     }
diff --git a/src/api/data_types/chunking/upload/options.rs b/src/api/data_types/chunking/upload/options.rs
@@ -15,7 +15,6 @@ pub struct ChunkServerOptions {
     pub max_file_size: u64,
     #[serde(default)]
     pub max_wait: u64,
-    #[expect(dead_code)]
     pub hash_algorithm: ChunkHashAlgorithm,
     pub chunk_size: u64,
     pub concurrency: u8,
diff --git a/src/api/mod.rs b/src/api/mod.rs
@@ -988,6 +988,8 @@ impl<'a> AuthenticatedApi<'a> {
                 projects: &[],
                 version: None,
                 dist: None,
+                filename: None,
+                project_id: None,
             })?
             .send()?
             .convert_rnf(ApiErrorKind::ReleaseNotFound)
@@ -1011,11 +1013,32 @@ impl<'a> AuthenticatedApi<'a> {
                 projects,
                 version,
                 dist,
+                filename: None,
+                project_id: None,
             })?
             .send()?
             .convert_rnf(ApiErrorKind::ReleaseNotFound)
     }
 
+    /// Request preprod artifact assembling and processing from chunks.
+    pub fn assemble_preprod_artifact(
+        &self,
+        org: &str,
+        project: &str,
+        request: &ChunkedPreprodArtifactRequest<'_>,
+    ) -> ApiResult<ChunkedPreprodArtifactResponse> {
+        let url = format!(
+            "/projects/{}/{}/files/preprodartifacts/assemble/",
+            PathArg(org),
+            PathArg(project)
+        );
+
+        self.request(Method::Post, &url)?
+            .with_json_body(request)?
+            .send()?
+            .convert_rnf(ApiErrorKind::ProjectNotFound)
+    }
+
     pub fn associate_proguard_mappings(
         &self,
         org: &str,
@@ -1929,7 +1952,6 @@ pub struct AuthDetails {
 #[derive(Deserialize, Debug)]
 pub struct User {
     pub email: String,
-    #[expect(dead_code)]
     pub id: String,
 }
 
@@ -2011,7 +2033,6 @@ pub struct UpdatedRelease {
 #[derive(Debug, Deserialize)]
 pub struct ReleaseInfo {
     pub version: String,
-    #[expect(dead_code)]
     pub url: Option<String>,
     #[serde(rename = "dateCreated")]
     pub date_created: DateTime<Utc>,
@@ -2077,7 +2098,6 @@ pub struct DebugInfoData {
     #[serde(default, rename = "type")]
     pub kind: Option<ObjectKind>,
     #[serde(default)]
-    #[expect(dead_code)]
     pub features: Vec<String>,
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -0,0 +1,11 @@
+#![warn(clippy::allow_attributes)]
+#![warn(clippy::unnecessary_wraps)]
+
+pub mod api;
+pub mod config;
+pub mod constants;
+pub mod utils;
+
+// Re-export commonly used types
+pub use api::{Api, ChunkUploadCapability};
+pub use config::{Auth, Config}; 
diff --git a/src/utils/dif_upload/mod.rs b/src/utils/dif_upload/mod.rs
@@ -1355,7 +1355,7 @@ fn upload_difs_batched(options: &DifUpload) -> Result<Vec<DebugInfoFile>> {
             "{} Nothing to upload, all files are on the server",
             style(">").dim()
         );
-        println!("{} Nothing to upload", style(">").dim());
+        println!("{} Nothing to upload , buddy", style(">").dim());
         return Ok(Default::default());
     }
 
diff --git a/src/utils/file_upload.rs b/src/utils/file_upload.rs
@@ -369,6 +369,7 @@ impl<'a> FileUpload<'a> {
         // multiple projects OK
         initialize_legacy_release_upload(self.context)?;
 
+        //  @nico: where is the chunk_upload_options value being defined?
         if let Some(chunk_options) = self.context.chunk_upload_options {
             if chunk_options.supports(ChunkUploadCapability::ReleaseFiles) {
                 // multiple projects OK
@@ -593,6 +594,7 @@ fn poll_assemble(
     Ok(())
 }
 
+// So they will probably do something similar but for the preprod artifacts
 fn upload_files_chunked(
     context: &UploadContext,
     files: &SourceFiles,
diff --git a/src/utils/sourcemaps.rs b/src/utils/sourcemaps.rs
@@ -601,7 +601,7 @@ impl SourceMapProcessor {
         self.flush_pending_sources();
         self.collect_sourcemap_references();
 
-        println!("{} Adding source map references", style(">").dim());
+        println!("{} Adding source map references.... boy", style(">").dim());
         for source in self.sources.values_mut() {
             if source.ty != SourceFileType::MinifiedSource {
                 continue;
@@ -764,7 +764,7 @@ impl SourceMapProcessor {
             uploader.upload()?;
             self.dump_log("Source Map Upload Report");
         } else {
-            println!("{} Nothing to upload", style(">").dim());
+            println!("{} Nothing to upload, buddy boy", style(">").dim());
         }
         Ok(files_needing_upload)
     }
diff --git a/test_full_upload.rs b/test_full_upload.rs
diff --git a/test_mobile_app_upload.rs b/test_mobile_app_upload.rs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+SENTRY_ORG=emerge-tools`
	`2`	`+SENTRY_PROJECT=hackernews-ios`
	`3`	`+SENTRY_AUTH_TOKEN=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`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`		`-; this stub prevents global .sentryclirc from being loaded`
	`1`	`+[auth]`
	`2`	`+token=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`