def test_az_deleted_object_replication():
""" test zone deleted object replication """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create object on the non archive zone
bucket = zones[0].create_bucket(bucket_name)
key = bucket.new_key("foo")
key.set_contents_from_string("bar")
p1 = key.get_contents_as_string() == "bar"
assert_equal(p1, True)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# update object on non archive zone
key.set_contents_from_string("soup")
p2 = key.get_contents_as_string() == "soup"
assert_equal(p2, True)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# delete object on non archive zone
key.delete()
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check object on non archive zone
p3 = check_key_exists(key) == False
assert_equal(p3, True)
# check objects on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
key_az = bucket_az.get_key("foo")
p4 = check_key_exists(key_az) == True
assert_equal(p4, True)
p5 = key_az.get_contents_as_string() == "soup"
assert_equal(p5, True)
b_ver_az = get_versioned_objs(bucket_az)
p6 = len(b_ver_az) == 2
assert_equal(p6, True)
def test_az_bucket_renaming_on_empty_bucket_deletion():
""" test bucket renaming on empty bucket deletion """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# grab number of buckets on non archive zone
num_buckets = get_number_buckets_by_zone(zones[0])
# grab number of buckets on archive zone
num_buckets_az = get_number_buckets_by_zone(az_zones[0])
# create bucket on non archive zone
bucket = zones[0].create_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# delete bucket in non archive zone
zones[0].delete_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check no new buckets on non archive zone
p1 = get_number_buckets_by_zone(zones[0]) == num_buckets
assert_equal(p1, True)
# check non deletion on bucket on archive zone
p2 = get_number_buckets_by_zone(az_zones[0]) == (num_buckets_az + 1)
assert_equal(p2, True)
# check bucket renaming
bucket_names_az = get_bucket_names_by_zone(az_zones[0])
new_bucket_name = bucket_name + '-deleted-'
p3 = any(bucket_name.startswith(new_bucket_name) for bucket_name in bucket_names_az)
assert_equal(p3, True)
def test_az_lazy_activation_of_versioned_bucket():
""" test lazy activation of versioned bucket """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create object on the non archive zone
bucket = zones[0].create_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# get bucket on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
# check for non bucket versioning
p1 = get_versioning_status(bucket) is None
assert_equal(p1, True)
p2 = get_versioning_status(bucket_az) is None
assert_equal(p2, True)
# create object on non archive zone
key = bucket.new_key("foo")
key.set_contents_from_string("bar")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check lazy versioned buckets
p3 = get_versioning_status(bucket) is None
assert_equal(p3, True)
p4 = get_versioning_status(bucket_az) == 'Enabled'
assert_equal(p4, True)
def test_az_object_replication_versioning():
""" test object replication versioning """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create object on the non archive zone
bucket = zones[0].create_bucket(bucket_name)
key = bucket.new_key("foo")
key.set_contents_from_string("bar")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check object content on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
key_az = bucket_az.get_key("foo")
p1 = key_az.get_contents_as_string() == "bar"
assert_equal(p1, True)
# grab object versioning and etag
for b_version in bucket.list_versions():
b_version_id = b_version.version_id
b_version_etag = b_version.etag
for b_az_version in bucket_az.list_versions():
b_az_version_id = b_az_version.version_id
b_az_version_etag = b_az_version.etag
# check
p2 = b_version_id == 'null'
assert_equal(p2, True)
p3 = b_az_version_id != 'null'
assert_equal(p3, True)
p4 = b_version_etag == b_az_version_etag
assert_equal(p4, True)
def test_az_create_empty_bucket():
""" test empty bucket replication """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create bucket on the non archive zone
zones[0].create_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# bucket exist on the archive zone
p = check_bucket_exists_on_zone(az_zones[0], bucket_name)
assert_equal(p, True)
def test_az_old_object_version_in_archive_zone():
""" test old object version in archive zone """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# grab number of buckets on non archive zone
num_buckets = get_number_buckets_by_zone(zones[0])
# grab number of buckets on archive zone
num_buckets_az = get_number_buckets_by_zone(az_zones[0])
# create bucket on non archive zone
bucket = zones[0].create_bucket(bucket_name)
# create object on non archive zone
key = bucket.new_key("foo")
key.set_contents_from_string("zero")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# save object version on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
b_ver_az = get_versioned_objs(bucket_az)
obj_az_version_id = b_ver_az[0]['foo']['version_id']
# update object on non archive zone
key.set_contents_from_string("one")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# delete object on non archive zone
key.delete()
# delete bucket on non archive zone
zones[0].delete_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check same buckets on non archive zone
p1 = get_number_buckets_by_zone(zones[0]) == num_buckets
assert_equal(p1, True)
# check for new bucket on archive zone
p2 = get_number_buckets_by_zone(az_zones[0]) == (num_buckets_az + 1)
assert_equal(p2, True)
# get new bucket name on archive zone
bucket_names_az = get_bucket_names_by_zone(az_zones[0])
new_bucket_name_az = get_full_bucket_name(bucket_name + '-deleted-', bucket_names_az)
p3 = new_bucket_name_az is not None
assert_equal(p3, True)
# check number of objects on archive zone
new_bucket_az = az_zones[0].conn.get_bucket(new_bucket_name_az)
new_b_ver_az = get_versioned_objs(new_bucket_az)
p4 = len(new_b_ver_az) == 2
assert_equal(p4, True)
# check versioned objects on archive zone
new_key_az = new_bucket_az.get_key("foo", version_id=obj_az_version_id)
p5 = new_key_az.get_contents_as_string() == "zero"
assert_equal(p5, True)
new_key_latest_az = new_bucket_az.get_key("foo")
p6 = new_key_latest_az.get_contents_as_string() == "one"
assert_equal(p6, True)
def test_az_archive_zone_double_object_replication_versioning():
""" test archive zone double object replication versioning """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create object on the non archive zone
bucket = zones[0].create_bucket(bucket_name)
key = bucket.new_key("foo")
key.set_contents_from_string("bar")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# get bucket on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
# check for non bucket versioning
p1 = get_versioning_status(bucket) is None
assert_equal(p1, True)
p2 = get_versioning_status(bucket_az) == 'Enabled'
assert_equal(p2, True)
# overwrite object on non archive zone
key = bucket.new_key("foo")
key.set_contents_from_string("ouch")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check lazy versioned buckets
p3 = get_versioning_status(bucket) is None
assert_equal(p3, True)
p4 = get_versioning_status(bucket_az) == 'Enabled'
assert_equal(p4, True)
# get versioned objects
objs = get_versioned_objs(bucket)
objs_az = get_versioned_objs(bucket_az)
# check version_id, size, and is_latest on non archive zone
p5 = objs[0]['foo']['version_id'] == 'null'
assert_equal(p5, True)
p6 = objs[0]['foo']['size'] == 4
assert_equal(p6, True)
p7 = objs[0]['foo']['is_latest'] == True
assert_equal(p7, True)
# check version_id, size, is_latest on archive zone
latest_obj_az_etag = None
for obj_az in objs_az:
current_obj_az = obj_az['foo']
if current_obj_az['is_latest'] == True:
p8 = current_obj_az['size'] == 4
assert_equal(p8, True)
latest_obj_az_etag = current_obj_az['etag']
else:
p9 = current_obj_az['size'] == 3
assert_equal(p9, True)
assert_not_equal(current_obj_az['version_id'], 'null')
# check last versions' etags
p10 = objs[0]['foo']['etag'] == latest_obj_az_etag
assert_equal(p10, True)
def test_az_object_replication():
""" test object replication """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create bucket on the non archive zone
bucket = zones[0].create_bucket(bucket_name)
key = bucket.new_key("foo")
key.set_contents_from_string("bar")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check object on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
key_az = bucket_az.get_key("foo")
p1 = key_az.get_contents_as_string() == "bar"
assert_equal(p1, True)
def test_az_check_empty_bucket_versioning():
""" test bucket vesioning with empty bucket """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create bucket on the non archive zone
bucket = zones[0].create_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# get bucket on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
# check for non bucket versioning
p1 = get_versioning_status(bucket) is None
assert_equal(p1, True)
p2 = get_versioning_status(bucket_az) is None
assert_equal(p2, True)
def test_az_force_bucket_renaming_if_same_bucket_name():
""" test force bucket renaming if same bucket name """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# grab number of buckets on non archive zone
num_buckets = get_number_buckets_by_zone(zones[0])
# grab number of buckets on archive zone
num_buckets_az = get_number_buckets_by_zone(az_zones[0])
# create bucket on non archive zone
bucket = zones[0].create_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check same buckets on non archive zone
p1 = get_number_buckets_by_zone(zones[0]) == (num_buckets + 1)
assert_equal(p1, True)
# check for new bucket on archive zone
p2 = get_number_buckets_by_zone(az_zones[0]) == (num_buckets_az + 1)
assert_equal(p2, True)
# delete bucket on non archive zone
zones[0].delete_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check number of buckets on non archive zone
p3 = get_number_buckets_by_zone(zones[0]) == num_buckets
assert_equal(p3, True)
# check number of buckets on archive zone
p4 = get_number_buckets_by_zone(az_zones[0]) == (num_buckets_az + 1)
assert_equal(p4, True)
# get new bucket name on archive zone
bucket_names_az = get_bucket_names_by_zone(az_zones[0])
new_bucket_name_az = get_full_bucket_name(bucket_name + '-deleted-', bucket_names_az)
p5 = new_bucket_name_az is not None
assert_equal(p5, True)
# create bucket on non archive zone
_ = zones[0].create_bucket(new_bucket_name_az)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check number of buckets on non archive zone
p6 = get_number_buckets_by_zone(zones[0]) == (num_buckets + 1)
assert_equal(p6, True)
# check number of buckets on archive zone
p7 = get_number_buckets_by_zone(az_zones[0]) == (num_buckets_az + 2)
assert_equal(p7, True)
def test_az_info():
""" log information for manual testing """
return SkipTest("only used in manual testing")
zones, az_zones = init_env()
realm = get_realm()
zonegroup = realm.master_zonegroup()
bucket_name = gen_bucket_name()
# create bucket on the first of the rados zones
bucket = zones[0].create_bucket(bucket_name)
# create objects in the bucket
number_of_objects = 3
for i in range(number_of_objects):
key = bucket.new_key(str(i))
key.set_contents_from_string('bar')
print('Zonegroup: ' + zonegroup.name)
print('user: '******'tenant: ' + get_tenant())
print('Master Zone')
print_connection_info(zones[0].conn)
print('Archive Zone')
print_connection_info(az_zones[0].conn)
print('Bucket: ' + bucket_name)
def test_az_versioning_support_in_zones():
""" test versioning support on zones """
zones, az_zones = init_env()
bucket_name = gen_bucket_name()
# create bucket on non archive zone
bucket = zones[0].create_bucket(bucket_name)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# get bucket on archive zone
bucket_az = az_zones[0].conn.get_bucket(bucket_name)
# check non versioned buckets
p1 = get_versioning_status(bucket) is None
assert_equal(p1, True)
p2 = get_versioning_status(bucket_az) is None
assert_equal(p2, True)
# create object on non archive zone
key = bucket.new_key("foo")
key.set_contents_from_string("zero")
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check bucket versioning
p3 = get_versioning_status(bucket) is None
assert_equal(p3, True)
p4 = get_versioning_status(bucket_az) == 'Enabled'
assert_equal(p4, True)
# enable bucket versioning on non archive zone
bucket.configure_versioning(True)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check bucket versioning
p5 = get_versioning_status(bucket) == 'Enabled'
assert_equal(p5, True)
p6 = get_versioning_status(bucket_az) == 'Enabled'
assert_equal(p6, True)
# delete object on non archive zone
key.delete()
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check delete-markers and versions on non archive zone
(b_dm, b_ver) = get_versioned_entries(bucket)
p7 = len(b_dm) == 1
assert_equal(p7, True)
p8 = len(b_ver) == 1
assert_equal(p8, True)
# check delete-markers and versions on archive zone
(b_dm_az, b_ver_az) = get_versioned_entries(bucket_az)
p9 = len(b_dm_az) == 1
assert_equal(p9, True)
p10 = len(b_ver_az) == 1
assert_equal(p10, True)
# delete delete-marker on non archive zone
dm_version_id = b_dm[0]['foo']['version_id']
bucket.delete_key("foo", version_id=dm_version_id)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check delete-markers and versions on non archive zone
(b_dm, b_ver) = get_versioned_entries(bucket)
p11 = len(b_dm) == 0
assert_equal(p11, True)
p12 = len(b_ver) == 1
assert_equal(p12, True)
# check delete-markers and versions on archive zone
(b_dm_az, b_ver_az) = get_versioned_entries(bucket_az)
p13 = len(b_dm_az) == 1
assert_equal(p13, True)
p14 = len(b_ver_az) == 1
assert_equal(p14, True)
# delete delete-marker on archive zone
dm_az_version_id = b_dm_az[0]['foo']['version_id']
bucket_az.delete_key("foo", version_id=dm_az_version_id)
# sync
zone_full_checkpoint(az_zones[0].zone, zones[0].zone)
# check delete-markers and versions on non archive zone
(b_dm, b_ver) = get_versioned_entries(bucket)
p15 = len(b_dm) == 0
assert_equal(p15, True)
p16 = len(b_ver) == 1
assert_equal(p16, True)
# check delete-markers and versions on archive zone
(b_dm_az, b_ver_az) = get_versioned_entries(bucket_az)
p17 = len(b_dm_az) == 0
assert_equal(p17, True)
p17 = len(b_ver_az) == 1
assert_equal(p17, True)
# check body in zones
obj_version_id = b_ver[0]['foo']['version_id']
key = bucket.get_key("foo", version_id=obj_version_id)
p18 = key.get_contents_as_string() == "zero"
assert_equal(p18, True)
obj_az_version_id = b_ver_az[0]['foo']['version_id']
key_az = bucket_az.get_key("foo", version_id=obj_az_version_id)
p19 = key_az.get_contents_as_string() == "zero"
assert_equal(p19, True)