Merge pull request ceph#62637 from smanjara/wip-rgw-revert-62323

rgw/multisite: revert pr 62323

Reviewed-by: Casey Bodley <[email protected]>

Author: cbodley

src/rgw/driver/rados/rgw_data_sync.cc

@@ -4520,20 +4520,6 @@ class RGWBucketSyncSingleEntryCR : public RGWCoroutine {
             tn->log(0, "entry with empty obj name, skipping");
             goto done;
           }
-
-          // make sure versioned object only lands on versioned bucket and non-versioned object only lands on non-versioned bucket
-          if (key.instance.empty() == sync_pipe.dest_bucket_info.versioned()) {
-            set_status("skipping entry due to versioning mismatch");
-            tn->log(0, SSTR("skipping entry due to versioning mismatch: " << key));
-            goto done;
-          }
-          // if object lock is enabled on either, the other should follow as well
-          if (sync_pipe.source_bucket_info.obj_lock_enabled() != sync_pipe.dest_bucket_info.obj_lock_enabled()) {
-            set_status("skipping entry due to object lock mismatch");
-            tn->log(0, SSTR("skipping entry due to object lock mismatch: " << key));
-            goto done;
-          }
-
           if (error_injection &&
               rand() % 10000 < cct->_conf->rgw_sync_data_inject_err_probability * 10000.0) {
             tn->log(0, SSTR(": injecting data sync error on key=" << key.name));

src/rgw/rgw_rest_s3.cc

@@ -1356,28 +1356,6 @@ struct ReplicationConfiguration {
       }
       pipe->dest.bucket.emplace(dest_bk);
 
-      std::unique_ptr<rgw::sal::Bucket> dest_bucket;
-      if (int r = driver->load_bucket(s, *pipe->dest.bucket, &dest_bucket, s->yield); r < 0) {
-        if (r == -ENOENT) {
-          s->err.message = "Destination bucket must exist.";
-          return -EINVAL;
-        }
-
-        ldpp_dout(s, 0) << "ERROR: failed to load bucket info for bucket=" << *pipe->dest.bucket << " r=" << r << dendl;
-        return r;
-      }
-
-      // check versioning identicality
-      if (dest_bucket->get_info().versioned() != s->bucket->get_info().versioned()) {
-        s->err.message = "Versioning must be identical in source and destination buckets.";
-        return -EINVAL;
-      }
-      // check object lock identicality
-      if (dest_bucket->get_info().obj_lock_enabled() != s->bucket->get_info().obj_lock_enabled()) {
-        s->err.message = "Object lock must be identical in source and destination buckets.";
-        return -EINVAL;
-      }
-
       if (filter) {
         int r = filter->to_sync_pipe_filter(s->cct, &pipe->params.source.filter);
         if (r < 0) {

src/test/rgw/rgw_multi/tests.py

@@ -3916,288 +3916,3 @@ def test_bucket_replication_alt_user():
     # check that object exists in destination bucket
     k = get_key(dest, dest_bucket, objname)
     assert_equal(k.get_contents_as_string().decode('utf-8'), 'foo')
-
-@allow_bucket_replication
-def test_bucket_replication_reject_versioning_identical():
-    zonegroup = realm.master_zonegroup()
-    zonegroup_conns = ZonegroupConns(zonegroup)
-
-    source = zonegroup_conns.non_account_rw_zones[0]
-    dest = zonegroup_conns.non_account_rw_zones[1]
-
-    source_bucket = source.create_bucket(gen_bucket_name())
-    dest_bucket = dest.create_bucket(gen_bucket_name())
-    source.s3_client.put_bucket_versioning(
-        Bucket=source_bucket.name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # create replication configuration
-    e = assert_raises(ClientError,
-                      source.s3_client.put_bucket_replication,
-                      Bucket=source_bucket.name,
-                      ReplicationConfiguration={
-                          'Role': '',
-                          'Rules': [{
-                              'ID': 'rule1',
-                              'Status': 'Enabled',
-                              'Destination': {
-                                  'Bucket': f'arn:aws:s3:::{dest_bucket.name}',
-                              }
-                          }]
-                      })
-    assert e.response['ResponseMetadata']['HTTPStatusCode'] == 400
-
-@allow_bucket_replication
-def test_bucket_replicaion_reject_objectlock_identical():
-    zonegroup = realm.master_zonegroup()
-    zonegroup_conns = ZonegroupConns(zonegroup)
-
-    source = zonegroup_conns.non_account_rw_zones[0]
-    dest = zonegroup_conns.non_account_rw_zones[1]
-
-    source_bucket = source.create_bucket(gen_bucket_name())
-    dest_bucket_name = gen_bucket_name()
-    dest.s3_client.create_bucket(Bucket=dest_bucket_name, ObjectLockEnabledForBucket=True)
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # create replication configuration
-    e = assert_raises(ClientError,
-                      source.s3_client.put_bucket_replication,
-                      Bucket=source_bucket.name,
-                      ReplicationConfiguration={
-                          'Role': '',
-                          'Rules': [{
-                              'ID': 'rule1',
-                              'Status': 'Enabled',
-                              'Destination': {
-                                  'Bucket': f'arn:aws:s3:::{dest_bucket_name}',
-                              }
-                          }]
-                      })
-    assert e.response['ResponseMetadata']['HTTPStatusCode'] == 400
-
-@allow_bucket_replication
-def test_bucket_replication_non_versioned_to_versioned():
-    zonegroup = realm.master_zonegroup()
-    zonegroup_conns = ZonegroupConns(zonegroup)
-
-    source = zonegroup_conns.non_account_rw_zones[0]
-    dest = zonegroup_conns.non_account_rw_zones[1]
-
-    source_bucket = source.create_bucket(gen_bucket_name())
-    dest_bucket = dest.create_bucket(gen_bucket_name())
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # create replication configuration
-    response = source.s3_client.put_bucket_replication(
-        Bucket=source_bucket.name,
-        ReplicationConfiguration={
-            'Role': '',
-            'Rules': [
-                {
-                    'ID': 'rule1',
-                    'Status': 'Enabled',
-                    'Destination': {
-                        'Bucket': f'arn:aws:s3:::{dest_bucket.name}',
-                    }
-                }
-            ]
-        }
-    )
-    assert response['ResponseMetadata']['HTTPStatusCode'] == 200
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # enable versioning on destination bucket
-    dest.s3_client.put_bucket_versioning(
-        Bucket=dest_bucket.name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # upload an object and wait for sync.
-    objname = 'dummy'
-    k = new_key(source, source_bucket, objname)
-    k.set_contents_from_string('foo')
-    zone_data_checkpoint(dest.zone, source.zone)
-
-    # check that object not exists in destination bucket
-    e = assert_raises(ClientError, dest.s3_client.get_object, Bucket=dest_bucket.name, Key=objname)
-    assert e.response['Error']['Code'] == 'NoSuchKey'
-
-@allow_bucket_replication
-def test_bucket_replication_versioned_to_non_versioned():
-    zonegroup = realm.master_zonegroup()
-    zonegroup_conns = ZonegroupConns(zonegroup)
-
-    source = zonegroup_conns.non_account_rw_zones[0]
-    dest = zonegroup_conns.non_account_rw_zones[1]
-
-    source_bucket = source.create_bucket(gen_bucket_name())
-    dest_bucket = dest.create_bucket(gen_bucket_name())
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # create replication configuration
-    response = source.s3_client.put_bucket_replication(
-        Bucket=source_bucket.name,
-        ReplicationConfiguration={
-            'Role': '',
-            'Rules': [
-                {
-                    'ID': 'rule1',
-                    'Status': 'Enabled',
-                    'Destination': {
-                        'Bucket': f'arn:aws:s3:::{dest_bucket.name}',
-                    }
-                }
-            ]
-        }
-    )
-    assert response['ResponseMetadata']['HTTPStatusCode'] == 200
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # enable versioning on source bucket
-    source.s3_client.put_bucket_versioning(
-        Bucket=source_bucket.name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # upload an object and wait for sync.
-    objname = 'dummy'
-    k = new_key(source, source_bucket, objname)
-    k.set_contents_from_string('foo')
-    zone_data_checkpoint(dest.zone, source.zone)
-
-    # check that object not exists in destination bucket
-    e = assert_raises(ClientError, dest.s3_client.get_object, Bucket=dest_bucket.name, Key=objname)
-    assert e.response['Error']['Code'] == 'NoSuchKey'
-
-@allow_bucket_replication
-def test_bucket_replication_lock_enabled_to_lock_disabled():
-    zonegroup = realm.master_zonegroup()
-    zonegroup_conns = ZonegroupConns(zonegroup)
-
-    source = zonegroup_conns.non_account_rw_zones[0]
-    dest = zonegroup_conns.non_account_rw_zones[1]
-
-    source_bucket_name = gen_bucket_name()
-    source.create_bucket(source_bucket_name)
-    # enabled versioning
-    source.s3_client.put_bucket_versioning(
-        Bucket=source_bucket_name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    dest_bucket = dest.create_bucket(gen_bucket_name())
-    # enabled versioning
-    dest.s3_client.put_bucket_versioning(
-        Bucket=dest_bucket.name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # create replication configuration
-    source.s3_client.put_bucket_replication(
-        Bucket=source_bucket_name,
-        ReplicationConfiguration={
-            'Role': '',
-            'Rules': [{
-                'ID': 'rule1',
-                'Status': 'Enabled',
-                'Destination': {
-                    'Bucket': f'arn:aws:s3:::{dest_bucket.name}',
-                }
-            }]
-        }
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # enable object lock on source bucket
-    source.s3_client.put_object_lock_configuration(
-        Bucket=source_bucket_name,
-        ObjectLockConfiguration={
-            'ObjectLockEnabled': 'Enabled',
-            'Rule': {
-                'DefaultRetention': {
-                    'Mode': 'GOVERNANCE',
-                    'Days': 1
-                }
-            }
-        }
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # upload an object and wait for sync.
-    objname = 'dummy'
-    k = new_key(source, source_bucket_name, objname)
-    k.set_contents_from_string('foo')
-    zone_data_checkpoint(dest.zone, source.zone)
-
-    # check that object does not exist in destination bucket
-    e = assert_raises(ClientError, dest.s3_client.get_object, Bucket=dest_bucket.name, Key=objname)
-    assert e.response['Error']['Code'] == 'NoSuchKey'
-
-@allow_bucket_replication
-def test_bucket_replication_lock_disabled_to_lock_enabled():
-    zonegroup = realm.master_zonegroup()
-    zonegroup_conns = ZonegroupConns(zonegroup)
-
-    source = zonegroup_conns.non_account_rw_zones[0]
-    dest = zonegroup_conns.non_account_rw_zones[1]
-
-    source_bucket = source.create_bucket(gen_bucket_name())
-    # enabled versioning
-    source.s3_client.put_bucket_versioning(
-        Bucket=source_bucket.name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    dest_bucket_name = gen_bucket_name()
-    dest.create_bucket(dest_bucket_name)
-    # enabled versioning
-    dest.s3_client.put_bucket_versioning(
-        Bucket=dest_bucket_name,
-        VersioningConfiguration={'Status': 'Enabled'}
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # create replication configuration
-    source.s3_client.put_bucket_replication(
-        Bucket=source_bucket.name,
-        ReplicationConfiguration={
-            'Role': '',
-            'Rules': [{
-                'ID': 'rule1',
-                'Status': 'Enabled',
-                'Destination': {
-                    'Bucket': f'arn:aws:s3:::{dest_bucket_name}',
-                }
-            }]
-        }
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # enable object lock on destination bucket
-    dest.s3_client.put_object_lock_configuration(
-        Bucket=dest_bucket_name,
-        ObjectLockConfiguration={
-            'ObjectLockEnabled': 'Enabled',
-            'Rule': {
-                'DefaultRetention': {
-                    'Mode': 'GOVERNANCE',
-                    'Days': 1
-                }
-            }
-        }
-    )
-    zonegroup_meta_checkpoint(zonegroup)
-
-    # upload an object and wait for sync.
-    objname = 'dummy'
-    k = new_key(source, source_bucket.name, objname)
-    k.set_contents_from_string('foo')
-    zone_data_checkpoint(dest.zone, source.zone)
-
-    # check that object does not exist in destination bucket
-    e = assert_raises(ClientError, dest.s3_client.get_object, Bucket=dest_bucket_name, Key=objname)
-    assert e.response['Error']['Code'] == 'NoSuchKey'