noobaa
diff --git a/‎src/sdk/accountspace_fs.js
Lines changed: 14 additions & 31 deletions b/‎src/sdk/accountspace_fs.js
Lines changed: 14 additions & 31 deletions
diff --git a/‎src/sdk/bucketspace_fs.js
Lines changed: 38 additions & 33 deletions b/‎src/sdk/bucketspace_fs.js
Lines changed: 38 additions & 33 deletions
@@ -21,11 +21,6 @@ const { get_symlink_config_file_path, get_config_file_path, get_config_data,
 const nc_mkm = require('../manage_nsfs/nc_master_key_manager').get_instance();
 const { account_cache } = require('./object_sdk');
 
-const entity_enum = Object.freeze({
-    USER: 'USER',
-    ACCESS_KEY: 'ACCESS_KEY',
-});
-
 // TODO - rename (the typo), move and reuse in manage_nsfs
 const acounts_dir_relative_path = '../accounts/';
 
@@ -87,7 +82,7 @@ class AccountSpaceFS {
             };
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.USER);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);
         }
     }
 
@@ -125,7 +120,7 @@ class AccountSpaceFS {
             };
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.USER);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);
         }
     }
 
@@ -179,7 +174,7 @@ class AccountSpaceFS {
             };
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.USER);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);
         }
     }
 
@@ -213,7 +208,7 @@ class AccountSpaceFS {
             await native_fs_utils.delete_config_file(this.fs_context, this.accounts_dir, account_config_path);
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.USER);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);
         }
     }
 
@@ -237,7 +232,7 @@ class AccountSpaceFS {
         return { members, is_truncated };
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.USER);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);
         }
     }
 
@@ -297,7 +292,7 @@ class AccountSpaceFS {
             };
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);
         }
     }
 
@@ -329,7 +324,7 @@ class AccountSpaceFS {
             };
         } catch (err) {
             dbg.error('AccountSpaceFS.get_access_key_last_used error', err);
-            throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);
         }
     }
 
@@ -380,7 +375,7 @@ class AccountSpaceFS {
             this._clean_account_cache(requested_account);
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);
         }
     }
 
@@ -426,7 +421,7 @@ class AccountSpaceFS {
             this._clean_account_cache(requested_account);
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);
         }
     }
 
@@ -460,26 +455,14 @@ class AccountSpaceFS {
             return { members, is_truncated, username: name_for_access_key };
         } catch (err) {
             dbg.error(`AccountSpaceFS.${action} error`, err);
-            throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);
+            throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);
         }
     }
 
     ////////////////////////
     // INTERNAL FUNCTIONS //
     ////////////////////////
 
-    // this function was copied from namespace_fs and bucketspace_fs
-    // It is a fallback that we use, but might be not accurate
-    _translate_error_codes(err, entity) {
-        if (err.rpc_code) return err;
-        if (err.code === 'ENOENT') err.rpc_code = `NO_SUCH_${entity}`;
-        if (err.code === 'EEXIST') err.rpc_code = `${entity}_ALREADY_EXISTS`;
-        if (err.code === 'EPERM' || err.code === 'EACCES') err.rpc_code = 'UNAUTHORIZED';
-        if (err.code === 'IO_STREAM_ITEM_TIMEOUT') err.rpc_code = 'IO_STREAM_ITEM_TIMEOUT';
-        if (err.code === 'INTERNAL_ERROR') err.rpc_code = 'INTERNAL_ERROR';
-        return err;
-    }
-
      _get_account_config_path(name) {
         return get_config_file_path(this.accounts_dir, name);
      }
