/// 获取存储桶生命周期
public void GetBucketLifecycle()
{
//.cssg-snippet-body-start:[get-bucket-lifecycle]
try
{
string bucket = "examplebucket-1250000000"; //格式：BucketName-APPID
GetBucketLifecycleRequest request = new GetBucketLifecycleRequest(bucket);
//执行请求
GetBucketLifecycleResult result = cosXml.GetBucketLifecycle(request);
//存储桶的生命周期配置
LifecycleConfiguration conf = result.lifecycleConfiguration;
}
catch (COSXML.CosException.CosClientException clientEx)
{
//请求失败
Console.WriteLine("CosClientException: " + clientEx);
}
catch (COSXML.CosException.CosServerException serverEx)
{
//请求失败
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
}
//.cssg-snippet-body-end
}
public static void testLifeCycleConfig()
{
LifecycleConfiguration lifeCycleConfig = new LifecycleConfiguration();
lifeCycleConfig.rules = new System.Collections.Generic.List <LifecycleConfiguration.Rule>();
for (int i = 0; i < 3; i++)
{
LifecycleConfiguration.Rule rule = new LifecycleConfiguration.Rule();
rule.id = String.Format("the {0}th", i + 1);
rule.filter = new LifecycleConfiguration.Filter();
rule.filter.prefix = "filter prefix";
rule.status = "Enabled";
rule.abortIncompleteMultiUpload = new LifecycleConfiguration.AbortIncompleteMultiUpload();
rule.abortIncompleteMultiUpload.daysAfterInitiation = 2;
rule.expiration = new LifecycleConfiguration.Expiration();
rule.expiration.date = DateTime.Now.ToString();
rule.expiration.days = 2;
rule.transition = new LifecycleConfiguration.Transition();
rule.transition.date = DateTime.Now.ToString();
rule.transition.days = 2;
rule.noncurrentVersionExpiration = new LifecycleConfiguration.NoncurrentVersionExpiration();
rule.noncurrentVersionExpiration.noncurrentDays = 2;
rule.noncurrentVersionTransition = new LifecycleConfiguration.NoncurrentVersionTransition();
rule.noncurrentVersionTransition.noncurrentDays = 2;
rule.noncurrentVersionTransition.storageClass = EnumUtils.GetValue(CosStorageClass.STANDARD);
lifeCycleConfig.rules.Add(rule);
}
Console.WriteLine(lifeCycleConfig.GetInfo());
}
public PutBucketLifecycleRequest(string bucket)
: base(bucket)
{
this.method = CosRequestMethod.PUT;
this.queryParameters.Add("lifecycle", null);
lifecycleConfiguration = new LifecycleConfiguration();
lifecycleConfiguration.rules = new List <LifecycleConfiguration.Rule>();
}
static async Task AddExampleLifecycleConfigAsync(IAmazonS3 client, LifecycleConfiguration configuration)
{
PutLifecycleConfigurationRequest request = new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
};
var response = await client.PutLifecycleConfigurationAsync(request);
}
private static async Task LifecycleConfigAsync()
{
client = new AmazonS3Client(bucketRegion);
string input = Console.ReadLine();
try
{
int action = Convert.ToInt32(input);
var lifeCycleConfiguration = new LifecycleConfiguration();
switch (action)
{
case 1:
await AddUpdateDeleteLifecycleConfigAsync();
break;
case 2:
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
foreach (var rule in lifeCycleConfiguration.Rules)
{
Console.WriteLine("Rule Id {0} with status of {1} and expiration Days is ", rule.Id, rule.Status, rule.Expiration != null ? rule.Expiration.Days: 0);
Console.WriteLine("Transition");
foreach (var trans in rule.Transitions)
{
Console.WriteLine("Storage class {0} and expiration Days is ", trans.StorageClass, trans.Days);
}
Console.WriteLine("Filter");
if (rule.Filter.LifecycleFilterPredicate is LifecyclePrefixPredicate)
{
LifecyclePrefixPredicate prefix = rule.Filter.LifecycleFilterPredicate as LifecyclePrefixPredicate;
Console.WriteLine("Filter Prefix {0} and expiration Days is ", prefix.Prefix);
}
if (rule.Filter.LifecycleFilterPredicate is LifecycleTagPredicate)
{
LifecycleTagPredicate tags = rule.Filter.LifecycleFilterPredicate as LifecycleTagPredicate;
Console.WriteLine("Filter Tag Key {0} and value ", tags.Tag.Key, tags.Tag.Value);
}
Console.WriteLine("*************************************");
}
break;
case 3:
await RemoveLifecycleConfigAsync(client);
break;
default:
break;
}
}
catch (Exception e)
{
ErrorUtility.LogError(e, GApplication.Unknown, string.Format("Error: Lifecycle Error: " + e.Message));
}
}
public void GetInfoTest()
{
LifecycleConfiguration target = new LifecycleConfiguration(); // TODO: Initialize to an appropriate value
string expected = string.Empty; // TODO: Initialize to an appropriate value
string actual;
actual = target.GetInfo();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
static void AddExampleLifecycleConfigAsync(IAmazonS3 client, LifecycleConfiguration configuration)
{
PutLifecycleConfigurationRequest request = new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
};
var response = client.PutLifecycleConfigurationAsync(request).Result;
}
private void GetLifeCycleConfiguration()
{
var request = new GetLifecycleConfigurationRequest {
BucketName = AWSBucket
};
var response = S3Client.GetLifecycleConfiguration(request);
LifecycleConfiguration = response.Configuration;
if (LifecycleConfiguration == null)
{
LifecycleConfiguration = new LifecycleConfiguration();
}
}
internal GetBucketLifecycleResponse(HttpStatusCode statusCode, string responseContent)
: base(statusCode, responseContent)
{
if (string.IsNullOrEmpty(responseContent) ||
!HttpStatusCode.OK.Equals(statusCode))
{
this.BucketLifecycle = null;
return;
}
//Remove xmlns content for config serialization
responseContent = utils.RemoveNamespaceInXML(responseContent);
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(responseContent)))
{
this.BucketLifecycle = (LifecycleConfiguration) new XmlSerializer(typeof(LifecycleConfiguration)).Deserialize(stream);
}
}
public void getBucketLifecycle()
{
//.cssg-snippet-body-start:[get-bucket-lifecycle]
CosXmlConfig config = new CosXmlConfig.Builder()
.SetConnectionTimeoutMs(60000) //设置连接超时时间，单位毫秒，默认45000ms
.SetReadWriteTimeoutMs(40000) //设置读写超时时间，单位毫秒，默认45000ms
.IsHttps(true) //设置默认 HTTPS 请求
.SetAppid("1253653367") //设置腾讯云账户的账户标识 APPID
.SetRegion("ap-guangzhou") //设置一个默认的存储桶地域
.Build();
string secretId = Environment.GetEnvironmentVariable("COS_KEY"); //云 API 密钥 SecretId
string secretKey = Environment.GetEnvironmentVariable("COS_SECRET"); //云 API 密钥 SecretKey
long durationSecond = 600; //每次请求签名有效时长，单位为秒
QCloudCredentialProvider qCloudCredentialProvider = new DefaultQCloudCredentialProvider(secretId,
secretKey, durationSecond);
CosXml cosXml = new CosXmlServer(config, qCloudCredentialProvider);
try
{
string bucket = "bucket-cssg-test-dotnet-1253653367"; //格式：BucketName-APPID
GetBucketLifecycleRequest request = new GetBucketLifecycleRequest(bucket);
//设置签名有效时长
request.SetSign(TimeUtils.GetCurrentTime(TimeUnit.SECONDS), 600);
//执行请求
GetBucketLifecycleResult result = cosXml.GetBucketLifecycle(request);
//存储桶的生命周期配置
LifecycleConfiguration conf = result.lifecycleConfiguration;
}
catch (COSXML.CosException.CosClientException clientEx)
{
//请求失败
Console.WriteLine("CosClientException: " + clientEx);
Assert.Null(clientEx);
}
catch (COSXML.CosException.CosServerException serverEx)
{
//请求失败
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
Assert.Null(serverEx);
}
//.cssg-snippet-body-end
}
// Set Lifecycle configuration to the bucket
public async static Task Run(MinioClient minio,
string bucketName = "my-bucket-name",
LifecycleConfiguration lfc = null)
{
try
{
Console.WriteLine("Running example for API: SetBucketLifecycle");
await minio.SetBucketLifecycleAsync(
new SetBucketLifecycleArgs()
.WithBucket(bucketName)
.WithLifecycleConfiguration(lfc)
);
Console.WriteLine($"Bucket Lifecycle set for bucket {bucketName}.");
Console.WriteLine();
}
catch (Exception e)
{
Console.WriteLine($"[Bucket] Exception: {e}");
}
}
public void CreateExpirationRule(string bucket, string prefix, int expirationDays, string description)
{
var rule = new LifecycleRule
{
Id = description,
Prefix = prefix,
Status = LifecycleRuleStatus.Enabled,
Expiration = new LifecycleRuleExpiration {
Days = expirationDays
}
};
var lifecycleConfiguration = new LifecycleConfiguration
{
Rules = new List <LifecycleRule> {
rule
}
};
_s3Client.PutLifecycleConfiguration(bucket, lifecycleConfiguration);
}
public void LifecycleConfigurationConstructorTest()
{
LifecycleConfiguration target = new LifecycleConfiguration();
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void BucketSamples()
{
{
#region ListBuckets Sample
// Create a client
AmazonS3Client client = new AmazonS3Client();
// Issue call
ListBucketsResponse response = client.ListBuckets();
// View response data
Console.WriteLine("Buckets owner - {0}", response.Owner.DisplayName);
foreach (S3Bucket bucket in response.Buckets)
{
Console.WriteLine("Bucket {0}, Created on {1}", bucket.BucketName, bucket.CreationDate);
}
#endregion
}
{
#region BucketPolicy Sample
// Create a client
AmazonS3Client client = new AmazonS3Client();
// Put sample bucket policy (overwrite an existing policy)
string newPolicy = @"{
""Statement"":[{
""Sid"":""BasicPerms"",
""Effect"":""Allow"",
""Principal"": ""*"",
""Action"":[""s3:PutObject"",""s3:GetObject""],
""Resource"":[""arn:aws:s3:::samplebucketname/*""]
}]}";
PutBucketPolicyRequest putRequest = new PutBucketPolicyRequest
{
BucketName = "SampleBucket",
Policy = newPolicy
};
client.PutBucketPolicy(putRequest);
// Retrieve current policy
GetBucketPolicyRequest getRequest = new GetBucketPolicyRequest
{
BucketName = "SampleBucket"
};
string policy = client.GetBucketPolicy(getRequest).Policy;
Console.WriteLine(policy);
Debug.Assert(policy.Contains("BasicPerms"));
// Delete current policy
DeleteBucketPolicyRequest deleteRequest = new DeleteBucketPolicyRequest
{
BucketName = "SampleBucket"
};
client.DeleteBucketPolicy(deleteRequest);
// Retrieve current policy and verify that it is null
policy = client.GetBucketPolicy(getRequest).Policy;
Debug.Assert(policy == null);
#endregion
}
{
#region GetBucketLocation Sample
// Create a client
AmazonS3Client client = new AmazonS3Client();
// Construct request
GetBucketLocationRequest request = new GetBucketLocationRequest
{
BucketName = "SampleBucket"
};
// Issue call
GetBucketLocationResponse response = client.GetBucketLocation(request);
// View response data
Console.WriteLine("Bucket location - {0}", response.Location);
#endregion
}
{
#region PutBucket Sample
// Create a client
AmazonS3Client client = new AmazonS3Client();
// Construct request
PutBucketRequest request = new PutBucketRequest
{
BucketName = "SampleBucket",
BucketRegion = S3Region.EU, // set region to EU
CannedACL = S3CannedACL.PublicRead // make bucket publicly readable
};
// Issue call
PutBucketResponse response = client.PutBucket(request);
#endregion
}
{
#region DeleteBucket Sample 1
// Create a client
AmazonS3Client client = new AmazonS3Client();
// Construct request
DeleteBucketRequest request = new DeleteBucketRequest
{
BucketName = "SampleBucket"
};
// Issue call
DeleteBucketResponse response = client.DeleteBucket(request);
#endregion
}
{
#region DeleteBucket Sample 2
// Create a client
AmazonS3Client client = new AmazonS3Client();
// List and delete all objects
ListObjectsRequest listRequest = new ListObjectsRequest
{
BucketName = "SampleBucket"
};
ListObjectsResponse listResponse;
do
{
// Get a list of objects
listResponse = client.ListObjects(listRequest);
foreach (S3Object obj in listResponse.S3Objects)
{
// Delete each object
client.DeleteObject(new DeleteObjectRequest
{
BucketName = "SampleBucket",
Key = obj.Key
});
}
// Set the marker property
listRequest.Marker = listResponse.NextMarker;
} while (listResponse.IsTruncated);
// Construct DeleteBucket request
DeleteBucketRequest request = new DeleteBucketRequest
{
BucketName = "SampleBucket"
};
// Issue call
DeleteBucketResponse response = client.DeleteBucket(request);
#endregion
}
{
#region LifecycleConfiguration Sample
// Create a client
AmazonS3Client client = new AmazonS3Client();
// Put sample lifecycle configuration (overwrite an existing configuration)
LifecycleConfiguration newConfiguration = new LifecycleConfiguration
{
Rules = new List <LifecycleRule>
{
// Rule to delete keys with prefix "Test-" after 5 days
new LifecycleRule
{
Prefix = "Test-",
Expiration = new LifecycleRuleExpiration {
Days = 5
}
},
// Rule to delete keys in subdirectory "Logs" after 2 days
new LifecycleRule
{
Prefix = "Logs/",
Expiration = new LifecycleRuleExpiration {
Days = 2
},
Id = "log-file-removal"
}
}
};
PutLifecycleConfigurationRequest putRequest = new PutLifecycleConfigurationRequest
{
BucketName = "SampleBucket",
Configuration = newConfiguration
};
client.PutLifecycleConfiguration(putRequest);
// Retrieve current configuration
GetLifecycleConfigurationRequest getRequest = new GetLifecycleConfigurationRequest
{
BucketName = "SampleBucket"
};
LifecycleConfiguration configuration = client.GetLifecycleConfiguration(getRequest).Configuration;
Console.WriteLine("Configuration contains {0} rules", configuration.Rules.Count);
foreach (LifecycleRule rule in configuration.Rules)
{
Console.WriteLine("Rule");
Console.WriteLine(" Prefix = " + rule.Prefix);
Console.WriteLine(" Expiration (days) = " + rule.Expiration.Days);
Console.WriteLine(" Id = " + rule.Id);
Console.WriteLine(" Status = " + rule.Status);
}
// Put a new configuration and overwrite the existing configuration
configuration.Rules.RemoveAt(0); // remove first rule
client.PutLifecycleConfiguration(putRequest);
// Delete current configuration
DeleteLifecycleConfigurationRequest deleteRequest = new DeleteLifecycleConfigurationRequest
{
BucketName = "SampleBucket"
};
client.DeleteLifecycleConfiguration(deleteRequest);
// Retrieve current configuration and verify that it is null
configuration = client.GetLifecycleConfiguration(getRequest).Configuration;
Debug.Assert(configuration == null);
#endregion
}
}
public static string BuildLifecycleConfiguration(LifecycleConfiguration lifecycleConfiguration)
{
StringWriter stringWriter = new StringWriter();
XmlWriterSettings xmlWriterSetting = new XmlWriterSettings();
xmlWriterSetting.Indent = true;
XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSetting);
xmlWriter.WriteStartDocument();
//start to write element
xmlWriter.WriteStartElement("LifecycleConfiguration");
if (lifecycleConfiguration.rules != null)
{
foreach (LifecycleConfiguration.Rule rule in lifecycleConfiguration.rules)
{
if (rule == null)
{
continue;
}
xmlWriter.WriteStartElement("Rule");
if (rule.id != null)
{
xmlWriter.WriteElementString("ID", rule.id);
}
if (rule.filter != null)
{
xmlWriter.WriteStartElement("Filter");
if (rule.filter.prefix != null)
{
xmlWriter.WriteElementString("Prefix", rule.filter.prefix);
}
if (rule.filter.filterAnd != null)
{
xmlWriter.WriteStartElement("And");
if (rule.filter.filterAnd.prefix != null)
{
xmlWriter.WriteElementString("Prefix", rule.filter.filterAnd.prefix);
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
if (rule.status != null)
{
xmlWriter.WriteElementString("Status", rule.status);
}
if (rule.transition != null)
{
xmlWriter.WriteStartElement("Transition");
if (rule.transition.days > 0)
{
xmlWriter.WriteElementString("Days", rule.transition.days.ToString());
}
if (rule.transition.storageClass != null)
{
xmlWriter.WriteElementString("StorageClass", rule.transition.storageClass);
}
if (rule.transition.date != null)
{
xmlWriter.WriteElementString("Date", rule.transition.date);
}
xmlWriter.WriteEndElement();
}
if (rule.expiration != null)
{
xmlWriter.WriteStartElement("Expiration");
if (rule.expiration.days > 0)
{
xmlWriter.WriteElementString("Days", rule.expiration.days.ToString());
}
if (rule.expiration.expiredObjectDeleteMarker != null)
{
if ((bool)rule.expiration.expiredObjectDeleteMarker)
{
xmlWriter.WriteElementString("ExpiredObjectDeleteMarker", "true");
}
else
{
xmlWriter.WriteElementString("ExpiredObjectDeleteMarker", "false");
}
}
if (rule.expiration.date != null)
{
xmlWriter.WriteElementString("Date", rule.expiration.date);
}
xmlWriter.WriteEndElement();
}
if (rule.noncurrentVersionTransition != null)
{
xmlWriter.WriteStartElement("NoncurrentVersionTransition");
if (rule.noncurrentVersionTransition.noncurrentDays > 0)
{
xmlWriter.WriteElementString("NoncurrentDays", rule.noncurrentVersionTransition.noncurrentDays.ToString());
}
if (rule.noncurrentVersionTransition.storageClass != null)
{
xmlWriter.WriteElementString("StorageClass", rule.noncurrentVersionTransition.storageClass);
}
xmlWriter.WriteEndElement();
}
if (rule.noncurrentVersionExpiration != null)
{
xmlWriter.WriteStartElement("NoncurrentVersionExpiration");
if (rule.noncurrentVersionExpiration.noncurrentDays > 0)
{
xmlWriter.WriteElementString("NoncurrentDays", rule.noncurrentVersionExpiration.noncurrentDays.ToString());
}
xmlWriter.WriteEndElement();
}
if (rule.abortIncompleteMultiUpload != null)
{
xmlWriter.WriteStartElement("AbortIncompleteMultipartUpload");
if (rule.abortIncompleteMultiUpload.daysAfterInitiation > 0)
{
xmlWriter.WriteElementString("DaysAfterInitiation", rule.abortIncompleteMultiUpload.daysAfterInitiation.ToString());
}
xmlWriter.WriteEndElement();
}
}
}
// end to element
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
return(RemoveXMLHeader(stringWriter.ToString()));
}
public SetBucketLifecycleArgs WithLifecycleConfiguration(LifecycleConfiguration lc)
{
BucketLifecycle = lc;
return(this);
}
internal override void ParseResponseBody(System.IO.Stream inputStream, string contentType, long contentLength)
{
lifecycleConfiguration = new LifecycleConfiguration();
XmlParse.ParseLifecycleConfiguration(inputStream, lifecycleConfiguration);
}
public void LifecycleTest()
{
var s3Configuration = Client.GetLifecycleConfiguration(bucketName).Configuration;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(0, s3Configuration.Rules.Count);
var configuration = new LifecycleConfiguration
{
Rules = new List <LifecycleRule>
{
new LifecycleRule
{
Prefix = "rule1-",
Status = LifecycleRuleStatus.Enabled,
Expiration = new LifecycleRuleExpiration
{
Days = 2,
},
#pragma warning disable 618
Transition = new LifecycleTransition
{
Days = 1,
StorageClass = S3StorageClass.Glacier
},
NoncurrentVersionTransition = new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 14,
StorageClass = S3StorageClass.Glacier
},
#pragma warning restore 618
AbortIncompleteMultipartUpload = new LifecycleRuleAbortIncompleteMultipartUpload
{
DaysAfterInitiation = 7
}
},
new LifecycleRule
{
Prefix = "rule2-",
Expiration = new LifecycleRuleExpiration
{
Days = 120
},
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 90,
StorageClass = S3StorageClass.Glacier
}
},
NoncurrentVersionTransitions = new List <LifecycleRuleNoncurrentVersionTransition>
{
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 90,
StorageClass = S3StorageClass.Glacier
}
}
},
new LifecycleRule
{
Prefix = "rule3-",
Expiration = new LifecycleRuleExpiration
{
ExpiredObjectDeleteMarker = true
},
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 90,
StorageClass = S3StorageClass.Glacier
}
},
NoncurrentVersionTransitions = new List <LifecycleRuleNoncurrentVersionTransition>
{
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 90,
StorageClass = S3StorageClass.Glacier
}
}
}
}
};
Client.PutLifecycleConfiguration(new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
});
s3Configuration = Client.GetLifecycleConfiguration(bucketName).Configuration;
string abortRuleId = null;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(configuration.Rules.Count, s3Configuration.Rules.Count);
for (int i = 0; i < configuration.Rules.Count; i++)
{
var rule = configuration.Rules[i];
Assert.IsNotNull(rule);
var s3Rule = s3Configuration.Rules[i];
Assert.IsNotNull(s3Rule);
Assert.IsFalse(string.IsNullOrEmpty(s3Rule.Id));
Assert.AreEqual(rule.Transitions.Count, s3Rule.Transitions.Count);
Assert.AreEqual(rule.NoncurrentVersionTransitions.Count, s3Rule.NoncurrentVersionTransitions.Count);
if (rule.AbortIncompleteMultipartUpload == null)
{
Assert.IsNull(s3Rule.AbortIncompleteMultipartUpload);
Assert.AreEqual(LifecycleRuleStatus.Disabled, s3Rule.Status);
}
else
{
Assert.AreEqual(rule.AbortIncompleteMultipartUpload.DaysAfterInitiation, s3Rule.AbortIncompleteMultipartUpload.DaysAfterInitiation);
Assert.AreEqual(LifecycleRuleStatus.Enabled, s3Rule.Status);
abortRuleId = s3Rule.Id;
}
Assert.AreEqual(rule.Expiration.Days, s3Rule.Expiration.Days);
Assert.AreEqual(rule.Expiration.ExpiredObjectDeleteMarker, s3Rule.Expiration.ExpiredObjectDeleteMarker);
#pragma warning disable 618
Assert.AreEqual(rule.Transition.Days, s3Rule.Transition.Days);
Assert.AreEqual(rule.NoncurrentVersionTransition.NoncurrentDays, s3Rule.NoncurrentVersionTransition.NoncurrentDays);
#pragma warning restore 618
}
var expectedMinAbortDate = DateTime.Now.Date.AddDays(7);
var initResponse = Client.InitiateMultipartUpload(new InitiateMultipartUploadRequest
{
BucketName = bucketName,
Key = "rule1-123",
CannedACL = S3CannedACL.PublicRead
});
var listResponse = Client.ListParts(bucketName, initResponse.Key, initResponse.UploadId);
Assert.AreEqual(abortRuleId, initResponse.AbortRuleId);
Assert.AreEqual(abortRuleId, listResponse.AbortRuleId);
Assert.AreEqual(initResponse.AbortDate, listResponse.AbortDate);
Assert.IsTrue(expectedMinAbortDate < initResponse.AbortDate);
}
public IRequest Marshall(PutLifecycleConfigurationRequest putLifecycleConfigurationRequest)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
//IL_050c: Unknown result type (might be due to invalid IL or missing references)
IRequest val = new DefaultRequest(putLifecycleConfigurationRequest, "AmazonS3");
val.set_HttpMethod("PUT");
val.set_ResourcePath("/" + S3Transforms.ToStringValue(putLifecycleConfigurationRequest.BucketName));
val.AddSubResource("lifecycle");
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings
{
Encoding = Encoding.UTF8,
OmitXmlDeclaration = true
}))
{
LifecycleConfiguration configuration = putLifecycleConfigurationRequest.Configuration;
if (configuration != null)
{
xmlWriter.WriteStartElement("LifecycleConfiguration", "");
if (configuration != null)
{
List <LifecycleRule> rules = configuration.Rules;
if (rules != null && rules.Count > 0)
{
foreach (LifecycleRule item in rules)
{
xmlWriter.WriteStartElement("Rule", "");
if (item != null)
{
LifecycleRuleExpiration expiration = item.Expiration;
if (expiration != null)
{
xmlWriter.WriteStartElement("Expiration", "");
if (expiration.IsSetDate())
{
xmlWriter.WriteElementString("Date", "", S3Transforms.ToXmlStringValue(expiration.Date));
}
if (expiration.IsSetDays())
{
xmlWriter.WriteElementString("Days", "", S3Transforms.ToXmlStringValue(expiration.Days));
}
if (expiration.IsSetExpiredObjectDeleteMarker())
{
xmlWriter.WriteElementString("ExpiredObjectDeleteMarker", "", expiration.ExpiredObjectDeleteMarker.ToString().ToLowerInvariant());
}
xmlWriter.WriteEndElement();
}
List <LifecycleTransition> transitions = item.Transitions;
if (transitions != null && transitions.Count > 0)
{
foreach (LifecycleTransition item2 in transitions)
{
if (item2 != null)
{
xmlWriter.WriteStartElement("Transition", "");
if (item2.IsSetDate())
{
xmlWriter.WriteElementString("Date", "", S3Transforms.ToXmlStringValue(item2.Date));
}
if (item2.IsSetDays())
{
xmlWriter.WriteElementString("Days", "", S3Transforms.ToXmlStringValue(item2.Days));
}
if (item2.IsSetStorageClass())
{
xmlWriter.WriteElementString("StorageClass", "", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(item2.StorageClass)));
}
xmlWriter.WriteEndElement();
}
}
}
LifecycleRuleNoncurrentVersionExpiration noncurrentVersionExpiration = item.NoncurrentVersionExpiration;
if (noncurrentVersionExpiration != null)
{
xmlWriter.WriteStartElement("NoncurrentVersionExpiration", "");
if (noncurrentVersionExpiration.IsSetNoncurrentDays())
{
xmlWriter.WriteElementString("NoncurrentDays", "", S3Transforms.ToXmlStringValue(noncurrentVersionExpiration.NoncurrentDays));
}
xmlWriter.WriteEndElement();
}
List <LifecycleRuleNoncurrentVersionTransition> noncurrentVersionTransitions = item.NoncurrentVersionTransitions;
if (noncurrentVersionTransitions != null && noncurrentVersionTransitions.Count > 0)
{
foreach (LifecycleRuleNoncurrentVersionTransition item3 in noncurrentVersionTransitions)
{
if (item3 != null)
{
xmlWriter.WriteStartElement("NoncurrentVersionTransition", "");
if (item3.IsSetNoncurrentDays())
{
xmlWriter.WriteElementString("NoncurrentDays", "", S3Transforms.ToXmlStringValue(item3.NoncurrentDays));
}
if (item3.IsSetStorageClass())
{
xmlWriter.WriteElementString("StorageClass", "", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(item3.StorageClass)));
}
xmlWriter.WriteEndElement();
}
}
}
LifecycleRuleAbortIncompleteMultipartUpload abortIncompleteMultipartUpload = item.AbortIncompleteMultipartUpload;
if (abortIncompleteMultipartUpload != null)
{
xmlWriter.WriteStartElement("AbortIncompleteMultipartUpload", "");
if (abortIncompleteMultipartUpload.IsSetDaysAfterInitiation())
{
xmlWriter.WriteElementString("DaysAfterInitiation", "", S3Transforms.ToXmlStringValue(abortIncompleteMultipartUpload.DaysAfterInitiation));
}
xmlWriter.WriteEndElement();
}
}
if (item.IsSetId())
{
xmlWriter.WriteElementString("ID", "", S3Transforms.ToXmlStringValue(item.Id));
}
if (item.IsSetPrefix() && item.IsSetFilter())
{
throw new AmazonClientException("LifecycleRule.Prefix is deprecated. Please only use LifecycleRule.Filter.");
}
if (item.IsSetPrefix())
{
xmlWriter.WriteElementString("Prefix", "", S3Transforms.ToXmlStringValue(item.Prefix));
}
if (item.IsSetFilter())
{
xmlWriter.WriteStartElement("Filter", "");
if (item.Filter.IsSetLifecycleFilterPredicate())
{
item.Filter.LifecycleFilterPredicate.Accept(new LifecycleFilterPredicateMarshallVisitor(xmlWriter));
}
xmlWriter.WriteEndElement();
}
if (item.IsSetStatus())
{
xmlWriter.WriteElementString("Status", "", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(item.Status)));
}
else
{
xmlWriter.WriteElementString("Status", "", "Disabled");
}
xmlWriter.WriteEndElement();
}
}
}
xmlWriter.WriteEndElement();
}
}
try
{
string text = stringWriter.ToString();
val.set_Content(Encoding.UTF8.GetBytes(text));
val.get_Headers()["Content-Type"] = "application/xml";
string value = AmazonS3Util.GenerateChecksumForContent(text, fBase64Encode: true);
val.get_Headers()["Content-MD5"] = value;
return(val);
}
catch (EncoderFallbackException ex)
{
throw new AmazonServiceException("Unable to marshall request to XML", (Exception)ex);
}
}
private static async Task AddUpdateDeleteLifecycleConfigAsync()
{
try
{
var lifeCycleConfiguration = new LifecycleConfiguration()
{
Rules = new List <LifecycleRule>
{
new LifecycleRule
{
Id = "Archive immediately rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "glacierobjects/"
}
},
Status = LifecycleRuleStatus.Enabled,
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 0,
StorageClass = S3StorageClass.Glacier
}
},
},
new LifecycleRule
{
Id = "Archive and then delete rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "projectdocs/"
}
},
Status = LifecycleRuleStatus.Enabled,
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 365,
StorageClass = S3StorageClass.Glacier
}
},
Expiration = new LifecycleRuleExpiration()
{
Days = 3650
}
}
}
};
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);
// Retrieve an existing configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
// Add a new rule.
lifeCycleConfiguration.Rules.Add(new LifecycleRule
{
Id = "NewRule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "YearlyDocuments/"
}
},
Expiration = new LifecycleRuleExpiration()
{
Days = 3650
}
});
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);
// Verify that there are now three rules.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
Console.WriteLine("Expected # of rulest=3; found:{0}", lifeCycleConfiguration.Rules.Count);
// Delete the configuration.
await RemoveLifecycleConfigAsync(client);
// Retrieve a nonexistent configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
public void LifecycleV2Test()
{
var s3Configuration = Client.GetLifecycleConfiguration(bucketName).Configuration;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(0, s3Configuration.Rules.Count);
var configuration = new LifecycleConfiguration
{
Rules = new List <LifecycleRule>
{
new LifecycleRule
{
Filter = new LifecycleFilter
{
LifecycleFilterPredicate = new LifecycleAndOperator
{
Operands = new List <LifecycleFilterPredicate>
{
new LifecycleObjectSizeGreaterThanPredicate
{
ObjectSizeGreaterThan = 132000
},
new LifecycleObjectSizeLessThanPredicate
{
ObjectSizeLessThan = 422000
}
}
}
},
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 90,
StorageClass = S3StorageClass.Glacier
}
}
}
}
};
Client.PutLifecycleConfiguration(new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
});
s3Configuration = S3TestUtils.WaitForConsistency(() =>
{
var res = Client.GetLifecycleConfiguration(bucketName);
return(res.Configuration?.Rules?.Count == configuration.Rules.Count ? res.Configuration : null);
});
string abortRuleId = null;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(configuration.Rules.Count, s3Configuration.Rules.Count);
for (int i = 0; i < configuration.Rules.Count; i++)
{
var s3Rule = s3Configuration.Rules[i];
var rule = configuration.Rules[i];
Assert.IsNotNull(rule);
Assert.IsNotNull(s3Rule);
if (rule.AbortIncompleteMultipartUpload != null)
{
abortRuleId = s3Rule.Id;
}
AssertRulesAreEqual(rule, s3Rule);
}
}
public void LifecycleTest()
{
var s3Configuration = Client.GetLifecycleConfiguration(bucketName).Configuration;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(0, s3Configuration.Rules.Count);
var configuration = new LifecycleConfiguration
{
Rules = new List<LifecycleRule>
{
new LifecycleRule
{
#pragma warning disable 618
Prefix = "rule1-",
#pragma warning restore 618
Status = LifecycleRuleStatus.Enabled,
Expiration = new LifecycleRuleExpiration
{
Days = 2,
},
#pragma warning disable 618
Transition = new LifecycleTransition
{
Days = 1,
StorageClass = S3StorageClass.Glacier
},
NoncurrentVersionTransition = new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 14,
StorageClass = S3StorageClass.Glacier
},
#pragma warning restore 618
AbortIncompleteMultipartUpload = new LifecycleRuleAbortIncompleteMultipartUpload
{
DaysAfterInitiation = 7
}
},
new LifecycleRule
{
#pragma warning disable 618
Prefix = "rule2-",
#pragma warning restore 618
Expiration = new LifecycleRuleExpiration
{
Days = 120
},
Transitions = new List<LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 90,
StorageClass = S3StorageClass.Glacier
}
},
NoncurrentVersionTransitions = new List<LifecycleRuleNoncurrentVersionTransition>
{
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 90,
StorageClass = S3StorageClass.Glacier
}
}
},
new LifecycleRule
{
#pragma warning disable 618
Prefix = "rule3-",
#pragma warning restore 618
Expiration = new LifecycleRuleExpiration
{
ExpiredObjectDeleteMarker = true
},
Transitions = new List<LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 90,
StorageClass = S3StorageClass.Glacier
}
},
NoncurrentVersionTransitions = new List<LifecycleRuleNoncurrentVersionTransition>
{
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 90,
StorageClass = S3StorageClass.Glacier
}
}
}
}
};
Client.PutLifecycleConfiguration(new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
});
s3Configuration = S3TestUtils.WaitForConsistency(() =>
{
var res = Client.GetLifecycleConfiguration(bucketName);
return res.Configuration?.Rules?.Count == configuration.Rules.Count ? res.Configuration : null;
});
string abortRuleId = null;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(configuration.Rules.Count, s3Configuration.Rules.Count);
for(int i=0;i<configuration.Rules.Count;i++)
{
var s3Rule = s3Configuration.Rules[i];
var rule = configuration.Rules[i];
Assert.IsNotNull(rule);
Assert.IsNotNull(s3Rule);
if (rule.AbortIncompleteMultipartUpload != null)
abortRuleId = s3Rule.Id;
AssertRulesAreEqual(rule, s3Rule);
}
Thread.Sleep(10000);
var expectedMinAbortDate = DateTime.Now.Date.AddDays(7);
var initResponse = Client.InitiateMultipartUpload(new InitiateMultipartUploadRequest
{
BucketName = bucketName,
Key = "rule1-123",
CannedACL = S3CannedACL.PublicRead
});
var listResponse = Client.ListParts(bucketName, initResponse.Key, initResponse.UploadId);
Assert.AreEqual(abortRuleId, initResponse.AbortRuleId);
Assert.AreEqual(abortRuleId, listResponse.AbortRuleId);
Assert.AreEqual(initResponse.AbortDate, listResponse.AbortDate);
Assert.IsTrue(expectedMinAbortDate < initResponse.AbortDate);
}
public static void Main(string[] args)
{
// create the AWS S3 client
AmazonS3Client s3 = AWSS3Factory.getS3Client();
String bucketName = String.Join("-", AWSS3Factory.S3_BUCKET, DateTime.Now.ToString("yyyyMMddHHmmss"));
//************************//
// 1. Create a bucket //
//************************//
Console.Write(string.Format(" [*] Creating bucket '{0}'... ", bucketName));
PutBucketResponse pbRes = s3.PutBucket(bucketName);
if (pbRes.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine("fail");
Console.ReadLine();
System.Environment.Exit(1);
}
Console.WriteLine("done");
//*************************************//
// 2. Configure bucket lifecycle rules //
//*************************************//
Console.Write(string.Format(" [*] Updating lifecycle configuration for bucket '{0}'... ", bucketName));
LifecycleConfiguration newConfiguration = new LifecycleConfiguration
{
Rules = new List <LifecycleRule>
{
// Rule to delete keys with prefix "Test-" after 5 days
new LifecycleRule
{
Prefix = "Test-",
Expiration = new LifecycleRuleExpiration {
Days = 5
},
Status = LifecycleRuleStatus.Enabled
},
// Rule to delete keys in subdirectory "Logs" after 2 days
new LifecycleRule
{
Prefix = "Logs/",
Expiration = new LifecycleRuleExpiration {
Days = 2
},
Id = "log-file-removal",
Status = LifecycleRuleStatus.Enabled
}
}
};
PutLifecycleConfigurationRequest plcReq = new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = newConfiguration
};
PutLifecycleConfigurationResponse plcRes = s3.PutLifecycleConfiguration(plcReq);
if (plcRes.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine("fail");
Console.ReadLine();
System.Environment.Exit(1);
}
Console.WriteLine("done");
//************************************************//
// 3. Retrieve the bucket lifecycle configuration //
//************************************************//
Console.Write(string.Format(" [*] Retrieving current lifecycle configuration for bucket '{0}'... ", bucketName));
GetLifecycleConfigurationResponse glcRes = s3.GetLifecycleConfiguration(bucketName);
if (glcRes.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine("fail");
Console.ReadLine();
System.Environment.Exit(1);
}
Console.WriteLine("done");
Console.WriteLine(String.Format(" [x] Configuration contains {0} rules", glcRes.Configuration.Rules.Count));
foreach (LifecycleRule rule in glcRes.Configuration.Rules)
{
Console.WriteLine(" [x] Rule:");
Console.WriteLine(" [x] Prefix = " + rule.Prefix);
Console.WriteLine(" [x] Expiration (days) = " + rule.Expiration.Days);
Console.WriteLine(" [x] Id = " + rule.Id);
Console.WriteLine(" [x] Status = " + rule.Status);
}
//**********************************************//
// 4. Delete the bucket lifecycle configuration //
//**********************************************//
Console.Write(String.Format(" [*] Deleting current lifecycle configuration for bucket '{0}'... ", bucketName));
DeleteLifecycleConfigurationResponse dlcRes = s3.DeleteLifecycleConfiguration(bucketName);
if (dlcRes.HttpStatusCode != System.Net.HttpStatusCode.NoContent)
{
Console.WriteLine("fail");
Console.ReadLine();
System.Environment.Exit(1);
}
Console.WriteLine("done");
Console.Write(String.Format(" [*] Verifying current lifecycle rules for bucket '{0}' are empty... ", bucketName));
LifecycleConfiguration configuration = s3.GetLifecycleConfiguration(bucketName).Configuration;
if (configuration.Rules.Count != 0)
{
Console.WriteLine("fail");
Console.ReadLine();
System.Environment.Exit(1);
}
Console.WriteLine("done");
//************************//
// 5. Delete the bucket //
//************************//
Console.Write(String.Format(" [*] Deleting bucket '{0}'... ", bucketName));
DeleteBucketResponse dbRes = s3.DeleteBucket(bucketName);
if (dbRes.HttpStatusCode != System.Net.HttpStatusCode.NoContent)
{
Console.WriteLine("fail");
Console.ReadLine();
System.Environment.Exit(1);
}
Console.WriteLine("done");
Console.WriteLine(" [*] Example is completed. Press any key to exit...");
Console.ReadLine();
}
public void PutLifecycleConfigurationAsync(string bucketName, LifecycleConfiguration configuration, AmazonServiceCallback <PutLifecycleConfigurationRequest, PutLifecycleConfigurationResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
/// <summary>
/// This method creates, adds, and then removes lifecycle information
/// to the S3 bucket named in the bucketName parameter.
/// </summary>
/// <param name="client">An S3 client object used to call methods
/// to add, check, and update configuration settings for the supplied
/// S3 bucket.</param>
/// <param name="bucketName">A string representing the name of the
/// bucket to add configuration settings.</param>
public static async Task AddUpdateDeleteLifecycleConfigAsync(IAmazonS3 client, string bucketName)
{
try
{
var lifeCycleConfiguration = new LifecycleConfiguration()
{
Rules = new List <LifecycleRule>
{
new LifecycleRule
{
Id = "Archive immediately rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "glacierobjects/",
},
},
Status = LifecycleRuleStatus.Enabled,
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 0,
StorageClass = S3StorageClass.Glacier,
},
},
},
new LifecycleRule
{
Id = "Archive and then delete rule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "projectdocs/",
},
},
Status = LifecycleRuleStatus.Enabled,
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess,
},
new LifecycleTransition
{
Days = 365,
StorageClass = S3StorageClass.Glacier,
},
},
Expiration = new LifecycleRuleExpiration()
{
Days = 3650,
},
},
},
};
// Add the configuration to the bucket.
await AddExampleLifecycleConfigAsync(client, bucketName, lifeCycleConfiguration);
// Retrieve the existing configuration to show that the configuration
// was added.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client, bucketName);
// Add another rule to the existing lifecycle rule.
lifeCycleConfiguration.Rules.Add(new LifecycleRule
{
Id = "NewRule",
Filter = new LifecycleFilter()
{
LifecycleFilterPredicate = new LifecyclePrefixPredicate()
{
Prefix = "YearlyDocuments/",
},
},
Expiration = new LifecycleRuleExpiration()
{
Days = 3650,
},
});
// Add the lifecycle configuration to the S3 bucket.
await AddExampleLifecycleConfigAsync(client, bucketName, lifeCycleConfiguration);
// Verify that the the bucket now has three rules in its lifecycle configuration.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client, bucketName);
Console.WriteLine($"Expected # of rulest: 3; # of rules found: {lifeCycleConfiguration.Rules.Count}");
// Now delete the configuration from the S3 bucket.
await RemoveLifecycleConfigAsync(client, bucketName);
// Show that the lifecycle configuration is no longer associated with
// the S3 bucket.
lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client, bucketName);
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Error encountered ***. Message:'{ex.Message}' when writing an object.");
}
}
public Task <PutLifecycleConfigurationResponse> PutLifecycleConfigurationAsync(string bucketName, LifecycleConfiguration configuration, CancellationToken cancellationToken = default)
{
throw new NotImplementedException();
}
public void LifecycleTest1()
{
var s3Configuration = Client.GetLifecycleConfiguration(bucketName).Configuration;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(0, s3Configuration.Rules.Count);
var configuration = new LifecycleConfiguration
{
Rules = new List <LifecycleRule>
{
new LifecycleRule
{
Prefix = "rule1-",
Expiration = new LifecycleRuleExpiration
{
Days = 2
},
#pragma warning disable 618
Transition = new LifecycleTransition
{
Days = 1,
StorageClass = S3StorageClass.Glacier
},
NoncurrentVersionTransition = new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 14,
StorageClass = S3StorageClass.Glacier
}
#pragma warning restore 618
},
new LifecycleRule
{
Prefix = "rule2-",
Expiration = new LifecycleRuleExpiration
{
Days = 120
},
Transitions = new List <LifecycleTransition>
{
new LifecycleTransition
{
Days = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleTransition
{
Days = 90,
StorageClass = S3StorageClass.Glacier
}
},
NoncurrentVersionTransitions = new List <LifecycleRuleNoncurrentVersionTransition>
{
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 30,
StorageClass = S3StorageClass.StandardInfrequentAccess
},
new LifecycleRuleNoncurrentVersionTransition
{
NoncurrentDays = 90,
StorageClass = S3StorageClass.Glacier
}
}
},
}
};
Client.PutLifecycleConfiguration(new PutLifecycleConfigurationRequest
{
BucketName = bucketName,
Configuration = configuration
});
s3Configuration = Client.GetLifecycleConfiguration(bucketName).Configuration;
Assert.IsNotNull(s3Configuration);
Assert.IsNotNull(s3Configuration.Rules);
Assert.AreEqual(configuration.Rules.Count, s3Configuration.Rules.Count);
for (int i = 0; i < configuration.Rules.Count; i++)
{
var rule = configuration.Rules[i];
Assert.IsNotNull(rule);
var s3Rule = s3Configuration.Rules[i];
Assert.IsNotNull(s3Rule);
Assert.AreEqual(rule.Transitions.Count, s3Rule.Transitions.Count);
Assert.AreEqual(rule.NoncurrentVersionTransitions.Count, s3Rule.NoncurrentVersionTransitions.Count);
#pragma warning disable 618
Assert.AreEqual(rule.Transition.Days, s3Rule.Transition.Days);
Assert.AreEqual(rule.NoncurrentVersionTransition.NoncurrentDays, s3Rule.NoncurrentVersionTransition.NoncurrentDays);
#pragma warning restore 618
}
}
