def test_lifecycle_without_versioning(self):
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-lifecycle-without-versioning"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
rule1 = LifecycleRule('rule1',
'tests/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=3))
rule2 = LifecycleRule(
'rule2',
'logging-',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(
created_before_date=datetime.date(2020, 12, 12)))
rule3 = LifecycleRule(
'rule3',
'tests1/',
status=LifecycleRule.ENABLED,
abort_multipart_upload=AbortMultipartUpload(days=3))
rule4 = LifecycleRule(
'rule4',
'logging1-',
status=LifecycleRule.ENABLED,
abort_multipart_upload=AbortMultipartUpload(
created_before_date=datetime.date(2020, 12, 12)))
tagging_rule = TaggingRule()
tagging_rule.add('test_key1', 'test_value1')
tagging_rule.add('test_key2', 'test_value2')
tagging = Tagging(tagging_rule)
rule5 = LifecycleRule(
'rule5',
'logging2-',
status=LifecycleRule.ENABLED,
storage_transitions=[
StorageTransition(days=100,
storage_class=oss2.BUCKET_STORAGE_CLASS_IA),
StorageTransition(
days=356, storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)
],
tagging=tagging)
lifecycle = BucketLifecycle([rule1, rule2, rule3, rule4, rule5])
bucket.put_bucket_lifecycle(lifecycle)
lifecycle = bucket.get_bucket_lifecycle()
self.assertEquals(5, len(lifecycle.rules))
bucket.delete_bucket()
def test_lifecycle_veriong_wrong(self):
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-lifecycle-versioning-wrong"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
# days and expired_detete_marker cannot both exsit.
self.assertRaises(oss2.exceptions.ClientError,
LifecycleExpiration,
days=10,
expired_detete_marker=True)
rule = LifecycleRule(
'rule1',
'test-prefix',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(expired_detete_marker=True),
noncurrent_version_expiration=NoncurrentVersionExpiration(30),
noncurrent_version_sotrage_transitions=[
NoncurrentVersionStorageTransition(
20, oss2.BUCKET_STORAGE_CLASS_IA),
NoncurrentVersionStorageTransition(
12, oss2.BUCKET_STORAGE_CLASS_ARCHIVE)
])
lifecycle = BucketLifecycle([rule])
# Archive transition days < IA transition days
self.assertRaises(oss2.exceptions.InvalidArgument,
bucket.put_bucket_lifecycle, lifecycle)
bucket.delete_bucket()
def test_lifecycle_all(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, AbortMultipartUpload, StorageTransition
rule = LifecycleRule(random_string(10), '中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=357))
self.assertRaises(oss2.exceptions.ClientError,
LifecycleExpiration, days=356, created_before_date=datetime.date(2016, 12, 25))
self.assertRaises(oss2.exceptions.ClientError,
AbortMultipartUpload, days=356, created_before_date=datetime.date(2016, 12, 25))
self.assertRaises(oss2.exceptions.ClientError,
StorageTransition, days=356, created_before_date=datetime.date(2016, 12, 25))
rule.abort_multipart_upload = AbortMultipartUpload(days=356)
rule.storage_transitions = [StorageTransition(days=356, storage_class=oss2.BUCKET_STORAGE_CLASS_IA)]
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(356, result.rules[0].abort_multipart_upload.days)
self.assertEqual(1, len(result.rules[0].storage_transitions))
self.assertEqual(356, result.rules[0].storage_transitions[0].days)
self.bucket.delete_bucket_lifecycle()
def test_put_lifecycle_days(self, do_request):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
request_text = '''PUT /?lifecycle= HTTP/1.1
Host: ming-oss-share.oss-cn-hangzhou.aliyuncs.com
Accept-Encoding: identity
Connection: keep-alive
Content-Length: 178
date: Sat, 12 Dec 2015 00:35:39 GMT
User-Agent: aliyun-sdk-python/2.0.2(Windows/7/;3.3.3)
Accept: */*
authorization: OSS ZCDmm7TPZKHtx77j:BdIgh0100HCI1QkZKsArQvQafzY=
<LifecycleConfiguration><Rule><ID>{0}</ID><Prefix>{1}</Prefix><Status>{2}</Status><Expiration><Days>{3}</Days></Expiration></Rule></LifecycleConfiguration>'''
response_text = '''HTTP/1.1 200 OK
Server: AliyunOSS
Date: Sat, 12 Dec 2015 00:35:39 GMT
Content-Length: 0
Connection: keep-alive
x-oss-request-id: 566B6BDB1BA604C27DD419B8'''
req_info = mock_response(do_request, response_text)
id = '中文ID'
prefix = '中文前缀'
status = 'Enabled'
days = 3
rule = LifecycleRule(id, prefix,
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=days))
bucket().put_bucket_lifecycle(BucketLifecycle([rule]))
self.assertRequest(req_info, request_text.format(id, prefix, status, days))
def test_put_lifecycle_invalid_transitions(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
rule = LifecycleRule(random_string(10),
'中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=6))
# 转储为ARCHIVE的天数小于转储为IA
rule.storage_transitions = [
oss2.models.StorageTransition(
days=5, storage_class=oss2.BUCKET_STORAGE_CLASS_IA),
oss2.models.StorageTransition(
days=2, storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)
]
self.assertRaises(oss2.exceptions.InvalidArgument,
self.bucket.put_bucket_lifecycle,
BucketLifecycle([rule]))
# 转储为IA(天数大于object过期时间)
rule.storage_transitions = [
oss2.models.StorageTransition(
days=7, storage_class=oss2.BUCKET_STORAGE_CLASS_IA)
]
self.assertRaises(oss2.exceptions.InvalidArgument,
self.bucket.put_bucket_lifecycle,
BucketLifecycle([rule]))
# 转储为STANDARD
rule.storage_transitions = [
oss2.models.StorageTransition(
days=5, storage_class=oss2.BUCKET_STORAGE_CLASS_STANDARD)
]
self.assertRaises(oss2.exceptions.InvalidArgument,
self.bucket.put_bucket_lifecycle,
BucketLifecycle([rule]))
def test_lifecycle_object_tagging_exceptions_too_much_rules(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, StorageTransition, Tagging, TaggingRule
rule = LifecycleRule(
random_string(10),
'中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(
created_before_date=datetime.date(2016, 12, 25)))
rule.storage_transitions = [
StorageTransition(created_before_date=datetime.date(2016, 12, 20),
storage_class=oss2.BUCKET_STORAGE_CLASS_IA)
]
tagging = Tagging()
for i in range(1, 20):
key = 'test_key_' + str(i)
value = 'test_value_' + str(i)
tagging.tag_set.tagging_rule[key] = value
rule.tagging = tagging
lifecycle = BucketLifecycle([rule])
try:
# do not return error,but the lifecycle rule doesn't take effect
result = self.bucket.put_bucket_lifecycle(lifecycle)
except oss2.exceptions.OssError:
self.assertFalse(
True, "put lifecycle with tagging should fail ,but success")
def test_lifecycle_storage_transitions_date(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, StorageTransition
rule = LifecycleRule(
random_string(10),
'中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(
created_before_date=datetime.date(2016, 12, 25)))
rule.storage_transitions = [
StorageTransition(created_before_date=datetime.date(2016, 12, 20),
storage_class=oss2.BUCKET_STORAGE_CLASS_IA)
]
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
wait_meta_sync()
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(1, len(result.rules[0].storage_transitions))
self.assertEqual(
datetime.date(2016, 12, 20),
result.rules[0].storage_transitions[0].created_before_date)
self.assertTrue(result.rules[0].tagging is None)
self.bucket.delete_bucket_lifecycle()
def test_put_lifecycle_date(self, do_request):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
request_text = '''PUT /?lifecycle= HTTP/1.1
Host: ming-oss-share.oss-cn-hangzhou.aliyuncs.com
Accept-Encoding: identity
Connection: keep-alive
Content-Length: 198
date: Sat, 12 Dec 2015 00:35:37 GMT
User-Agent: aliyun-sdk-python/2.0.2(Windows/7/;3.3.3)
Accept: */*
authorization: OSS ZCDmm7TPZKHtx77j:45HTpSD5osRvtusf8VCkmchZZFs=
<LifecycleConfiguration><Rule><ID>{0}</ID><Prefix>{1}</Prefix><Status>{2}</Status><Expiration><Date>{3}</Date></Expiration></Rule></LifecycleConfiguration>'''
response_text = '''HTTP/1.1 200 OK
Server: AliyunOSS
Date: Sat, 12 Dec 2015 00:35:37 GMT
Content-Length: 0
Connection: keep-alive
x-oss-request-id: 566B6BD9B295345D15740F1F'''
id = 'hello world'
prefix = '中文前缀'
status = 'Disabled'
date = '2015-12-25T00:00:00.000Z'
req_info = mock_response(do_request, response_text)
rule = LifecycleRule(id, prefix,
status=LifecycleRule.DISABLED,
expiration=LifecycleExpiration(date=datetime.date(2015, 12, 25)))
bucket().put_bucket_lifecycle(BucketLifecycle([rule]))
self.assertRequest(req_info, request_text.format(id, prefix, status, date))
def test_put_lifecycle_days(self, do_request):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
template = '<LifecycleConfiguration><Rule><ID>{0}</ID><Prefix>{1}</Prefix>' + \
'<Status>{2}</Status><Expiration><Days>{3}</Days></Expiration></Rule></LifecycleConfiguration>'
req_info = RequestInfo()
do_request.auto_spec = True
do_request.side_effect = partial(do4put,
req_info=req_info,
data_type=DT_BYTES)
id = '中文ID'
prefix = '中文前缀'
status = 'Enabled'
days = 3
rule = LifecycleRule(id,
prefix,
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=days))
bucket().put_bucket_lifecycle(BucketLifecycle([rule]))
self.assertXmlEqual(req_info.data,
template.format(id, prefix, status, days))
def set_oss_file_expired(prefix, days=3):
"""
关于prefix:
https://help.aliyun.com/knowledge_detail/39527.html
OSS中的文件夹其实是一个大小为0KB的空文件。因此，用户创建一个key值为1/的object就会定义文件夹1；
并且如果用户创建文件abc/1.jpg，系统是不会创建abc/这个文件的，因此在删除abc/1.jpg后将不会再存在abc这个文件夹。
在后端存储的过程中不同的文件夹的文件仅仅是key值的前缀不一样。
所有文件的key值（这里需要通过prefix指定文件夹）
:param prefix: prefix for key,
:param days: save days
:return:
"""
logger.info("setting expired time started")
bucket = oss2.Bucket(oss2.Auth(access_key_id, access_key_secret), endpoint, bucket_name)
rule1 = LifecycleRule('rule1', prefix,
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=days))
lifecycle = BucketLifecycle([rule1])
result = bucket.put_bucket_lifecycle(lifecycle)
logger.info(" ".join((result.request_id, str(result.status))))
logger.info("setting expired time finished")
return result
def test_lifecycle_storage_transitions_more_days(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, StorageTransition
rule = LifecycleRule(random_string(10), '中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=357))
rule.storage_transitions = [StorageTransition(days=355, storage_class=oss2.BUCKET_STORAGE_CLASS_IA),
StorageTransition(days=356, storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)]
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
wait_meta_sync()
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(2, len(result.rules[0].storage_transitions))
self.assertTrue(result.rules[0].tagging is None)
if result.rules[0].storage_transitions[0].storage_class == oss2.BUCKET_STORAGE_CLASS_IA:
self.assertEqual(355, result.rules[0].storage_transitions[0].days)
self.assertEqual(356, result.rules[0].storage_transitions[1].days)
self.assertEqual(oss2.BUCKET_STORAGE_CLASS_ARCHIVE, result.rules[0].storage_transitions[1].storage_class)
else:
self.assertEqual(356, result.rules[0].storage_transitions[0].days)
self.assertEqual(356, result.rules[0].storage_transitions[1].days)
self.assertEqual(oss2.BUCKET_STORAGE_CLASS_IA, result.rules[0].storage_transitions[1].storage_class)
self.bucket.delete_bucket_lifecycle()
def test_lifecycle_object_tagging(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, StorageTransition, Tagging, TaggingRule
rule = LifecycleRule(random_string(10), 'aaaaaaaaaaa/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2016, 12, 25)))
rule.storage_transitions = [StorageTransition(created_before_date=datetime.date(2016, 12, 20),
storage_class=oss2.BUCKET_STORAGE_CLASS_IA)]
tagging_rule = TaggingRule()
tagging_rule.add('test_key', 'test_value')
tagging = Tagging(tagging_rule)
rule.tagging = tagging
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
wait_meta_sync()
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(1, len(result.rules[0].storage_transitions))
self.assertEqual(datetime.date(2016, 12, 20), result.rules[0].storage_transitions[0].created_before_date)
self.assertEqual(1, result.rules[0].tagging.tag_set.len())
self.assertEqual('test_value', result.rules[0].tagging.tag_set.tagging_rule['test_key'])
self.bucket.delete_bucket_lifecycle()
def test_lifecycle_abort_multipart_upload_date(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, AbortMultipartUpload
rule = LifecycleRule(
random_string(10),
'中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(
created_before_date=datetime.date(2016, 12, 25)))
rule.abort_multipart_upload = AbortMultipartUpload(
created_before_date=datetime.date(2016, 12, 20))
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
wait_meta_sync()
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(
datetime.date(2016, 12, 20),
result.rules[0].abort_multipart_upload.created_before_date)
self.assertTrue(result.rules[0].tagging is None)
self.bucket.delete_bucket_lifecycle()
def test_put_lifecycle_date(self, do_request):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
template = '<LifecycleConfiguration><Rule><ID>{0}</ID><Prefix>{1}</Prefix>' + \
'<Status>{2}</Status><Expiration><Date>{3}</Date></Expiration></Rule></LifecycleConfiguration>'
req_info = RequestInfo()
do_request.auto_spec = True
do_request.side_effect = partial(do4put,
req_info=req_info,
data_type=DT_BYTES)
id = 'hello world'
prefix = '中文前缀'
status = 'Disabled'
date = '2015-12-25T00:00:00.000Z'
rule = LifecycleRule(
id,
prefix,
status=LifecycleRule.DISABLED,
expiration=LifecycleExpiration(date=datetime.date(2015, 12, 25)))
bucket().put_bucket_lifecycle(BucketLifecycle([rule]))
self.assertXmlEqual(req_info.data,
template.format(id, prefix, status, date))
def test_put_lifecycle_days_less_than_transition_days(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
rule = LifecycleRule(random_string(10), '中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=3))
rule.storage_transitions = [oss2.models.StorageTransition(days=4, storage_class=oss2.BUCKET_STORAGE_CLASS_IA)]
self.assertRaises(oss2.exceptions.InvalidArgument, self.bucket.put_bucket_lifecycle, BucketLifecycle([rule]))
def test_lifecycle_storage_transitions_mixed(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, StorageTransition
rule = LifecycleRule(random_string(10), '中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2016, 12, 25)))
rule.storage_transitions = [StorageTransition(days=356, storage_class=oss2.BUCKET_STORAGE_CLASS_IA)]
lifecycle = BucketLifecycle([rule])
self.assertRaises(oss2.exceptions.InvalidRequest, self.bucket.put_bucket_lifecycle, lifecycle)
def test_lifecycle_created_before_date(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
rule = LifecycleRule(random_string(10), '中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2016, 12, 25)))
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
self.retry_assert(lambda: self.same_lifecycle(rule, self.bucket))
self.bucket.delete_bucket_lifecycle()
def test_put_lifecycle_days(self, do_request):
from oss2.models import (LifecycleExpiration, LifecycleRule,
BucketLifecycle, AbortMultipartUpload,
StorageTransition)
request_text = '''PUT /?lifecycle= HTTP/1.1
Host: ming-oss-share.oss-cn-hangzhou.aliyuncs.com
Accept-Encoding: identity
Connection: keep-alive
Content-Length: 178
date: Sat, 12 Dec 2015 00:35:39 GMT
User-Agent: aliyun-sdk-python/2.0.2(Windows/7/;3.3.3)
Accept: */*
authorization: OSS ZCDmm7TPZKHtx77j:BdIgh0100HCI1QkZKsArQvQafzY=
<LifecycleConfiguration><Rule><ID>{0}</ID><Prefix>{1}</Prefix><Status>{2}</Status>\
<Expiration><Days>{3}</Days></Expiration><AbortMultipartUpload><Days>{5}</Days></AbortMultipartUpload>\
<Transition><StorageClass>Standard</StorageClass><Days>{4}</Days></Transition></Rule></LifecycleConfiguration>'''
response_text = '''HTTP/1.1 200 OK
Server: AliyunOSS
Date: Sat, 12 Dec 2015 00:35:39 GMT
Content-Length: 0
Connection: keep-alive
x-oss-request-id: 566B6BDB1BA604C27DD419B8'''
req_info = unittests.common.mock_response(do_request, response_text)
id = '中文ID'
prefix = '中文前缀'
status = 'Enabled'
days = 3
rule = LifecycleRule(
id,
prefix,
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=days),
storage_transitions=[
StorageTransition(
days=days,
storage_class=oss2.BUCKET_STORAGE_CLASS_STANDARD)
],
abort_multipart_upload=AbortMultipartUpload(days=days))
unittests.common.bucket().put_bucket_lifecycle(BucketLifecycle([rule]))
self.assertRequest(
req_info, request_text.format(id, prefix, status, days, days,
days))
def test_put_lifecycle_date(self, do_request):
from oss2.models import (LifecycleExpiration, LifecycleRule,
BucketLifecycle, AbortMultipartUpload,
StorageTransition)
request_text = '''PUT /?lifecycle= HTTP/1.1
Host: ming-oss-share.oss-cn-hangzhou.aliyuncs.com
Accept-Encoding: identity
Connection: keep-alive
Content-Length: 198
date: Sat, 12 Dec 2015 00:35:37 GMT
User-Agent: aliyun-sdk-python/2.0.2(Windows/7/;3.3.3)
Accept: */*
authorization: OSS ZCDmm7TPZKHtx77j:45HTpSD5osRvtusf8VCkmchZZFs=
<LifecycleConfiguration><Rule><ID>{0}</ID><Prefix>{1}</Prefix><Status>{2}</Status>\
<Expiration><Date>{3}</Date></Expiration><AbortMultipartUpload><CreatedBeforeDate>{5}</CreatedBeforeDate></AbortMultipartUpload>\
<Transition><StorageClass>Standard</StorageClass><CreatedBeforeDate>{4}</CreatedBeforeDate></Transition></Rule></LifecycleConfiguration>'''
response_text = '''HTTP/1.1 200 OK
Server: AliyunOSS
Date: Sat, 12 Dec 2015 00:35:37 GMT
Content-Length: 0
Connection: keep-alive
x-oss-request-id: 566B6BD9B295345D15740F1F'''
id = 'hello world'
prefix = '中文前缀'
status = 'Disabled'
date = '2015-12-25T00:00:00.000Z'
date1 = datetime.date(2015, 12, 25)
req_info = unittests.common.mock_response(do_request, response_text)
rule = LifecycleRule(
id,
prefix,
status=LifecycleRule.DISABLED,
expiration=LifecycleExpiration(date=date1),
storage_transitions=[
StorageTransition(
created_before_date=date1,
storage_class=oss2.BUCKET_STORAGE_CLASS_STANDARD)
],
abort_multipart_upload=AbortMultipartUpload(
created_before_date=date1))
unittests.common.bucket().put_bucket_lifecycle(BucketLifecycle([rule]))
self.assertRequest(
req_info, request_text.format(id, prefix, status, date, date,
date))
def test_lifecycle_days(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle
for prefix in ['中文前缀+/', '', u'中文前缀+/']:
rule = LifecycleRule(random_string(10), prefix,
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=356))
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
self.retry_assert(lambda: self.same_lifecycle(rule, self.bucket))
self.bucket.delete_bucket_lifecycle()
self.bucket.delete_bucket_lifecycle()
self.assertRaises(oss2.exceptions.NoSuchLifecycle, self.bucket.get_bucket_lifecycle)
def test_lifecycle_abort_multipart_upload_days(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, AbortMultipartUpload
rule = LifecycleRule(
random_string(10),
'中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(
created_before_date=datetime.date(2016, 12, 25)))
rule.abort_multipart_upload = AbortMultipartUpload(days=356)
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
self.retry_assert(lambda: self.same_lifecycle(rule, self.bucket))
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(356, result.rules[0].abort_multipart_upload.days)
self.bucket.delete_bucket_lifecycle()
def test_lifecycle_storage_transitions_days(self):
from oss2.models import LifecycleExpiration, LifecycleRule, BucketLifecycle, StorageTransition
rule = LifecycleRule(random_string(10),
'中文前缀/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=357))
rule.storage_transitions = [
StorageTransition(days=356,
storage_class=oss2.BUCKET_STORAGE_CLASS_IA)
]
lifecycle = BucketLifecycle([rule])
self.bucket.put_bucket_lifecycle(lifecycle)
result = self.bucket.get_bucket_lifecycle()
self.assertEqual(1, len(result.rules))
self.assertEqual(1, len(result.rules[0].storage_transitions))
self.assertEqual(356, result.rules[0].storage_transitions[0].days)
self.bucket.delete_bucket_lifecycle()
def test_lifecycle_versioning(self):
auth = oss2.Auth(OSS_ID, OSS_SECRET)
bucket_name = OSS_BUCKET + "-test-lifecycle-versioning"
bucket = oss2.Bucket(auth, self.endpoint, bucket_name)
bucket.create_bucket(oss2.BUCKET_ACL_PRIVATE)
wait_meta_sync()
rule = LifecycleRule(
'rule1',
'test-prefix',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(expired_detete_marker=True),
noncurrent_version_expiration=NoncurrentVersionExpiration(30),
noncurrent_version_sotrage_transitions=[
NoncurrentVersionStorageTransition(
12, oss2.BUCKET_STORAGE_CLASS_IA),
NoncurrentVersionStorageTransition(
20, oss2.BUCKET_STORAGE_CLASS_ARCHIVE)
])
lifecycle = BucketLifecycle([rule])
bucket.put_bucket_lifecycle(lifecycle)
lifecycle = bucket.get_bucket_lifecycle()
self.assertEquals(1, len(lifecycle.rules))
self.assertEqual('rule1', lifecycle.rules[0].id)
self.assertEqual('test-prefix', lifecycle.rules[0].prefix)
self.assertEquals(LifecycleRule.ENABLED, lifecycle.rules[0].status)
self.assertEquals(True,
lifecycle.rules[0].expiration.expired_detete_marker)
self.assertEquals(
30,
lifecycle.rules[0].noncurrent_version_expiration.noncurrent_days)
self.assertEquals(
2, len(lifecycle.rules[0].noncurrent_version_sotrage_transitions))
bucket.delete_bucket()