@@ -572,7 +555,7 @@ class AccountSpaceFS {
         const basic_message = `User: ${arn_for_requesting_account} is not authorized to perform:` +
         `${full_action_name} on resource: `;
         let message_with_details;
-        if (entity === entity_enum.USER) {
+        if (entity === native_fs_utils.entity_enum.USER) {
             let user_message;
             if (action === 'list_access_keys') {
                 user_message = `user ${requesting_account.name.unwrap()}`;
@@ -581,7 +564,7 @@ class AccountSpaceFS {
             }
             message_with_details = basic_message +
             `${user_message} because no identity-based policy allows the ${full_action_name} action`;
-        } else { // entity_enum.ACCESS_KEY
+        } else { // native_fs_utils.entity_enum.ACCESS_KEY
             message_with_details = basic_message + `access key ${details.access_key}`;
         }
         const { code, http_code, type } = IamError.AccessDeniedException;
@@ -658,7 +641,7 @@ class AccountSpaceFS {
         if (!is_root_account) {
             dbg.error(`AccountSpaceFS.${action} requesting account is not a root account`,
                 requesting_account);
-            this._throw_access_denied_error(action, requesting_account, user_details, entity_enum.USER);
+            this._throw_access_denied_error(action, requesting_account, user_details, native_fs_utils.entity_enum.USER);
         }
     }
 
@@ -895,7 +878,7 @@ class AccountSpaceFS {
             dbg.error(`AccountSpaceFS.${action} requesting account is neither a root account ` +
             `nor user requester on himself`,
             requesting_account);
-            this._throw_access_denied_error(action, requesting_account, { username }, entity_enum.USER);
+            this._throw_access_denied_error(action, requesting_account, { username }, native_fs_utils.entity_enum.USER);
         }
         return requester;
     }
 
@@ -21,7 +21,8 @@ const { CONFIG_SUBDIRS } = require('../manage_nsfs/manage_nsfs_constants');
 
 const KeysSemaphore = require('../util/keys_semaphore');
 const { get_umasked_mode, isDirectory, validate_bucket_creation,
-    create_config_file, delete_config_file, get_bucket_tmpdir_full_path, folder_delete } = require('../util/native_fs_utils');
+    create_config_file, delete_config_file, get_bucket_tmpdir_full_path, folder_delete,
+    entity_enum, translate_error_codes } = require('../util/native_fs_utils');
 const NoobaaEvent = require('../manage_nsfs/manage_nsfs_events_utils').NoobaaEvent;
 const { anonymous_access_key } = require('./object_sdk');
 
@@ -86,16 +87,6 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
         }
     }
 
-    _translate_bucket_error_codes(err) {
-        if (err.rpc_code) return err;
-        if (err.code === 'ENOENT') err.rpc_code = 'NO_SUCH_BUCKET';
-        if (err.code === 'EEXIST') err.rpc_code = 'BUCKET_ALREADY_EXISTS';
-        if (err.code === 'EPERM' || err.code === 'EACCES') err.rpc_code = 'UNAUTHORIZED';
-        if (err.code === 'IO_STREAM_ITEM_TIMEOUT') err.rpc_code = 'IO_STREAM_ITEM_TIMEOUT';
-        if (err.code === 'INTERNAL_ERROR') err.rpc_code = 'INTERNAL_ERROR';
-        return err;
-    }
-
     async read_account_by_access_key({ access_key }) {
         try {
             if (!access_key) throw new Error('no access key');
@@ -178,7 +169,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
             }
             return bucket;
         } catch (err) {
-            const rpc_error = this._translate_bucket_error_codes(err);
+            const rpc_error = translate_error_codes(err, entity_enum.BUCKET);
             if (err.rpc_code === 'INVALID_SCHEMA') err.rpc_code = 'INVALID_BUCKET_STATE';
             new NoobaaEvent(NoobaaEvent[rpc_error.rpc_code]).create_event(name, {bucket_name: name}, err);
             throw rpc_error;
@@ -222,7 +213,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 dbg.error('BucketSpaceFS: root dir not found', err, this.bucket_schema_dir);
                 throw new S3Error(S3Error.NoSuchBucket);
             }
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
 
         const account = object_sdk.requesting_account;
@@ -302,7 +293,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 await create_config_file(this.fs_context, this.bucket_schema_dir, bucket_config_path, bucket_config);
             } catch (err) {
                 new NoobaaEvent(NoobaaEvent.BUCKET_CREATION_FAILED).create_event(name, {bucket_name: name}, err);
-                throw this._translate_bucket_error_codes(err);
+                throw translate_error_codes(err, entity_enum.BUCKET);
             }
 
             // create bucket's underlying storage directory
