更新全局disk

ecstore/src/disk/local.rs

@@ -19,18 +19,29 @@ use std::{
 use time::OffsetDateTime;
 use tokio::fs::{self, File};
 use tokio::io::ErrorKind;
+use tokio::sync::Mutex;
 use tracing::{debug, warn};
 use uuid::Uuid;
 
+#[derive(Debug)]
+pub struct FormatInfo {
+    pub id: Option<Uuid>,
+    pub data: Vec<u8>,
+    pub file_info: Option<Metadata>,
+    pub last_check: Option<OffsetDateTime>,
+}
+
+impl FormatInfo {}
+
 #[derive(Debug)]
 pub struct LocalDisk {
     pub root: PathBuf,
-    pub id: Uuid,
-    pub _format_data: Vec<u8>,
-    pub _format_meta: Option<Metadata>,
     pub _format_path: PathBuf,
-    // pub format_legacy: bool, // drop
-    pub _format_last_check: Option<OffsetDateTime>,
+    pub format_info: Mutex<FormatInfo>,
+    // pub id: Mutex<Option<Uuid>>,
+    // pub format_data: Mutex<Vec<u8>>,
+    // pub format_file_info: Mutex<Option<Metadata>>,
+    // pub format_last_check: Mutex<Option<OffsetDateTime>>,
 }
 
 impl LocalDisk {
@@ -48,7 +59,7 @@ impl LocalDisk {
 
         let (format_data, format_meta) = read_file_exists(&format_path).await?;
 
-        let mut id = Uuid::nil();
+        let mut id = None;
         // let mut format_legacy = false;
         let mut format_last_check = None;
 
@@ -61,19 +72,26 @@ impl LocalDisk {
                 return Err(Error::from(DiskError::InconsistentDisk));
             }
 
-            id = fm.erasure.this;
+            id = Some(fm.erasure.this);
             // format_legacy = fm.erasure.distribution_algo == DistributionAlgoVersion::V1;
             format_last_check = Some(OffsetDateTime::now_utc());
         }
 
+        let format_info = FormatInfo {
+            id,
+            data: format_data,
+            file_info: format_meta,
+            last_check: format_last_check,
+        };
+
         let disk = Self {
             root,
-            id,
-            _format_meta: format_meta,
-            _format_data: format_data,
             _format_path: format_path,
-            // format_legacy,
-            _format_last_check: format_last_check,
+            format_info: Mutex::new(format_info),
+            // // format_legacy,
+            // format_file_info: Mutex::new(format_meta),
+            // format_data: Mutex::new(format_data),
+            // format_last_check: Mutex::new(format_last_check),
         };
 
         disk.make_meta_volumes().await?;
@@ -389,15 +407,26 @@ impl DiskAPI for LocalDisk {
     fn is_local(&self) -> bool {
         true
     }
-
-    fn id(&self) -> Uuid {
-        self.id
+    async fn close(&self) -> Result<()> {
+        Ok(())
     }
-
     fn path(&self) -> PathBuf {
         self.root.clone()
     }
 
+    async fn get_disk_id(&self) -> Option<Uuid> {
+        // TODO: check format file
+        let format_info = self.format_info.lock().await;
+
+        format_info.id.clone()
+        // TODO: 判断源文件id,是否有效
+    }
+
+    async fn set_disk_id(&self, _id: Option<Uuid>) -> Result<()> {
+        // 本地不需要设置
+        Ok(())
+    }
+
     #[must_use]
     async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes> {
         let p = self.get_object_path(volume, path)?;

ecstore/src/disk/mod.rs

@@ -46,8 +46,10 @@ pub async fn new_disk(ep: &endpoint::Endpoint, opt: &DiskOption) -> Result<DiskS
 #[async_trait::async_trait]
 pub trait DiskAPI: Debug + Send + Sync + 'static {
     fn is_local(&self) -> bool;
-    fn id(&self) -> Uuid;
     fn path(&self) -> PathBuf;
+    async fn close(&self) -> Result<()>;
+    async fn get_disk_id(&self) -> Option<Uuid>;
+    async fn set_disk_id(&self, id: Option<Uuid>) -> Result<()>;
 
     async fn delete(&self, volume: &str, path: &str, opt: DeleteOptions) -> Result<()>;
     async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes>;

ecstore/src/disk/remote.rs

@@ -1,6 +1,7 @@
 use std::{path::PathBuf, sync::RwLock, time::Duration};
 
 use bytes::Bytes;
+use futures::lock::Mutex;
 use protos::{
     node_service_time_out_client,
     proto_gen::node_service::{
@@ -32,6 +33,7 @@ use super::{
 
 #[derive(Debug)]
 pub struct RemoteDisk {
+    id: Mutex<Option<Uuid>>,
     channel: RwLock<Option<Channel>>,
     url: url::Url,
     pub root: PathBuf,
@@ -45,6 +47,7 @@ impl RemoteDisk {
             channel: RwLock::new(None),
             url: ep.url.clone(),
             root,
+            id: Mutex::new(None),
         })
     }
 
@@ -83,15 +86,23 @@ impl DiskAPI for RemoteDisk {
     fn is_local(&self) -> bool {
         false
     }
-
-    fn id(&self) -> Uuid {
-        Uuid::nil()
+    async fn close(&self) -> Result<()> {
+        Ok(())
     }
-
     fn path(&self) -> PathBuf {
         self.root.clone()
     }
 
+    async fn get_disk_id(&self) -> Option<Uuid> {
+        self.id.lock().await.clone()
+    }
+    async fn set_disk_id(&self, id: Option<Uuid>) -> Result<()> {
+        let mut lock = self.id.lock().await;
+        *lock = id;
+
+        Ok(())
+    }
+
     async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes> {
         let mut client = self.get_client();
         let request = Request::new(ReadAllRequest {