Merge pull request #8481 from dannyzaken/danny-fixes

lifecycle fixes

Author: dannyzaken

src/endpoint/s3/ops/s3_get_bucket_lifecycle.js

@@ -47,6 +47,7 @@ async function get_bucket_lifecycle(req) {
             current_rule.Expiration = {
                 Days: rule.expiration.days,
                 Date: rule.expiration.date ? new Date(rule.expiration.date).toISOString() : undefined,
+                ExpiredObjectDeleteMarker: rule.expiration.expired_object_delete_marker,
             };
             _.omitBy(current_rule.Expiration, _.isUndefined);
         }

src/endpoint/s3/ops/s3_put_bucket_lifecycle.js

@@ -46,6 +46,13 @@ function parse_filter(filter) {
     return current_rule_filter;
 }
 
+function reject_empty_field(field) {
+    if (_.isEmpty(field)) {
+        dbg.error('Invalid field - empty', field);
+        throw new S3Error(S3Error.MalformedXML);
+    }
+}
+
 // parse lifecycle rule expiration
 function parse_expiration(expiration) {
     const output_expiration = {};
@@ -111,12 +118,14 @@ async function put_bucket_lifecycle(req) {
 
         if (rule.Expiration?.length === 1) {
             current_rule.expiration = parse_expiration(rule.Expiration[0]);
+            reject_empty_field(current_rule.expiration);
         }
 
         if (rule.AbortIncompleteMultipartUpload?.length === 1) {
             current_rule.abort_incomplete_multipart_upload = _.omitBy({
                 days_after_initiation: parse_lifecycle_field(rule.AbortIncompleteMultipartUpload[0].DaysAfterInitiation),
             }, _.isUndefined);
+            reject_empty_field(current_rule.abort_incomplete_multipart_upload);
         }
 
         if (rule.Transition?.length === 1) {
@@ -125,13 +134,15 @@ async function put_bucket_lifecycle(req) {
                 date: parse_lifecycle_field(rule.Transition[0].Date, s => new Date(s)),
                 days: parse_lifecycle_field(rule.Transition[0].Days),
             }, _.isUndefined);
+            reject_empty_field(current_rule.transition);
         }
 
         if (rule.NoncurrentVersionExpiration?.length === 1) {
             current_rule.noncurrent_version_expiration = _.omitBy({
                 noncurrent_days: parse_lifecycle_field(rule.NoncurrentVersionExpiration[0].NoncurrentDays),
                 newer_noncurrent_versions: parse_lifecycle_field(rule.NoncurrentVersionExpiration[0].NewerNoncurrentVersions),
             }, _.isUndefined);
+            reject_empty_field(current_rule.noncurrent_version_expiration);
         }
 
         if (rule.NoncurrentVersionTransition?.length === 1) {
@@ -140,6 +151,7 @@ async function put_bucket_lifecycle(req) {
                 noncurrent_days: parse_lifecycle_field(rule.NoncurrentVersionTransition[0].NoncurrentDays),
                 newer_noncurrent_versions: parse_lifecycle_field(rule.NoncurrentVersionTransition[0].NewerNoncurrentVersions),
             }, _.isUndefined);
+            reject_empty_field(current_rule.noncurrent_version_transition);
         }
 
         return current_rule;

src/test/unit_tests/test_s3_ops.js

@@ -403,6 +403,57 @@ mocha.describe('s3_ops', function() {
                 assert.strictEqual(res.Rules[0].NoncurrentVersionExpiration.NoncurrentDays, 1);
             });
 
+            mocha.it('should put and get bucket lifecycle with expired object delete marker', async function() {
+                // put bucket lifecycle
+                const params = {
+                    Bucket: "lifecycle-bucket",
+                    LifecycleConfiguration: {
+                        Rules: [{
+                            ID: 'rule1',
+                            Status: 'Enabled',
+                            Prefix: 'prefix1-expired-object-delete-marker',
+                            Expiration: {
+                                ExpiredObjectDeleteMarker: true
+                            }
+                        }]
+                    }
+                };
+                await s3.putBucketLifecycleConfiguration(params);
+
+                // get bucket lifecycle
+                const res = await s3.getBucketLifecycleConfiguration({ Bucket: "lifecycle-bucket" });
+                assert.strictEqual(res.Rules.length, 1);
+                assert.strictEqual(res.Rules[0].ID, 'rule1');
+                assert.strictEqual(res.Rules[0].Status, 'Enabled');
+                assert.strictEqual(res.Rules[0].Prefix, 'prefix1-expired-object-delete-marker');
+                assert.strictEqual(res.Rules[0].Expiration.ExpiredObjectDeleteMarker, true);
+            });
+
+            mocha.it('should reject put bucket lifecycle with empty fields', async function() {
+                const lifecycle_fields = ['Expiration', 'NoncurrentVersionExpiration', 'AbortIncompleteMultipartUpload'];
+                for (const field of lifecycle_fields) {
+                    const params = {
+                        Bucket: "lifecycle-bucket",
+                        LifecycleConfiguration: {
+                            Rules: [{
+                                ID: 'rule1',
+                                Status: 'Enabled',
+                                Prefix: `prefix1-empty-${field}`,
+                            }]
+                        }
+                    };
+                    params.LifecycleConfiguration.Rules[0][field] = {};
+                    try {
+                        await s3.putBucketLifecycleConfiguration(params);
+                        assert.fail(`should reject put bucket lifecycle with empty ${field}`);
+                    } catch (err) {
+                        assert.strictEqual(err.Code, 'MalformedXML', `should reject put bucket lifecycle with empty ${field}`);
+                        assert.strictEqual(err.$metadata.httpStatusCode, 400);
+                    }
+                }
+            });
+
+
             mocha.after(async function() {
                 await s3.deleteBucket({ Bucket: "lifecycle-bucket" });
             });