@@ -313,7 +304,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 dbg.error('BucketSpaceFS: create_bucket could not create underlying directory - nsfs, deleting bucket', err);
                 new NoobaaEvent(NoobaaEvent.BUCKET_DIR_CREATION_FAILED).create_event(name, {bucket: name, path: bucket_storage_path}, err);
                 await nb_native().fs.unlink(this.fs_context, bucket_config_path);
-                throw this._translate_bucket_error_codes(err);
+                throw translate_error_codes(err, entity_enum.BUCKET);
             }
         });
     }
@@ -359,13 +350,27 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 if (!namespace_bucket_config) throw new RpcError('INTERNAL_ERROR', 'Invalid Bucket configuration');
 
                 if (namespace_bucket_config.should_create_underlying_storage) {
-                    // 1. delete underlying storage
+                    // 1. delete underlying storage (ULS = Underline Storage)
                     dbg.log1('BucketSpaceFS.delete_bucket: deleting uls', this.fs_root, namespace_bucket_config.write_resource.path);
                     const bucket_storage_path = path.join(this.fs_root, namespace_bucket_config.write_resource.path); // includes write_resource.path + bucket name (s3 flow)
-                    await ns.delete_uls({ name, full_path: bucket_storage_path }, object_sdk);
+                    try {
+                        await ns.delete_uls({ name, full_path: bucket_storage_path }, object_sdk);
+                    } catch (err) {
+                        dbg.warn('delete_bucket: bucket name', name, 'with bucket_storage_path', bucket_storage_path,
+                            'got an error while trying to delete_uls', err);
+                        // in case the ULS was deleted - we will continue
+                        if (err.rpc_code !== 'NO_SUCH_BUCKET') throw err;
+                    }
                 } else {
                     // 2. delete only bucket tmpdir
-                    const list = await ns.list_objects({ ...params, bucket: name, limit: 1 }, object_sdk);
+                    let list;
+                    try {
+                        list = await ns.list_objects({ ...params, bucket: name, limit: 1 }, object_sdk);
+                    } catch (err) {
+                        dbg.warn('delete_bucket: bucket name', name, 'got an error while trying to list_objects', err);
+                        // in case the ULS was deleted - we will continue
+                        if (err.rpc_code !== 'NO_SUCH_BUCKET') throw err;
+                    }
                     if (list && list.objects && list.objects.length > 0) throw new RpcError('NOT_EMPTY', 'underlying directory has files in it');
                     const bucket_tmpdir_path = get_bucket_tmpdir_full_path(namespace_bucket_config.write_resource.path, bucket._id);
                     await folder_delete(bucket_tmpdir_path, this.fs_context, true);
@@ -375,10 +380,10 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 await delete_config_file(this.fs_context, this.bucket_schema_dir, bucket_config_path);
                 new NoobaaEvent(NoobaaEvent.BUCKET_DELETE).create_event(name, { bucket_name: name });
             } catch (err) {
-                dbg.error('BucketSpaceFS: delete_bucket: error', err);
+                dbg.error('BucketSpaceFS: delete_bucket: bucket name', name, 'error', err);
                 new NoobaaEvent(NoobaaEvent.BUCKET_DELETE_FAILED).create_event(name,
                     { bucket_name: name, bucket_path: bucket_config_path }, err);
-                throw this._translate_bucket_error_codes(err);
+                throw translate_error_codes(err, entity_enum.BUCKET);
             }
         });
     }
