ec use AsyncRead

ecstore/src/disk/mod.rs

@@ -21,9 +21,11 @@ use crate::{
 };
 use endpoint::Endpoint;
 use futures::StreamExt;
+use local::LocalDisk;
 use protos::proto_gen::node_service::{
     node_service_client::NodeServiceClient, ReadAtRequest, ReadAtResponse, WriteRequest, WriteResponse,
 };
+use remote::RemoteDisk;
 use serde::{Deserialize, Serialize};
 use std::{
     any::Any,
@@ -47,15 +49,304 @@ use tracing::info;
 use tracing::warn;
 use uuid::Uuid;
 
-pub type DiskStore = Arc<Box<dyn DiskAPI>>;
+pub type DiskStore = Arc<Disk>;
+
+#[derive(Debug)]
+pub enum Disk {
+    Local(LocalDisk),
+    Remote(RemoteDisk),
+}
+
+#[async_trait::async_trait]
+impl DiskAPI for Disk {
+    fn to_string(&self) -> String {
+        match self {
+            Disk::Local(local_disk) => local_disk.to_string(),
+            Disk::Remote(remote_disk) => remote_disk.to_string(),
+        }
+    }
+
+    fn is_local(&self) -> bool {
+        match self {
+            Disk::Local(local_disk) => local_disk.is_local(),
+            Disk::Remote(remote_disk) => remote_disk.is_local(),
+        }
+    }
+
+    fn host_name(&self) -> String {
+        match self {
+            Disk::Local(local_disk) => local_disk.host_name(),
+            Disk::Remote(remote_disk) => remote_disk.host_name(),
+        }
+    }
+    async fn is_online(&self) -> bool {
+        match self {
+            Disk::Local(local_disk) => local_disk.is_online().await,
+            Disk::Remote(remote_disk) => remote_disk.is_online().await,
+        }
+    }
+    fn endpoint(&self) -> Endpoint {
+        match self {
+            Disk::Local(local_disk) => local_disk.endpoint(),
+            Disk::Remote(remote_disk) => remote_disk.endpoint(),
+        }
+    }
+    async fn close(&self) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.close().await,
+            Disk::Remote(remote_disk) => remote_disk.close().await,
+        }
+    }
+    fn path(&self) -> PathBuf {
+        match self {
+            Disk::Local(local_disk) => local_disk.path(),
+            Disk::Remote(remote_disk) => remote_disk.path(),
+        }
+    }
+
+    fn get_disk_location(&self) -> DiskLocation {
+        match self {
+            Disk::Local(local_disk) => local_disk.get_disk_location(),
+            Disk::Remote(remote_disk) => remote_disk.get_disk_location(),
+        }
+    }
+
+    async fn get_disk_id(&self) -> Result<Option<Uuid>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.get_disk_id().await,
+            Disk::Remote(remote_disk) => remote_disk.get_disk_id().await,
+        }
+    }
+    async fn set_disk_id(&self, id: Option<Uuid>) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.set_disk_id(id).await,
+            Disk::Remote(remote_disk) => remote_disk.set_disk_id(id).await,
+        }
+    }
+
+    async fn read_all(&self, volume: &str, path: &str) -> Result<Vec<u8>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.read_all(volume, path).await,
+            Disk::Remote(remote_disk) => remote_disk.read_all(volume, path).await,
+        }
+    }
+
+    async fn write_all(&self, volume: &str, path: &str, data: Vec<u8>) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.write_all(volume, path, data).await,
+            Disk::Remote(remote_disk) => remote_disk.write_all(volume, path, data).await,
+        }
+    }
+
+    async fn delete(&self, volume: &str, path: &str, opt: DeleteOptions) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.delete(volume, path, opt).await,
+            Disk::Remote(remote_disk) => remote_disk.delete(volume, path, opt).await,
+        }
+    }
+
+    async fn verify_file(&self, volume: &str, path: &str, fi: &FileInfo) -> Result<CheckPartsResp> {
+        match self {
+            Disk::Local(local_disk) => local_disk.verify_file(volume, path, fi).await,
+            Disk::Remote(remote_disk) => remote_disk.verify_file(volume, path, fi).await,
+        }
+    }
+
+    async fn check_parts(&self, volume: &str, path: &str, fi: &FileInfo) -> Result<CheckPartsResp> {
+        match self {
+            Disk::Local(local_disk) => local_disk.check_parts(volume, path, fi).await,
+            Disk::Remote(remote_disk) => remote_disk.check_parts(volume, path, fi).await,
+        }
+    }
+
+    async fn rename_part(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str, meta: Vec<u8>) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.rename_part(src_volume, src_path, dst_volume, dst_path, meta).await,
+            Disk::Remote(remote_disk) => {
+                remote_disk
+                    .rename_part(src_volume, src_path, dst_volume, dst_path, meta)
+                    .await
+            }
+        }
+    }
+    async fn rename_file(&self, src_volume: &str, src_path: &str, dst_volume: &str, dst_path: &str) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.rename_file(src_volume, src_path, dst_volume, dst_path).await,
+            Disk::Remote(remote_disk) => remote_disk.rename_file(src_volume, src_path, dst_volume, dst_path).await,
+        }
+    }
+
+    async fn create_file(&self, _origvolume: &str, volume: &str, path: &str, _file_size: usize) -> Result<FileWriter> {
+        match self {
+            Disk::Local(local_disk) => local_disk.create_file(_origvolume, volume, path, _file_size).await,
+            Disk::Remote(remote_disk) => remote_disk.create_file(_origvolume, volume, path, _file_size).await,
+        }
+    }
+
+    async fn append_file(&self, volume: &str, path: &str) -> Result<FileWriter> {
+        match self {
+            Disk::Local(local_disk) => local_disk.append_file(volume, path).await,
+            Disk::Remote(remote_disk) => remote_disk.append_file(volume, path).await,
+        }
+    }
+
+    async fn read_file(&self, volume: &str, path: &str) -> Result<FileReader> {
+        match self {
+            Disk::Local(local_disk) => local_disk.read_file(volume, path).await,
+            Disk::Remote(remote_disk) => remote_disk.read_file(volume, path).await,
+        }
+    }
+
+    async fn list_dir(&self, _origvolume: &str, volume: &str, _dir_path: &str, _count: i32) -> Result<Vec<String>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.list_dir(_origvolume, volume, _dir_path, _count).await,
+            Disk::Remote(remote_disk) => remote_disk.list_dir(_origvolume, volume, _dir_path, _count).await,
+        }
+    }
+
+    async fn walk_dir(&self, opts: WalkDirOptions) -> Result<Vec<MetaCacheEntry>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.walk_dir(opts).await,
+            Disk::Remote(remote_disk) => remote_disk.walk_dir(opts).await,
+        }
+    }
+
+    async fn rename_data(
+        &self,
+        src_volume: &str,
+        src_path: &str,
+        fi: FileInfo,
+        dst_volume: &str,
+        dst_path: &str,
+    ) -> Result<RenameDataResp> {
+        match self {
+            Disk::Local(local_disk) => local_disk.rename_data(src_volume, src_path, fi, dst_volume, dst_path).await,
+            Disk::Remote(remote_disk) => remote_disk.rename_data(src_volume, src_path, fi, dst_volume, dst_path).await,
+        }
+    }
+
+    async fn make_volumes(&self, volumes: Vec<&str>) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.make_volumes(volumes).await,
+            Disk::Remote(remote_disk) => remote_disk.make_volumes(volumes).await,
+        }
+    }
+
+    async fn make_volume(&self, volume: &str) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.make_volume(volume).await,
+            Disk::Remote(remote_disk) => remote_disk.make_volume(volume).await,
+        }
+    }
+
+    async fn list_volumes(&self) -> Result<Vec<VolumeInfo>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.list_volumes().await,
+            Disk::Remote(remote_disk) => remote_disk.list_volumes().await,
+        }
+    }
+
+    async fn stat_volume(&self, volume: &str) -> Result<VolumeInfo> {
+        match self {
+            Disk::Local(local_disk) => local_disk.stat_volume(volume).await,
+            Disk::Remote(remote_disk) => remote_disk.stat_volume(volume).await,
+        }
+    }
+
+    async fn delete_paths(&self, volume: &str, paths: &[&str]) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.delete_paths(volume, paths).await,
+            Disk::Remote(remote_disk) => remote_disk.delete_paths(volume, paths).await,
+        }
+    }
+    async fn update_metadata(&self, volume: &str, path: &str, fi: FileInfo, opts: &UpdateMetadataOpts) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.update_metadata(volume, path, fi, opts).await,
+            Disk::Remote(remote_disk) => remote_disk.update_metadata(volume, path, fi, opts).await,
+        }
+    }
+
+    async fn write_metadata(&self, _org_volume: &str, volume: &str, path: &str, fi: FileInfo) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.write_metadata(_org_volume, volume, path, fi).await,
+            Disk::Remote(remote_disk) => remote_disk.write_metadata(_org_volume, volume, path, fi).await,
+        }
+    }
+
+    async fn read_version(
+        &self,
+        _org_volume: &str,
+        volume: &str,
+        path: &str,
+        version_id: &str,
+        opts: &ReadOptions,
+    ) -> Result<FileInfo> {
+        match self {
+            Disk::Local(local_disk) => local_disk.read_version(_org_volume, volume, path, version_id, opts).await,
+            Disk::Remote(remote_disk) => remote_disk.read_version(_org_volume, volume, path, version_id, opts).await,
+        }
+    }
+
+    async fn read_xl(&self, volume: &str, path: &str, read_data: bool) -> Result<RawFileInfo> {
+        match self {
+            Disk::Local(local_disk) => local_disk.read_xl(volume, path, read_data).await,
+            Disk::Remote(remote_disk) => remote_disk.read_xl(volume, path, read_data).await,
+        }
+    }
+    async fn delete_version(
+        &self,
+        volume: &str,
+        path: &str,
+        fi: FileInfo,
+        force_del_marker: bool,
+        opts: DeleteOptions,
+    ) -> Result<RawFileInfo> {
+        match self {
+            Disk::Local(local_disk) => local_disk.delete_version(volume, path, fi, force_del_marker, opts).await,
+            Disk::Remote(remote_disk) => remote_disk.delete_version(volume, path, fi, force_del_marker, opts).await,
+        }
+    }
+    async fn delete_versions(
+        &self,
+        volume: &str,
+        versions: Vec<FileInfoVersions>,
+        opts: DeleteOptions,
+    ) -> Result<Vec<Option<Error>>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.delete_versions(volume, versions, opts).await,
+            Disk::Remote(remote_disk) => remote_disk.delete_versions(volume, versions, opts).await,
+        }
+    }
+
+    async fn read_multiple(&self, req: ReadMultipleReq) -> Result<Vec<ReadMultipleResp>> {
+        match self {
+            Disk::Local(local_disk) => local_disk.read_multiple(req).await,
+            Disk::Remote(remote_disk) => remote_disk.read_multiple(req).await,
+        }
+    }
+
+    async fn delete_volume(&self, volume: &str) -> Result<()> {
+        match self {
+            Disk::Local(local_disk) => local_disk.delete_volume(volume).await,
+            Disk::Remote(remote_disk) => remote_disk.delete_volume(volume).await,
+        }
+    }
+
+    async fn disk_info(&self, opts: &DiskInfoOptions) -> Result<DiskInfo> {
+        match self {
+            Disk::Local(local_disk) => local_disk.disk_info(opts).await,
+            Disk::Remote(remote_disk) => remote_disk.disk_info(opts).await,
+        }
+    }
+}
 
 pub async fn new_disk(ep: &endpoint::Endpoint, opt: &DiskOption) -> Result<DiskStore> {
     if ep.is_local {
         let s = local::LocalDisk::new(ep, opt.cleanup).await?;
-        Ok(Arc::new(Box::new(s)))
+        Ok(Arc::new(Disk::Local(s)))
     } else {
         let remote_disk = remote::RemoteDisk::new(ep, opt).await?;
-        Ok(Arc::new(Box::new(remote_disk)))
+        Ok(Arc::new(Disk::Remote(remote_disk)))
     }
 }