Implements attachment uploading

kordophoned/src/daemon/attachment_store.rs

@@ -19,7 +19,7 @@ use std::sync::Arc;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::sync::Mutex;
 
-use tokio::pin;
+use uuid::Uuid;
 
 mod target {
     pub static ATTACHMENTS: &str = "attachments";
@@ -36,6 +36,12 @@ pub enum AttachmentStoreEvent {
     // - attachment guid
     // - preview: whether to download the preview (true) or full attachment (false)
     QueueDownloadAttachment(String, bool),
+
+    // Queue an upload for a given attachment file.
+    // Args:
+    // - path: the path to the attachment file
+    // - reply: a reply channel to send the pending upload guid to
+    QueueUploadAttachment(PathBuf, Reply<String>),
 }
 
 #[derive(Debug, Error)]
@@ -161,6 +167,47 @@ impl AttachmentStore {
         Ok(())
     }
 
+    async fn upload_attachment_impl(
+        store_path: &PathBuf,
+        incoming_path: &PathBuf,
+        upload_guid: &String,
+        database: &mut Arc<Mutex<Database>>,
+        daemon_event_sink: &Sender<DaemonEvent>,
+    ) -> Result<String> {
+        use tokio::fs::File;
+        use tokio::io::BufReader;        
+
+        // Create uploads directory if it doesn't exist.
+        let uploads_path = store_path.join("uploads");
+        std::fs::create_dir_all(&uploads_path).unwrap();
+
+        // First, copy the file to the store path, under /uploads/. 
+        log::trace!(target: target::ATTACHMENTS, "Copying attachment to uploads directory: {}", uploads_path.display());
+        let temporary_path = uploads_path.join(incoming_path.file_name().unwrap());
+        std::fs::copy(incoming_path, &temporary_path).unwrap();
+
+        // Open file handle to the temporary file, 
+        log::trace!(target: target::ATTACHMENTS, "Opening stream to temporary file: {}", temporary_path.display());
+        let file = File::open(&temporary_path).await?;
+        let reader: BufReader<File> = BufReader::new(file);
+
+        // Upload the file to the server.
+        let filename = incoming_path.file_name().unwrap().to_str().unwrap();
+        log::trace!(target: target::ATTACHMENTS, "Uploading attachment to server: {}", &filename);
+        let mut client = Daemon::get_client_impl(database).await?;
+        let guid = client.upload_attachment(reader, filename).await?;
+
+        // Delete the temporary file.
+        log::debug!(target: target::ATTACHMENTS, "Upload completed with guid {}, deleting temporary file: {}", guid, temporary_path.display());
+        std::fs::remove_file(&temporary_path).unwrap();
+
+        // Send a signal to the daemon that the attachment has been uploaded.
+        let event = DaemonEvent::AttachmentUploaded(upload_guid.clone(), guid.clone());
+        daemon_event_sink.send(event).await.unwrap();
+
+        Ok(guid)
+    }
+
     pub async fn run(&mut self) {
         loop {
             tokio::select! {
@@ -201,6 +248,30 @@ impl AttachmentStore {
                             let attachment = self.get_attachment(&guid);
                             reply.send(attachment).unwrap();
                         }
+
+                        AttachmentStoreEvent::QueueUploadAttachment(path, reply) => {
+                            let upload_guid = Uuid::new_v4().to_string();
+                            let store_path = self.store_path.clone();
+                            let mut database = self.database.clone();
+                            let daemon_event_sink = self.daemon_event_sink.clone();
+
+                            let _upload_guid = upload_guid.clone();
+                            tokio::spawn(async move {
+                                let result = Self::upload_attachment_impl(
+                                    &store_path,
+                                    &path,
+                                    &_upload_guid,
+                                    &mut database,
+                                    &daemon_event_sink,
+                                ).await;
+
+                                if let Err(e) = result {
+                                    log::error!(target: target::ATTACHMENTS, "Error uploading attachment {}: {}", &_upload_guid, e);
+                                }
+                            });
+
+                            reply.send(upload_guid).unwrap();
+                        }
                     }
                 }
             }