@@ -426,7 +431,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -484,7 +489,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -508,7 +513,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -521,7 +526,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
             const bucket = JSON.parse(data.toString());
             return bucket.logging;
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -550,7 +555,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 { mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -563,7 +568,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
             const bucket = JSON.parse(data.toString());
             return bucket.encryption;
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -586,7 +591,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 { mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -614,7 +619,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 { mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -637,7 +642,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 { mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -654,7 +659,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
             const bucket = JSON.parse(data.toString());
             return { website: bucket.website };
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -685,7 +690,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 { mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -708,7 +713,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 { mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }
             );
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
 
@@ -722,7 +727,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
                 policy: bucket_policy_info.s3_policy
             };
         } catch (err) {
-            throw this._translate_bucket_error_codes(err);
+            throw translate_error_codes(err, entity_enum.BUCKET);
         }
     }
Original file line number	Diff line number	Diff line change
`@@ -21,11 +21,6 @@ const { get_symlink_config_file_path, get_config_file_path, get_config_data,`
`21`	`21`	`const nc_mkm = require('../manage_nsfs/nc_master_key_manager').get_instance();`
`22`	`22`	`const { account_cache } = require('./object_sdk');`
`23`	`23`
`24`		`-const entity_enum = Object.freeze({`
`25`		`- USER: 'USER',`
`26`		`- ACCESS_KEY: 'ACCESS_KEY',`
`27`		`-});`
`28`		`-`
`29`	`24`	`// TODO - rename (the typo), move and reuse in manage_nsfs`
`30`	`25`	`const acounts_dir_relative_path = '../accounts/';`
`31`	`26`
`@@ -87,7 +82,7 @@ class AccountSpaceFS {`
`87`	`82`	`};`
`88`	`83`	`} catch (err) {`
`89`	`84`	dbg.error(`AccountSpaceFS.${action} error`, err);
`90`		`- throw this._translate_error_codes(err, entity_enum.USER);`
	`85`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);`
`91`	`86`	`}`
`92`	`87`	`}`
`93`	`88`
`@@ -125,7 +120,7 @@ class AccountSpaceFS {`
`125`	`120`	`};`
`126`	`121`	`} catch (err) {`
`127`	`122`	dbg.error(`AccountSpaceFS.${action} error`, err);
`128`		`- throw this._translate_error_codes(err, entity_enum.USER);`
	`123`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);`
`129`	`124`	`}`
`130`	`125`	`}`
`131`	`126`
`@@ -179,7 +174,7 @@ class AccountSpaceFS {`
`179`	`174`	`};`
`180`	`175`	`} catch (err) {`
`181`	`176`	dbg.error(`AccountSpaceFS.${action} error`, err);
`182`		`- throw this._translate_error_codes(err, entity_enum.USER);`
	`177`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);`
`183`	`178`	`}`
`184`	`179`	`}`
`185`	`180`
`@@ -213,7 +208,7 @@ class AccountSpaceFS {`
`213`	`208`	`await native_fs_utils.delete_config_file(this.fs_context, this.accounts_dir, account_config_path);`
`214`	`209`	`} catch (err) {`
`215`	`210`	dbg.error(`AccountSpaceFS.${action} error`, err);
`216`		`- throw this._translate_error_codes(err, entity_enum.USER);`
	`211`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);`
`217`	`212`	`}`
`218`	`213`	`}`
`219`	`214`
`@@ -237,7 +232,7 @@ class AccountSpaceFS {`
`237`	`232`	`return { members, is_truncated };`
`238`	`233`	`} catch (err) {`
`239`	`234`	dbg.error(`AccountSpaceFS.${action} error`, err);
`240`		`- throw this._translate_error_codes(err, entity_enum.USER);`
	`235`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.USER);`
`241`	`236`	`}`
`242`	`237`	`}`
`243`	`238`
`@@ -297,7 +292,7 @@ class AccountSpaceFS {`
`297`	`292`	`};`
`298`	`293`	`} catch (err) {`
`299`	`294`	dbg.error(`AccountSpaceFS.${action} error`, err);
`300`		`- throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);`
	`295`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);`
`301`	`296`	`}`
`302`	`297`	`}`
`303`	`298`
`@@ -329,7 +324,7 @@ class AccountSpaceFS {`
`329`	`324`	`};`
`330`	`325`	`} catch (err) {`
`331`	`326`	`dbg.error('AccountSpaceFS.get_access_key_last_used error', err);`
`332`		`- throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);`
	`327`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);`
`333`	`328`	`}`
`334`	`329`	`}`
`335`	`330`
`@@ -380,7 +375,7 @@ class AccountSpaceFS {`
`380`	`375`	`this._clean_account_cache(requested_account);`
`381`	`376`	`} catch (err) {`
`382`	`377`	dbg.error(`AccountSpaceFS.${action} error`, err);
`383`		`- throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);`
	`378`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);`
