Method upload_object

bridge/src/client/data_store/sftp.rs:109–163

(
        &self,
        key: &str,
        data: &[u8],
        file_path: Option<&str>,
    )

    }

    async fn upload_object(
        &self,
        key: &str,
        data: &[u8],
        file_path: Option<&str>,
    ) -> Result<(), String> {
        match connect(&self.credentials).await {
            Ok(sftp) => {
                match create_directories_if_non_existent(&sftp, file_path).await {
                    Ok(_) => {
                        let mut full_filename = key.to_string();
                        if file_path.is_some() {
                            full_filename = format!("{}/{}", file_path.unwrap(), key);
                        }
                        let result = sftp
                            .options()
                            .write(true)
                            .create_new(true)
                            .open(full_filename)
                            .await; // Use intermediate variable to prevent GC issue
                        match result {
                            Ok(_file) => {
                                let mut file = Box::pin(TokioCompatFile::from(_file));
                                match file.write(data).await {
                                    Ok(_) => match file.flush().await {
                                        Ok(_) => {
                                            drop(file);
                                            disconnect(sftp).await;
                                            Ok(())
                                        }
                                        Err(err) => {
                                            drop(file);
                                            disconnect(sftp).await;
                                            Err(format!("Unable to write {}: {}", key, err))
                                        }
                                    },
                                    Err(err) => {
                                        drop(file);
                                        disconnect(sftp).await;
                                        Err(format!("Unable to write {}: {}", key, err))
                                    }
                                }
                            }
                            Err(err) => {
                                disconnect(sftp).await;
                                Err(format!("Unable to write {}: {}", key, err))
                            }
                        }
                    }
                    Err(err) => Err(format!("Unable to write {}: {}", key, err)),
                }
            }
            Err(err) => Err(format!("Unable to write {}: {}", key, err)),
        }
    }
}

#[async_trait]