temp

Author: nikhilsinhaparseable

server/src/main.rs

@@ -58,6 +58,7 @@ async fn main() -> anyhow::Result<()> {
     CONFIG.validate_staging()?;
     migration::run_metadata_migration(&CONFIG).await?;
     let metadata = storage::resolve_parseable_metadata().await?;
+    
     banner::print(&CONFIG, &metadata).await;
     rbac::map::init(&metadata);
     metadata.set_global();

server/src/migration.rs

@@ -35,8 +35,10 @@ use crate::{
 pub async fn run_metadata_migration(config: &Config) -> anyhow::Result<()> {
     let object_store = config.storage().get_object_store();
     let storage_metadata = get_storage_metadata(&*object_store).await?;
+    println!("storage_metadata in run_metadata_migration: {:?}", storage_metadata);
     let staging_metadata = get_staging_metadata(config)?;
-
+    println!("staging_metadata in run_metadata_migration: {:?}", staging_metadata);
+    
     fn get_version(metadata: &serde_json::Value) -> Option<&str> {
         metadata
             .as_object()

server/src/option.rs

@@ -43,15 +43,22 @@ pub struct Config {
 impl Config {
     fn new() -> Self {
         let cli = parseable_cli_command().get_matches();
-
         match cli.subcommand() {
             Some(("local-store", m)) => {
                 let server = match Server::from_arg_matches(m) {
-                    Ok(server) => server,
+                    
+                    Ok(server) => {
+                        println!("server: {:?}", server);
+                        server
+                    },
                     Err(err) => err.exit(),
                 };
                 let storage = match FSConfig::from_arg_matches(m) {
-                    Ok(server) => server,
+
+                    Ok(storage) => {
+                        println!("storage: {:?}", storage);
+                        storage
+                    },
                     Err(err) => err.exit(),
                 };
 
@@ -81,11 +88,17 @@ impl Config {
             }
             Some(("s3-store", m)) => {
                 let server = match Server::from_arg_matches(m) {
-                    Ok(server) => server,
+                    Ok(server) => {
+                        println!("server: {:?}", server);
+                        server
+                    },
                     Err(err) => err.exit(),
                 };
                 let storage = match S3Config::from_arg_matches(m) {
-                    Ok(server) => server,
+                    Ok(storage) => {
+                        println!("storage: {:?}", storage);
+                        storage
+                    },
                     Err(err) => err.exit(),
                 };
 

server/src/storage/localfs.rs

@@ -120,6 +120,7 @@ impl ObjectStorage for LocalFS {
         let path = self.path_in_root(path);
         if let Some(parent) = path.parent() {
             fs::create_dir_all(parent).await?;
+            println!("created dir {:?}", parent);
         }
         let res = fs::write(path, resource).await;
 
@@ -140,6 +141,7 @@ impl ObjectStorage for LocalFS {
 
     async fn check(&self) -> Result<(), ObjectStorageError> {
         fs::create_dir_all(&self.root).await?;
+        println!("created dir self.root {:?}", &self.root);
         validate_path_is_writeable(&self.root)
             .map_err(|e| ObjectStorageError::UnhandledError(e.into()))
     }
@@ -187,7 +189,9 @@ impl ObjectStorage for LocalFS {
         };
         let to_path = self.root.join(key);
         if let Some(path) = to_path.parent() {
+            println!("created dir path {:?}", &path);
             fs::create_dir_all(path).await?
+            
         }
         let _ = fs_extra::file::copy(path, to_path, &op)?;
         Ok(())

server/src/storage/store_metadata.rs

@@ -96,9 +96,11 @@ impl StorageMetadata {
 // overwrites staging metadata while updating storage info
 pub async fn resolve_parseable_metadata() -> Result<StorageMetadata, ObjectStorageError> {
     let staging_metadata = get_staging_metadata()?;
+    println!("staging metadata in resolve_parseable_metadata: {:?}", staging_metadata);
     let storage = CONFIG.storage().get_object_store();
     let remote_metadata = storage.get_metadata().await?;
-
+    println!("remote metadata in resolve_parseable_metadata: {:?}", remote_metadata);
+    
     let check = match (staging_metadata, remote_metadata) {
         (Some(staging), Some(remote)) => {
             if staging.deployment_id == remote.deployment_id {