`384`	`379`	`}`
`385`	`380`	`}`
`386`	`381`
`@@ -426,7 +421,7 @@ class AccountSpaceFS {`
`426`	`421`	`this._clean_account_cache(requested_account);`
`427`	`422`	`} catch (err) {`
`428`	`423`	dbg.error(`AccountSpaceFS.${action} error`, err);
`429`		`- throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);`
	`424`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);`
`430`	`425`	`}`
`431`	`426`	`}`
`432`	`427`
`@@ -460,26 +455,14 @@ class AccountSpaceFS {`
`460`	`455`	`return { members, is_truncated, username: name_for_access_key };`
`461`	`456`	`} catch (err) {`
`462`	`457`	dbg.error(`AccountSpaceFS.${action} error`, err);
`463`		`- throw this._translate_error_codes(err, entity_enum.ACCESS_KEY);`
	`458`	`+ throw native_fs_utils.translate_error_codes(err, native_fs_utils.entity_enum.ACCESS_KEY);`
`464`	`459`	`}`
`465`	`460`	`}`
`466`	`461`
`467`	`462`	`////////////////////////`
`468`	`463`	`// INTERNAL FUNCTIONS //`
`469`	`464`	`////////////////////////`
`470`	`465`
`471`		`- // this function was copied from namespace_fs and bucketspace_fs`
`472`		`- // It is a fallback that we use, but might be not accurate`
`473`		`- _translate_error_codes(err, entity) {`
`474`		`- if (err.rpc_code) return err;`
`475`		- if (err.code === 'ENOENT') err.rpc_code = `NO_SUCH_${entity}`;
`476`		- if (err.code === 'EEXIST') err.rpc_code = `${entity}_ALREADY_EXISTS`;
`477`		`- if (err.code === 'EPERM' \|\| err.code === 'EACCES') err.rpc_code = 'UNAUTHORIZED';`
`478`		`- if (err.code === 'IO_STREAM_ITEM_TIMEOUT') err.rpc_code = 'IO_STREAM_ITEM_TIMEOUT';`
`479`		`- if (err.code === 'INTERNAL_ERROR') err.rpc_code = 'INTERNAL_ERROR';`
`480`		`- return err;`
`481`		`- }`
`482`		`-`
`483`	`466`	`_get_account_config_path(name) {`
`484`	`467`	`return get_config_file_path(this.accounts_dir, name);`
`485`	`468`	`}`
`@@ -572,7 +555,7 @@ class AccountSpaceFS {`
`572`	`555`	const basic_message = `User: ${arn_for_requesting_account} is not authorized to perform:` +
`573`	`556`	`${full_action_name} on resource: `;
`574`	`557`	`let message_with_details;`
`575`		`- if (entity === entity_enum.USER) {`
	`558`	`+ if (entity === native_fs_utils.entity_enum.USER) {`
`576`	`559`	`let user_message;`
`577`	`560`	`if (action === 'list_access_keys') {`
`578`	`561`	user_message = `user ${requesting_account.name.unwrap()}`;
`@@ -581,7 +564,7 @@ class AccountSpaceFS {`
`581`	`564`	`}`
`582`	`565`	`message_with_details = basic_message +`
`583`	`566`	`${user_message} because no identity-based policy allows the ${full_action_name} action`;
`584`		`- } else { // entity_enum.ACCESS_KEY`
	`567`	`+ } else { // native_fs_utils.entity_enum.ACCESS_KEY`
