refactor(tvix/castore/blob/from_addr): use match guards

This will allow feature-flagging some of the backends.

Change-Id: Idffbf8b3fd154f5a3d938225c3871feffea8ff8c
Reviewed-on: https://cl.tvl.fyi/c/depot/+/11200
Autosubmit: flokli <flokli@flokli.de>
Tested-by: BuildkiteCI
Reviewed-by: raitobezarius <tvl@lahfa.xyz>

tvix/castore/src/blobservice/from_addr.rs

@@ -20,13 +20,15 @@ pub async fn from_addr(uri: &str) -> Result<Box<dyn BlobService>, crate::Error>
     let url = Url::parse(uri)
         .map_err(|e| crate::Error::StorageError(format!("unable to parse url: {}", e)))?;
 
-    Ok(if url.scheme() == "memory" {
+    let blob_service: Box<dyn BlobService> = match url.scheme() {
+        "memory" => {
             // memory doesn't support host or path in the URL.
             if url.has_host() || !url.path().is_empty() {
                 return Err(Error::StorageError("invalid url".to_string()));
             }
             Box::<MemoryBlobService>::default()
-    } else if url.scheme() == "sled" {
+        }
+        "sled" => {
             // sled doesn't support host, and a path can be provided (otherwise
             // it'll live in memory only).
             if url.has_host() {
@@ -41,15 +43,13 @@ pub async fn from_addr(uri: &str) -> Result<Box<dyn BlobService>, crate::Error>
 
             // TODO: expose other parameters as URL parameters?
 
-        if url.path().is_empty() {
+            Box::new(if url.path().is_empty() {
-            return Ok(Box::new(
+                SledBlobService::new_temporary().map_err(|e| Error::StorageError(e.to_string()))?
-                SledBlobService::new_temporary().map_err(|e| Error::StorageError(e.to_string()))?,
+            } else {
-            ));
+                SledBlobService::new(url.path()).map_err(|e| Error::StorageError(e.to_string()))?
+            })
         }
-        return Ok(Box::new(
+        scheme if scheme.starts_with("grpc+") => {
-            SledBlobService::new(url.path()).map_err(|e| Error::StorageError(e.to_string()))?,
-        ));
-    } else if url.scheme().starts_with("grpc+") {
             // schemes starting with grpc+ go to the GRPCPathInfoService.
             //   That's normally grpc+unix for unix sockets, and grpc+http(s) for the HTTP counterparts.
             // - In the case of unix sockets, there must be a path, but may not be a host.
@@ -57,29 +57,35 @@ pub async fn from_addr(uri: &str) -> Result<Box<dyn BlobService>, crate::Error>
             // Constructing the channel is handled by tvix_castore::channel::from_url.
             let client = BlobServiceClient::new(crate::tonic::channel_from_url(&url).await?);
             Box::new(GRPCBlobService::from_client(client))
-    } else if url.scheme() == "simplefs" {
+        }
+        "simplefs" => {
             if url.path().is_empty() {
                 return Err(Error::StorageError("Invalid filesystem path".to_string()));
             }
 
             Box::new(SimpleFilesystemBlobService::new(url.path().into()).await?)
-    } else if let Some(_trimmed_scheme) = url.scheme().strip_prefix("objectstore+") {
+        }
+        scheme if scheme.starts_with("objectstore+") => {
             // We need to convert the URL to string, strip the prefix there, and then
             // parse it back as url, as Url::set_scheme() rejects some of the transitions we want to do.
             let trimmed_url = {
                 let s = url.to_string();
                 Url::parse(s.strip_prefix("objectstore+").unwrap()).unwrap()
             };
-        return Ok(Box::new(
+            Box::new(
                 ObjectStoreBlobService::parse_url(&trimmed_url)
                     .map_err(|e| Error::StorageError(e.to_string()))?,
-        ));
+            )
-    } else {
+        }
-        Err(crate::Error::StorageError(format!(
+        scheme => {
+            return Err(crate::Error::StorageError(format!(
                 "unknown scheme: {}",
-            url.scheme()
+                scheme
-        )))?
+            )))
-    })
+        }
+    };
+
+    Ok(blob_service)
 }
 
 #[cfg(test)]