Add diagnostics around repo payload queries — radicle-explorer

radicle-explorer

rad:z4V1sjrXqjvFdnCUbxPFqd5p4DtH5

Radicle web interface

Add diagnostics around repo payload queries

Archived rudolfs opened 1 month ago

Activity Changes +129 -11

2 files changed +129 -11 4eae95ab → f85389ec

modified radicle-httpd/src/api.rs

@@ -99,16 +99,118 @@ impl Context {

         let db = &self.profile.database()?;
         let seeding = db.count(&rid).unwrap_or_default();
         let payload_count = doc.payload().len();
         if payload_count == 0 {
             tracing::warn!("Repository {} has NO payloads in identity document", rid);
         } else {
             tracing::debug!(
                 "Repository {} has {} payload(s): {:?}",
                 rid,
                 payload_count,
                 doc.payload().keys().collect::<Vec<_>>()
             );
         }
         let payloads: BTreeMap<PayloadId, Value> = doc
             .payload()
             .iter()
             .filter_map(|(id, payload)| {
                 if id == &PayloadId::project() {
                     let (_, head) = repo.head().ok()?;
                     let patches = self.profile.patches(repo).ok()?;
                     let patches = patches.counts().ok()?;
                     let issues = self.profile.issues(repo).ok()?;
                     let issues = issues.counts().ok()?;
                     match self.profile.cobs_db() {
                         Ok(db) => {
                             match (db.version(), db.check_version()) {
                                 (Ok(version), Ok(_)) => {
                                     tracing::debug!(
                                         "COB cache version {} is up-to-date for repo {}",
                                         version,
                                         rid
                                     );
                                 }
                                 (Ok(version), Err(e)) => {
                                     tracing::warn!(
                                         "COB cache version {} is outdated for repo {}: {}. Run 'rad cob migrate' to update",
                                         version,
                                         rid,
                                         e
                                     );
                                 }
                                 (Err(e), _) => {
                                     tracing::warn!(
                                         "Failed to read COB cache version for repo {}: {}",
                                         rid,
                                         e
                                     );
                                 }
                             }
                         }
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to open COB database for repo {}: {}. Cache may be corrupted or missing.",
                                 rid,
                                 e
                             );
                         }
                     }
                     let head = match repo.head() {
                         Ok((_, h)) => h,
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to get head for repo {}: {}",
                                 rid,
                                 e
                             );
                             return None;
                         }
                     };
                     let patches = match self.profile.patches(repo) {
                         Ok(p) => p,
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to get patches store for repo {}: {}",
                                 rid,
                                 e
                             );
                             return None;
                         }
                     };
                     let patch_counts = match patches.counts() {
                         Ok(c) => c,
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to get patch counts for repo {}: {}",
                                 rid,
                                 e
                             );
                             return None;
                         }
                     };
                     let issues = match self.profile.issues(repo) {
                         Ok(i) => i,
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to get issues store for repo {}: {}",
                                 rid,
                                 e
                             );
                             return None;
                         }
                     };
                     let issue_counts = match issues.counts() {
                         Ok(c) => c,
                         Err(e) => {
                             tracing::warn!(
                                 "Failed to get issue counts for repo {}: {}",
                                 rid,
                                 e
                             );
                             return None;
                         }
                     };
                     Some((
                         id.clone(),

@@ -116,8 +218,8 @@ impl Context {

                             "data": payload,
                             "meta": {
                                 "head": head,
                                 "issues": issues,
                                 "patches": patches
                                 "issues": issue_counts,
                                 "patches": patch_counts
                             }
                         }),
                     ))

modified radicle-httpd/src/api/v1/repos.rs

@@ -96,11 +96,27 @@ async fn repo_root_handler(

             if !policies.is_seeding(&info.rid).unwrap_or_default() {
                 return None;
             }
             let Ok((repo, doc)) = ctx.repo(info.rid) else {
                 return None;
             let (repo, doc) = match ctx.repo(info.rid) {
                 Ok(r) => r,
                 Err(e) => {
                     tracing::warn!(
                         "Failed to load repo {} in ctx.repo(): {}",
                         info.rid,
                         e
                     );
                     return None;
                 }
             };
             let Ok(repo_info) = ctx.repo_info(&repo, doc) else {
                 return None;
             let repo_info = match ctx.repo_info(&repo, doc) {
                 Ok(r) => r,
                 Err(e) => {
                     tracing::warn!(
                         "Failed to build repo_info for {}: {}",
                         info.rid,
                         e
                     );
                     return None;
                 }
             };
             Some(repo_info)