`585`	`568`	message_with_details = basic_message + `access key ${details.access_key}`;
`586`	`569`	`}`
`587`	`570`	`const { code, http_code, type } = IamError.AccessDeniedException;`
`@@ -658,7 +641,7 @@ class AccountSpaceFS {`
`658`	`641`	`if (!is_root_account) {`
`659`	`642`	dbg.error(`AccountSpaceFS.${action} requesting account is not a root account`,
`660`	`643`	`requesting_account);`
`661`		`- this._throw_access_denied_error(action, requesting_account, user_details, entity_enum.USER);`
	`644`	`+ this._throw_access_denied_error(action, requesting_account, user_details, native_fs_utils.entity_enum.USER);`
`662`	`645`	`}`
`663`	`646`	`}`
`664`	`647`
`@@ -895,7 +878,7 @@ class AccountSpaceFS {`
`895`	`878`	dbg.error(`AccountSpaceFS.${action} requesting account is neither a root account ` +
`896`	`879`	`nor user requester on himself`,
`897`	`880`	`requesting_account);`
`898`		`- this._throw_access_denied_error(action, requesting_account, { username }, entity_enum.USER);`
	`881`	`+ this._throw_access_denied_error(action, requesting_account, { username }, native_fs_utils.entity_enum.USER);`
`899`	`882`	`}`
`900`	`883`	`return requester;`
`901`	`884`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,8 @@ const { CONFIG_SUBDIRS } = require('../manage_nsfs/manage_nsfs_constants');`
`21`	`21`
`22`	`22`	`const KeysSemaphore = require('../util/keys_semaphore');`
`23`	`23`	`const { get_umasked_mode, isDirectory, validate_bucket_creation,`
`24`		`- create_config_file, delete_config_file, get_bucket_tmpdir_full_path, folder_delete } = require('../util/native_fs_utils');`
	`24`	`+ create_config_file, delete_config_file, get_bucket_tmpdir_full_path, folder_delete,`
	`25`	`+ entity_enum, translate_error_codes } = require('../util/native_fs_utils');`
`25`	`26`	`const NoobaaEvent = require('../manage_nsfs/manage_nsfs_events_utils').NoobaaEvent;`
`26`	`27`	`const { anonymous_access_key } = require('./object_sdk');`
`27`	`28`
`@@ -86,16 +87,6 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`86`	`87`	`}`
`87`	`88`	`}`
`88`	`89`
`89`		`- _translate_bucket_error_codes(err) {`
`90`		`- if (err.rpc_code) return err;`
`91`		`- if (err.code === 'ENOENT') err.rpc_code = 'NO_SUCH_BUCKET';`
`92`		`- if (err.code === 'EEXIST') err.rpc_code = 'BUCKET_ALREADY_EXISTS';`
`93`		`- if (err.code === 'EPERM' \|\| err.code === 'EACCES') err.rpc_code = 'UNAUTHORIZED';`
`94`		`- if (err.code === 'IO_STREAM_ITEM_TIMEOUT') err.rpc_code = 'IO_STREAM_ITEM_TIMEOUT';`
`95`		`- if (err.code === 'INTERNAL_ERROR') err.rpc_code = 'INTERNAL_ERROR';`
`96`		`- return err;`
`97`		`- }`
`98`		`-`
`99`	`90`	`async read_account_by_access_key({ access_key }) {`
`100`	`91`	`try {`
`101`	`92`	`if (!access_key) throw new Error('no access key');`
`@@ -178,7 +169,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`178`	`169`	`}`
`179`	`170`	`return bucket;`
`180`	`171`	`} catch (err) {`
`181`		`- const rpc_error = this._translate_bucket_error_codes(err);`
	`172`	`+ const rpc_error = translate_error_codes(err, entity_enum.BUCKET);`
`182`	`173`	`if (err.rpc_code === 'INVALID_SCHEMA') err.rpc_code = 'INVALID_BUCKET_STATE';`
`183`	`174`	`new NoobaaEvent(NoobaaEvent[rpc_error.rpc_code]).create_event(name, {bucket_name: name}, err);`
`184`	`175`	`throw rpc_error;`
`@@ -222,7 +213,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`222`	`213`	`dbg.error('BucketSpaceFS: root dir not found', err, this.bucket_schema_dir);`
`223`	`214`	`throw new S3Error(S3Error.NoSuchBucket);`
`224`	`215`	`}`
`225`		`- throw this._translate_bucket_error_codes(err);`
	`216`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`226`	`217`	`}`
`227`	`218`
`228`	`219`	`const account = object_sdk.requesting_account;`
`@@ -302,7 +293,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`302`	`293`	`await create_config_file(this.fs_context, this.bucket_schema_dir, bucket_config_path, bucket_config);`
`303`	`294`	`} catch (err) {`
`304`	`295`	`new NoobaaEvent(NoobaaEvent.BUCKET_CREATION_FAILED).create_event(name, {bucket_name: name}, err);`
`305`		`- throw this._translate_bucket_error_codes(err);`
	`296`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`306`	`297`	`}`
`307`	`298`
`308`	`299`	`// create bucket's underlying storage directory`
`@@ -313,7 +304,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`313`	`304`	`dbg.error('BucketSpaceFS: create_bucket could not create underlying directory - nsfs, deleting bucket', err);`
`314`	`305`	`new NoobaaEvent(NoobaaEvent.BUCKET_DIR_CREATION_FAILED).create_event(name, {bucket: name, path: bucket_storage_path}, err);`
`315`	`306`	`await nb_native().fs.unlink(this.fs_context, bucket_config_path);`
`316`		`- throw this._translate_bucket_error_codes(err);`
	`307`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`317`	`308`	`}`
`318`	`309`	`});`
`319`	`310`	`}`
`@@ -359,13 +350,27 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`359`	`350`	`if (!namespace_bucket_config) throw new RpcError('INTERNAL_ERROR', 'Invalid Bucket configuration');`
`360`	`351`
`361`	`352`	`if (namespace_bucket_config.should_create_underlying_storage) {`
`362`		`- // 1. delete underlying storage`
	`353`	`+ // 1. delete underlying storage (ULS = Underline Storage)`
