ARSN-528: add BucketLoggingStatus to BucketInfo model

Author: leif-scality

lib/models/BucketInfo.ts

@@ -11,6 +11,7 @@ import { ACL as OACL } from './ObjectMD';
 import { areTagsValid, BucketTag } from '../s3middleware/tagging';
 import { VeeamCapability, VeeamSOSApiSchema, VeeamSOSApiSerializable } from './Veeam';
 import { AzureInfoMetadata } from './BucketAzureInfo';
+import BucketLoggingStatus from './BucketLoggingStatus';
 
 // WHEN UPDATING THIS NUMBER, UPDATE BucketInfoModelVersion.md CHANGELOG
 // BucketInfoModelVersion.md can be found in documentation/ at the root
@@ -78,6 +79,7 @@ export type BucketMetadata = {
     tags: Array<BucketTag>,
     capabilities?: Capabilities,
     quotaMax: bigint | number,
+    bucketLoggingStatus?: BucketLoggingStatus,
 };
 
 export type BucketMetadataJSON = Omit<BucketMetadata, 'quotaMax' | 'capabilities'> & {
@@ -115,6 +117,7 @@ export default class BucketInfo implements BucketMetadata {
     private _ingestion?: { status: 'enabled' | 'disabled' };
     private _capabilities?: Capabilities;
     private _quotaMax: bigint;
+    private _bucketLoggingStatus?: BucketLoggingStatus;
 
     /**
     * Represents all bucket information.
@@ -201,6 +204,7 @@ export default class BucketInfo implements BucketMetadata {
         tags?: Array<BucketTag> | [],
         capabilities?: Capabilities,
         quotaMax?: bigint | number,
+        bucketLoggingStatus?: BucketLoggingStatus,
     ) {
         assert.strictEqual(typeof name, 'string');
         assert.strictEqual(typeof owner, 'string');
@@ -327,6 +331,10 @@ export default class BucketInfo implements BucketMetadata {
         }
         assert.strictEqual(areTagsValid(tags), true);
 
+        if (bucketLoggingStatus) {
+            assert(bucketLoggingStatus instanceof BucketLoggingStatus);
+        }
+
         // IF UPDATING PROPERTIES, INCREMENT MODELVERSION NUMBER ABOVE
         this._acl = aclInstance;
         this._name = name;
@@ -353,6 +361,7 @@ export default class BucketInfo implements BucketMetadata {
         this._objectLockConfiguration = objectLockConfiguration;
         this._notificationConfiguration = notificationConfiguration;
         this._tags = tags;
+        this._bucketLoggingStatus = bucketLoggingStatus;
 
         this._capabilities = capabilities && {
             ...capabilities,
@@ -401,6 +410,7 @@ export default class BucketInfo implements BucketMetadata {
                     VeeamCapability.serialize(this._capabilities.VeeamSOSApi),
             },
             quotaMax: this._quotaMax.toString(),
+            bucketLoggingStatus: this._bucketLoggingStatus,
         };
         const final = this._websiteConfiguration
             ? {
@@ -441,7 +451,7 @@ export default class BucketInfo implements BucketMetadata {
             obj.bucketPolicy, obj.uid, obj.readLocationConstraint, obj.isNFS,
             obj.ingestion, obj.azureInfo, obj.objectLockEnabled,
             obj.objectLockConfiguration, obj.notificationConfiguration, obj.tags,
-            capabilities, BigInt(obj.quotaMax || 0n));
+            capabilities, BigInt(obj.quotaMax || 0n), obj.bucketLoggingStatus);
     }
 
     /**
@@ -474,7 +484,7 @@ export default class BucketInfo implements BucketMetadata {
             data._isNFS, data._ingestion, data._azureInfo,
             data._objectLockEnabled, data._objectLockConfiguration,
             data._notificationConfiguration, data._tags, capabilities,
-            BigInt(data._quotaMax || 0n));
+            BigInt(data._quotaMax || 0n), data._bucketLoggingStatus);
     }
 
     /**
@@ -497,7 +507,7 @@ export default class BucketInfo implements BucketMetadata {
                 ...data.capabilities,
                 VeeamSOSApi: data.capabilities?.VeeamSOSApi &&
                     VeeamCapability.parse(data.capabilities?.VeeamSOSApi),
-            }, BigInt(data.quotaMax || 0n));
+            }, BigInt(data.quotaMax || 0n), data.bucketLoggingStatus);
     }
 
     /**
@@ -1070,4 +1080,22 @@ export default class BucketInfo implements BucketMetadata {
         this._quotaMax = BigInt(quota || 0n);
         return this;
     }
+
+    /**
+     * Get bucket logging status
+     * @returns - bucket logging status
+     */
+    getBucketLoggingStatus() : BucketLoggingStatus | undefined {
+        return this._bucketLoggingStatus;
+    }
+
+    /**
+     * Set bucket logging status
+     * @param bucketLoggingStatus - bucket logging status
+     * @returns - this
+     */
+    setBucketLoggingStatus(bucketLoggingStatus : BucketLoggingStatus) {
+        this._bucketLoggingStatus = bucketLoggingStatus;
+        return this;
+    }
 }

lib/models/BucketLoggingStatus.ts

@@ -0,0 +1,137 @@
+import { parseStringPromise } from 'xml2js';
+import errors, { ArsenalError } from '../errors';
+
+/**
+ * Format of xml request:
+<?xml version="1.0" encoding="UTF-8"?>
+<BucketLoggingStatus xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+   <LoggingEnabled>
+      <TargetBucket>string</TargetBucket>
+      <TargetGrants>
+         <Grant>
+            <Grantee>
+               <DisplayName>string</DisplayName>
+               <EmailAddress>string</EmailAddress>
+               <ID>string</ID>
+               <xsi:type>string</xsi:type>
+               <URI>string</URI>
+            </Grantee>
+            <Permission>string</Permission>
+         </Grant>
+      </TargetGrants>
+      <TargetObjectKeyFormat>
+         <PartitionedPrefix>
+            <PartitionDateSource>string</PartitionDateSource>
+         </PartitionedPrefix>
+         <SimplePrefix>
+         </SimplePrefix>
+      </TargetObjectKeyFormat>
+      <TargetPrefix>string</TargetPrefix>
+   </LoggingEnabled>
+</BucketLoggingStatus>
+*/
+
+export type LoggingEnabled = {
+    TargetBucket: string;
+    TargetPrefix: string;
+};
+
+export default class BucketLoggingStatus {
+    private _loggingEnabled?: LoggingEnabled;
+
+    constructor(loggingEnabled?: LoggingEnabled) {
+        this._loggingEnabled = loggingEnabled;
+    }
+
+    toXML(): string {
+        let loggingEnabledXML = "";
+        if (this._loggingEnabled) {
+            loggingEnabledXML = `<LoggingEnabled>
+    <TargetBucket>${this._loggingEnabled.TargetBucket}</TargetBucket>
+    <TargetPrefix>${this._loggingEnabled.TargetPrefix}</TargetPrefix>
+</LoggingEnabled>
+`;
+        }
+
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<BucketLoggingStatus xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+    ${loggingEnabledXML}
+</BucketLoggingStatus>
+`;
+    }
+
+    static async fromXML(
+        data: string,
+    ): Promise<{ error?: { arsenalError: ArsenalError, details: any }; res?: BucketLoggingStatus; }> {
+        let parsed;
+        try {
+            parsed = await parseStringPromise(data);
+        } catch (err) {
+            return {
+                error: { arsenalError: errors.MalformedXML, details: err },
+                res: undefined,
+            };
+        }
+
+        if (!parsed) {
+            return {
+                error: { arsenalError: errors.MalformedXML, details: 'request xml is undefined or empty' },
+                res: undefined,
+            };
+        }
+
+        if (!parsed.BucketLoggingStatus) {
+            return {
+                error: { arsenalError: errors.MalformedXML, details: 'missing BucketLoggingStatus root tag' },
+                res: undefined,
+            };
+        }
+
+        let loggingEnabled : LoggingEnabled | undefined = undefined; 
+        if (parsed.BucketLoggingStatus.LoggingEnabled) {
+            if (!parsed.BucketLoggingStatus.LoggingEnabled.TargetBucket) {
+                return {
+                    error: { arsenalError: errors.MalformedXML, details: 'missing TargetBucket tag in LoggingEnabled' },
+                    res: undefined,
+                };
+            }
+
+            if (!parsed.BucketLoggingStatus.LoggingEnabled.TargetPrefix) {
+                return {
+                    error: { arsenalError: errors.MalformedXML, details: 'missing TargetPrefix tag in LoggingEnabled' },
+                    res: undefined,
+                };
+            }
+
+            if (parsed.BuckerLoggingStatus.LoggingEnabled.TargetGrants) {
+                return {
+                    error: {
+                        arsenalError: errors.NotImplemented,
+                        details: 'TargetGrants tag in LoggingEnabled is not implemented',
+                    },
+                    res: undefined,
+                };
+            }
+
+            if (parsed.BuckerLoggingStatus.LoggingEnabled.TargetObjectKeyFormat) {
+                return {
+                    error: {
+                        arsenalError: errors.NotImplemented,
+                        details: 'TargetObjectKeyFormat tag in LoggingEnabled is not implemented',
+                    },
+                    res: undefined,
+                };
+            }
+
+            loggingEnabled = {
+                TargetPrefix: parsed.BucketLoggingStatus.LoggingEnabled.TargetPrefix[0],
+                TargetBucket: parsed.BucketLoggingStatus.LoggingEnabled.TargetBucket[0],
+            };
+        }
+
+        return {
+            error: undefined,
+            res: new BucketLoggingStatus(loggingEnabled),
+        };
+    }
+};