Merge branch 'bugfix/BB-722' into w/9.0/bugfix/BB-722

Author: francoisferrand

extensions/lifecycle/tasks/LifecycleTask.js

@@ -1649,7 +1649,7 @@ class LifecycleTask extends BackbeatTask {
             return done();
         }
 
-        if (rules.NoncurrentVersionTransition) {
+        if (rules.NoncurrentVersionTransition && !this._isDeleteMarker(version)) {
             return this._checkAndApplyNCVTransitionRule(bucketData, version, rules, log, done);
         }
 

extensions/lifecycle/tasks/LifecycleTaskV2.js

@@ -338,7 +338,7 @@ class LifecycleTaskV2 extends LifecycleTask {
             this._checkAndApplyExpirationRule(bucketData, obj, rules, log)) {
             return process.nextTick(cb);
         }
-        if (rules.Transition) {
+        if (rules.Transition && !this._isDeleteMarker(obj)) {
             return this._applyTransitionRule({
                 owner: bucketData.target.owner,
                 accountId: bucketData.target.accountId,
@@ -384,7 +384,7 @@ class LifecycleTaskV2 extends LifecycleTask {
             return process.nextTick(cb);
         }
 
-        if (rules.NoncurrentVersionTransition) {
+        if (rules.NoncurrentVersionTransition && !this._isDeleteMarker(obj)) {
             return this._checkAndApplyNCVTransitionRule(bucketData, obj, rules, log, cb);
         }
 

tests/functional/lifecycle/LifecycleTask.js

@@ -1869,6 +1869,48 @@ describe('lifecycle task functional tests', function dF() {
                 });
             });
         });
+
+        it('should not transition a non-current delete marker with NoncurrentVersionTransition rule', done => {
+            const bucket = 'test-bucket';
+            const keyName = 'test-key';
+            const bucketEntry = {
+                action: 'testing-noncurrent-transition',
+                target: {
+                    bucket,
+                    owner: OWNER,
+                },
+                details: {},
+            };
+            const params = {
+                lcTask,
+                lcp,
+                counter: 0,
+            };
+            async.waterfall([
+                next => s3Helper.setAndCreateBucket(bucket, next),
+                next => s3Helper.setBucketVersioning('Enabled', next),
+                (data, next) => s3.putObject({ Bucket: bucket, Key: keyName, Body: 'test-content' }, next),
+                (data, next) => s3.deleteObject({ Bucket: bucket, Key: keyName }, next),
+                (data, next) => s3.putObject({ Bucket: bucket, Key: keyName, Body: 'new-content' }, next),
+                (data, next) => s3Helper.setBucketLifecycleConfigurations([
+                    new LifecycleRule().addID('task-1').addNCVTransitions([{
+                        NoncurrentDays: 0,
+                        StorageClass: 'us-east-2',
+                    }]).build(),
+                ], next),
+                (data, next) => s3.getBucketLifecycleConfiguration({ Bucket: bucket }, next),
+                (data, next) => wrapProcessBucketEntry(data.Rules, bucketEntry, s3, params, (err, data) => {
+                    assert.ifError(err);
+
+                    assertTransitionResult({ data, expectedKeys: [] });
+
+                    next();
+                }),
+            ], err => {
+                assert.ifError(err);
+                done();
+            });
+        });
     }); // end versioned describe block
 
     describe('incomplete mpu objects', () => {

tests/functional/lifecycle/LifecycleTaskV2-versioned.js

@@ -427,6 +427,46 @@ describe('LifecycleTaskV2 with bucket versioned', () => {
         });
     });
 