`363`	`354`	`dbg.log1('BucketSpaceFS.delete_bucket: deleting uls', this.fs_root, namespace_bucket_config.write_resource.path);`
`364`	`355`	`const bucket_storage_path = path.join(this.fs_root, namespace_bucket_config.write_resource.path); // includes write_resource.path + bucket name (s3 flow)`
`365`		`- await ns.delete_uls({ name, full_path: bucket_storage_path }, object_sdk);`
	`356`	`+ try {`
	`357`	`+ await ns.delete_uls({ name, full_path: bucket_storage_path }, object_sdk);`
	`358`	`+ } catch (err) {`
	`359`	`+ dbg.warn('delete_bucket: bucket name', name, 'with bucket_storage_path', bucket_storage_path,`
	`360`	`+ 'got an error while trying to delete_uls', err);`
	`361`	`+ // in case the ULS was deleted - we will continue`
	`362`	`+ if (err.rpc_code !== 'NO_SUCH_BUCKET') throw err;`
	`363`	`+ }`
`366`	`364`	`} else {`
`367`	`365`	`// 2. delete only bucket tmpdir`
`368`		`- const list = await ns.list_objects({ ...params, bucket: name, limit: 1 }, object_sdk);`
	`366`	`+ let list;`
	`367`	`+ try {`
	`368`	`+ list = await ns.list_objects({ ...params, bucket: name, limit: 1 }, object_sdk);`
	`369`	`+ } catch (err) {`
	`370`	`+ dbg.warn('delete_bucket: bucket name', name, 'got an error while trying to list_objects', err);`
	`371`	`+ // in case the ULS was deleted - we will continue`
	`372`	`+ if (err.rpc_code !== 'NO_SUCH_BUCKET') throw err;`
	`373`	`+ }`
`369`	`374`	`if (list && list.objects && list.objects.length > 0) throw new RpcError('NOT_EMPTY', 'underlying directory has files in it');`
`370`	`375`	`const bucket_tmpdir_path = get_bucket_tmpdir_full_path(namespace_bucket_config.write_resource.path, bucket._id);`
`371`	`376`	`await folder_delete(bucket_tmpdir_path, this.fs_context, true);`
`@@ -375,10 +380,10 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`375`	`380`	`await delete_config_file(this.fs_context, this.bucket_schema_dir, bucket_config_path);`
`376`	`381`	`new NoobaaEvent(NoobaaEvent.BUCKET_DELETE).create_event(name, { bucket_name: name });`
`377`	`382`	`} catch (err) {`
`378`		`- dbg.error('BucketSpaceFS: delete_bucket: error', err);`
	`383`	`+ dbg.error('BucketSpaceFS: delete_bucket: bucket name', name, 'error', err);`
`379`	`384`	`new NoobaaEvent(NoobaaEvent.BUCKET_DELETE_FAILED).create_event(name,`
`380`	`385`	`{ bucket_name: name, bucket_path: bucket_config_path }, err);`
`381`		`- throw this._translate_bucket_error_codes(err);`
	`386`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`382`	`387`	`}`
`383`	`388`	`});`
`384`	`389`	`}`
`@@ -426,7 +431,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`426`	`431`	`}`
`427`	`432`	`);`
`428`	`433`	`} catch (err) {`
`429`		`- throw this._translate_bucket_error_codes(err);`
	`434`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`430`	`435`	`}`
