Make soft_error! return Ok in OSS builds and remove .unwrap() at call sites

Author: dkranchii

app/buck2_env/src/soft_error.rs

@@ -291,14 +291,6 @@ pub fn handle_soft_error(
         return Err(err.context("Upgraded warning to failure via $BUCK2_HARD_ERROR"));
     }
 
-    // @oss-disable: let is_open_source = false;
-    let is_open_source = true; // @oss-enable
-    if is_open_source {
-        // We don't log these, and we have no legacy users, and they might not upgrade that often,
-        // so lets just break open source things immediately.
-        return Err(err);
-    }
-
     Ok(err)
 }
 

app/buck2_execute_impl/src/materializers/deferred/artifact_tree.rs

@@ -392,7 +392,7 @@ impl ArtifactTree {
             }
             Err(e) => {
                 // NOTE: This shouldn't normally happen?
-                soft_error!("cleanup_finished_vacant", e, quiet: true).unwrap();
+                let _unused = soft_error!("cleanup_finished_vacant", e, quiet: true);
             }
         }
     }

app/buck2_execute_impl/src/materializers/deferred/command_processor.rs

@@ -553,12 +553,11 @@ impl<T: IoHandler> DeferredMaterializerCommandProcessor<T> {
                             Some(cmd.create_clean_fut(&mut self, None, daemon_id));
                     } else {
                         // This should never happen
-                        soft_error!(
+                        let _unused = soft_error!(
                             "clean_stale_no_config",
                             buck2_error!(buck2_error::ErrorTag::Tier0, "clean scheduled without being configured"),
                             quiet: true
-                        )
-                            .unwrap();
+                        );
                     }
                 }
             }
@@ -752,12 +751,11 @@ impl<T: IoHandler> DeferredMaterializerCommandProcessor<T> {
                     .materializer_state_table()
                     .update_access_times(buffer.iter().collect::<Vec<_>>())
                 {
-                    soft_error!(
+                    let _unused = soft_error!(
                         "materializer_materialize_error",
                         e,
                         quiet: true
-                    )
-                    .unwrap();
+                    );
                     return "Found error while updating access times in sqlite db".to_owned();
                 }
             }
@@ -1027,7 +1025,7 @@ impl<T: IoHandler> DeferredMaterializerCommandProcessor<T> {
                         .materializer_state_table()
                         .update_access_times(vec![&path])
                     {
-                        soft_error!("has_artifact_update_time", e, quiet: true).unwrap();
+                        let _unused = soft_error!("has_artifact_update_time", e, quiet: true);
                     }
                 }
             }
@@ -1475,7 +1473,7 @@ fn on_materialization(
             .materializer_state_table()
             .insert(path, metadata, timestamp)
         {
-            soft_error!(error_name, e, quiet: true).unwrap();
+            let _unused = soft_error!(error_name, e, quiet: true);
         }
     }
 

app/buck2_execute_impl/src/sqlite/incremental_state_db.rs

@@ -71,16 +71,15 @@ impl IncrementalDbState {
 
                 self.state.insert(key.to_owned(), value.clone().into());
                 if let Err(e) = db.incremental_state_table().insert(key.to_owned(), value) {
-                    soft_error!(
+                    let _unused = soft_error!(
                         "insert_to_incremental_db",
                         buck2_error::buck2_error!(
                             buck2_error::ErrorTag::Tier0,
                             "Failed to insert {} into sqlite db. {}",
                             key, e
                         ),
                         quiet: true
-                    )
-                    .unwrap();
+                    );
                 };
             }
             None => {
@@ -95,16 +94,15 @@ impl IncrementalDbState {
         {
             // This should be converted into a real error later, marking as a soft error for now as the row not existing
             // might show up as an error but doesn't actually matter in reality.
-            soft_error!(
+            let _unused = soft_error!(
                 "delete_from_incremental_db",
                 buck2_error::buck2_error!(
                     buck2_error::ErrorTag::Tier0,
                     "Failed to remove incremental path map from sqlite db. {}",
                     e
                 ),
                 quiet: true
-            )
-            .unwrap();
+            );
         }
 
         self.state.remove(key);