+    it('should not publish any object entry if object is a non-current delete marker with NCVT rule', done => {
+        const transitionRule = [
+            {
+                NoncurrentVersionTransitions: [{ NoncurrentDays: 2, StorageClass: destinationLocation }],
+                ID: '123',
+                Prefix: '',
+                Status: 'Enabled',
+            }
+        ];
+        const keyName = 'key1';
+        const versionId = 'versionid1';
+        // Create a delete marker (no ETag, no Size, no StorageClass)
+        const deleteMarker = keyMock.nonCurrent({ keyName, versionId, daysEarlier: 2 });
+        delete deleteMarker.ETag;
+        delete deleteMarker.Size;
+        delete deleteMarker.StorageClass;
+
+        const contents = [deleteMarker];
+        backbeatMetadataProxy.listLifecycleResponse = { contents, isTruncated: false, markerInfo: {} };
+
+        const nbRetries = 0;
+        return lifecycleTask.processBucketEntry(transitionRule, bucketData, s3,
+            backbeatMetadataProxy, nbRetries, err => {
+                assert.ifError(err);
+                // test that the non-current listing is triggered
+                assert.strictEqual(backbeatMetadataProxy.listLifecycleType, 'noncurrent');
+
+                // test parameters used to list lifecycle keys
+                const { listLifecycleParams } = backbeatMetadataProxy;
+                assert.strictEqual(listLifecycleParams.Bucket, bucketName);
+                assert.strictEqual(listLifecycleParams.Prefix, '');
+                assert(!!listLifecycleParams.BeforeDate);
+                assert.strictEqual(listLifecycleParams.ExcludedDataStoreName, destinationLocation);
+
+                // test that no entries are pushed to kafka topic (delete markers cannot be transitioned)
+                assert.strictEqual(kafkaEntries.length, 0);
+                return done();
+            });
+    });
+
     it('should publish one bucket entry to list orphan delete markers if Expiration rule is set', done => {
         const expirationRule = [
             {
@@ -464,6 +504,45 @@ describe('LifecycleTaskV2 with bucket versioned', () => {
         });
     });
 
+    it('should not publish any object entry if object is a delete marker if Transition rule is set', done => {
+        const transitionRule = [
+            {
+                Transitions: [{ Days: 2, StorageClass: destinationLocation }],
+                ID: '123',
+                Prefix: '',
+                Status: 'Enabled',
+            }
+        ];
+        const keyName = 'key1';
+        // Create a delete marker (no ETag, no StorageClass properties)
+        const deleteMarker = keyMock.current({ keyName, daysEarlier: 2 });
+        delete deleteMarker.ETag;
+        delete deleteMarker.Size;
+        delete deleteMarker.StorageClass;
+
+        const contents = [deleteMarker];
+        backbeatMetadataProxy.listLifecycleResponse = { contents, isTruncated: false, markerInfo: {} };
+
+        const nbRetries = 0;
+        return lifecycleTask.processBucketEntry(
+            transitionRule, bucketData, s3, backbeatMetadataProxy, nbRetries, err => {
+                assert.ifError(err);
+                // test that the current listing is triggered
+                assert.strictEqual(backbeatMetadataProxy.listLifecycleType, 'current');
+
+                // test parameters used to list lifecycle keys
+                const { listLifecycleParams } = backbeatMetadataProxy;
+                assert.strictEqual(listLifecycleParams.Bucket, bucketName);
+                assert.strictEqual(listLifecycleParams.Prefix, '');
+                assert(!!listLifecycleParams.BeforeDate);
+                assert.strictEqual(listLifecycleParams.ExcludedDataStoreName, destinationLocation);
+
+            // test that no entries are pushed to kafka topic (delete markers cannot be transitioned)
+            assert.strictEqual(kafkaEntries.length, 0);
+            return done();
+        });
+    });
+
     it('should publish one object entry if object is eligible with Transitions rule', done => {
         const transitionRule = [
             {

tests/functional/lifecycle/LifecycleTaskV2.js

@@ -613,6 +613,46 @@ describe('LifecycleTaskV2 with bucket non-versioned', () => {
         });
     });
 
+    it('should not publish any object entry if object is a delete marker with Transitions rule', done => {
+        const transitionRule = [
+            {
+                Transitions: [{ Days: 2, StorageClass: destinationLocation }],
+                ID: '123',
+                Prefix: '',
+                Status: 'Enabled',
+            }
+        ];
+
+        const keyName = 'key1';
+        // Create a delete marker (no ETag, no StorageClass properties)
+        const deleteMarker = keyMock.current({ keyName, daysEarlier: 2 });
+        delete deleteMarker.ETag;
+        delete deleteMarker.Size;
+        delete deleteMarker.StorageClass;
+
+        const contents = [deleteMarker];
+        backbeatMetadataProxy.listLifecycleResponse = { contents, isTruncated: false, markerInfo: {} };
+
+        const nbRetries = 0;
+        return lifecycleTask.processBucketEntry(
+            transitionRule, bucketData, s3, backbeatMetadataProxy, nbRetries, err => {
+                assert.ifError(err);
+                // test that the current listing is triggered
+                assert.strictEqual(backbeatMetadataProxy.listLifecycleType, 'current');
+
+                // test parameters used to list lifecycle keys
+                const { listLifecycleParams } = backbeatMetadataProxy;
+                assert.strictEqual(listLifecycleParams.Bucket, bucketName);
+                assert.strictEqual(listLifecycleParams.Prefix, '');
+                assert.strictEqual(listLifecycleParams.ExcludedDataStoreName, destinationLocation);
+                assert(!!listLifecycleParams.BeforeDate);
+
+                // test that no entry is pushed to kafka topic (delete markers cannot be transitioned)
+                assert.strictEqual(kafkaEntries.length, 0);
+                return done();
+            });
+    });
+
     it('should publish one bucket entry if listing is truncated', done => {
         const keyName = 'key1';
         const key = keyMock.current({ keyName, daysEarlier: 1 });