`431`	`436`	`}`
`432`	`437`
`@@ -484,7 +489,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`484`	`489`	`}`
`485`	`490`	`);`
`486`	`491`	`} catch (err) {`
`487`		`- throw this._translate_bucket_error_codes(err);`
	`492`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`488`	`493`	`}`
`489`	`494`	`}`
`490`	`495`
`@@ -508,7 +513,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`508`	`513`	`}`
`509`	`514`	`);`
`510`	`515`	`} catch (err) {`
`511`		`- throw this._translate_bucket_error_codes(err);`
	`516`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`512`	`517`	`}`
`513`	`518`	`}`
`514`	`519`
`@@ -521,7 +526,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`521`	`526`	`const bucket = JSON.parse(data.toString());`
`522`	`527`	`return bucket.logging;`
`523`	`528`	`} catch (err) {`
`524`		`- throw this._translate_bucket_error_codes(err);`
	`529`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`525`	`530`	`}`
`526`	`531`	`}`
`527`	`532`
`@@ -550,7 +555,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`550`	`555`	`{ mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }`
`551`	`556`	`);`
`552`	`557`	`} catch (err) {`
`553`		`- throw this._translate_bucket_error_codes(err);`
	`558`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`554`	`559`	`}`
`555`	`560`	`}`
`556`	`561`
`@@ -563,7 +568,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`563`	`568`	`const bucket = JSON.parse(data.toString());`
`564`	`569`	`return bucket.encryption;`
`565`	`570`	`} catch (err) {`
`566`		`- throw this._translate_bucket_error_codes(err);`
	`571`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`567`	`572`	`}`
`568`	`573`	`}`
`569`	`574`
`@@ -586,7 +591,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`586`	`591`	`{ mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }`
`587`	`592`	`);`
`588`	`593`	`} catch (err) {`
`589`		`- throw this._translate_bucket_error_codes(err);`
	`594`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`590`	`595`	`}`
`591`	`596`	`}`
`592`	`597`
`@@ -614,7 +619,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`614`	`619`	`{ mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }`
`615`	`620`	`);`
`616`	`621`	`} catch (err) {`
`617`		`- throw this._translate_bucket_error_codes(err);`
	`622`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`618`	`623`	`}`
`619`	`624`	`}`
`620`	`625`
`@@ -637,7 +642,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`637`	`642`	`{ mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }`
`638`	`643`	`);`
`639`	`644`	`} catch (err) {`
`640`		`- throw this._translate_bucket_error_codes(err);`
	`645`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`641`	`646`	`}`
`642`	`647`	`}`
`643`	`648`
`@@ -654,7 +659,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`654`	`659`	`const bucket = JSON.parse(data.toString());`
`655`	`660`	`return { website: bucket.website };`
`656`	`661`	`} catch (err) {`
`657`		`- throw this._translate_bucket_error_codes(err);`
	`662`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`658`	`663`	`}`
`659`	`664`	`}`
`660`	`665`
`@@ -685,7 +690,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`685`	`690`	`{ mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }`
`686`	`691`	`);`
`687`	`692`	`} catch (err) {`
`688`		`- throw this._translate_bucket_error_codes(err);`
	`693`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`689`	`694`	`}`
`690`	`695`	`}`
`691`	`696`
`@@ -708,7 +713,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`708`	`713`	`{ mode: get_umasked_mode(config.BASE_MODE_CONFIG_FILE) }`
`709`	`714`	`);`
`710`	`715`	`} catch (err) {`
`711`		`- throw this._translate_bucket_error_codes(err);`
	`716`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`712`	`717`	`}`
`713`	`718`	`}`
`714`	`719`
`@@ -722,7 +727,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {`
`722`	`727`	`policy: bucket_policy_info.s3_policy`
`723`	`728`	`};`
`724`	`729`	`} catch (err) {`
`725`		`- throw this._translate_bucket_error_codes(err);`
	`730`	`+ throw translate_error_codes(err, entity_enum.BUCKET);`
`726`	`731`	`}`
`727`	`732`	`}`
`728`	`733`