/// 获取存储桶清单任务
public void GetBucketInventory()
{
//.cssg-snippet-body-start:[get-bucket-inventory]
try
{
string inventoryId = "aInventoryId";
string bucket = "examplebucket-1250000000"; //格式：BucketName-APPID
GetBucketInventoryRequest getRequest = new GetBucketInventoryRequest(bucket);
getRequest.SetInventoryId(inventoryId);
GetBucketInventoryResult getResult = cosXml.getBucketInventory(getRequest);
InventoryConfiguration configuration = getResult.inventoryConfiguration;
}
catch (COSXML.CosException.CosClientException clientEx)
{
//请求失败
Console.WriteLine("CosClientException: " + clientEx);
}
catch (COSXML.CosException.CosServerException serverEx)
{
//请求失败
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
}
//.cssg-snippet-body-end
}
private static void GetBucketInventoryAndValidate(InventoryConfiguration getInventoryConfiguration, InventoryConfiguration putInventoryConfiguration)
{
Assert.AreEqual(getInventoryConfiguration.InventoryId, putInventoryConfiguration.InventoryId);
Assert.IsTrue(getInventoryConfiguration.IsEnabled);
Assert.AreEqual(getInventoryConfiguration.Schedule.Frequency, putInventoryConfiguration.Schedule.Frequency);
Assert.AreEqual(((InventoryPrefixPredicate)getInventoryConfiguration.InventoryFilter.InventoryFilterPredicate).Prefix, "string");
Assert.AreEqual(getInventoryConfiguration.IncludedObjectVersions, putInventoryConfiguration.IncludedObjectVersions);
CollectionAssert.AreEqual(getInventoryConfiguration.InventoryOptionalFields, putInventoryConfiguration.InventoryOptionalFields);
}
public PutBucketInventoryRequest(string bucket, string id) : base(bucket)
{
this.method = CosRequestMethod.PUT;
this.queryParameters.Add("inventory", null);
this.queryParameters.Add("id", id);
inventoryConfiguration = new InventoryConfiguration();
inventoryConfiguration.isEnabled = true;
inventoryConfiguration.id = id;
inventoryConfiguration.schedule = new InventoryConfiguration.Schedule();
inventoryConfiguration.destination = new InventoryConfiguration.Destination();
inventoryConfiguration.destination.cosBucketDestination = new InventoryConfiguration.COSBucketDestination();
}
public void ListBucketInventoryConfigurationTest()
{
//clear all inventory configurations first
_ossClient.DeleteBucketInventoryConfiguration(new DeleteBucketInventoryConfigurationRequest(_bucketName, "report1"));
int total = 104;
for (int i = 0; i < total; i++)
{
var config = new InventoryConfiguration();
config.Id = "test" + i.ToString("D4");
config.IsEnabled = (i % 4 == 0) ? true:false;
config.Filter = (i % 4 != 0) ? new InventoryFilter("filterPrefix" + i.ToString("D4")) : null;
config.Destination = new InventoryDestination();
config.Destination.OSSBucketDestination = new InventoryOSSBucketDestination();
config.Destination.OSSBucketDestination.Format = InventoryFormat.CSV;
config.Destination.OSSBucketDestination.AccountId = Config.RamUID;
config.Destination.OSSBucketDestination.RoleArn = Config.RamRoleArn;
config.Destination.OSSBucketDestination.Bucket = _bucketName2;
config.Destination.OSSBucketDestination.Prefix = "prefix" + i.ToString("D4");
config.Schedule = new InventorySchedule(InventoryFrequency.Daily);
config.IncludedObjectVersions = InventoryIncludedObjectVersions.All;
_ossClient.SetBucketInventoryConfiguration(new SetBucketInventoryConfigurationRequest(_bucketName, config));
}
var result = _ossClient.ListBucketInventoryConfiguration(new ListBucketInventoryConfigurationRequest(_bucketName, ""));
var configs = OssTestUtils.ToArray(result.Configurations);
Assert.AreEqual(configs.Count, 100);
Assert.AreEqual(result.IsTruncated, true);
Assert.AreEqual(result.NextContinuationToken, "test" + 99.ToString("D4"));
Assert.AreEqual(configs[0].Id, "test" + 0.ToString("D4"));
Assert.AreEqual(configs[99].Id, "test" + 99.ToString("D4"));
result = _ossClient.ListBucketInventoryConfiguration(new ListBucketInventoryConfigurationRequest(_bucketName, result.NextContinuationToken));
configs = OssTestUtils.ToArray(result.Configurations);
Assert.AreEqual(configs.Count, 4);
Assert.AreEqual(result.IsTruncated, false);
Assert.AreEqual(result.NextContinuationToken, null);
Assert.AreEqual(configs[0].Id, "test" + 100.ToString("D4"));
Assert.AreEqual(configs[3].Id, "test" + 103.ToString("D4"));
result = _ossClient.ListBucketInventoryConfiguration(new ListBucketInventoryConfigurationRequest(_bucketName, null));
configs = OssTestUtils.ToArray(result.Configurations);
Assert.AreEqual(configs.Count, 100);
Assert.AreEqual(result.IsTruncated, true);
Assert.AreEqual(result.NextContinuationToken, "test" + 99.ToString("D4"));
Assert.AreEqual(configs[0].Id, "test" + 0.ToString("D4"));
Assert.AreEqual(configs[99].Id, "test" + 99.ToString("D4"));
}
/// <summary>
/// Requests that the system create blank files for a new project.
/// </summary>
internal static void CreateTemplateFiles()
{
#region Write Configuration
PronounGroup.PutRecords(Enumerable.Empty <PronounGroup>());
BiomeConfiguration.PutRecord();
CraftConfiguration.PutRecord();
InventoryConfiguration.PutRecord();
RoomConfiguration.PutRecord();
#endregion
#region Write Models
ModelCollection <GameModel> .Default.PutRecordsForType <GameModel>();
ModelCollection <ParquetModel> .Default.PutRecordsForType <FloorModel>();
ModelCollection <ParquetModel> .Default.PutRecordsForType <BlockModel>();
ModelCollection <ParquetModel> .Default.PutRecordsForType <FurnishingModel>();
ModelCollection <ParquetModel> .Default.PutRecordsForType <CollectibleModel>();
ModelCollection <BeingModel> .Default.PutRecordsForType <CritterModel>();
ModelCollection <BeingModel> .Default.PutRecordsForType <CharacterModel>();
ModelCollection <BiomeRecipe> .Default.PutRecordsForType <BiomeRecipe>();
ModelCollection <CraftingRecipe> .Default.PutRecordsForType <CraftingRecipe>();
ModelCollection <RoomRecipe> .Default.PutRecordsForType <RoomRecipe>();
ModelCollection <RegionModel> .Default.PutRecordsForType <RegionModel>();
ModelCollection <ScriptModel> .Default.PutRecordsForType <ScriptModel>();
ModelCollection <InteractionModel> .Default.PutRecordsForType <InteractionModel>();
ModelCollection <ItemModel> .Default.PutRecordsForType <ItemModel>();
#endregion
}
public void TestBucketInventory()
{
try
{
string inventoryId = "id1";
PutBucketInventoryRequest putRequest = new PutBucketInventoryRequest(bucket, inventoryId);
putRequest.IsEnable(true);
putRequest.SetScheduleFrequency("Daily");
putRequest.SetIncludedObjectVersions("All");
putRequest.SetDestination("CSV", QCloudServer.Instance().uin, QCloudServer.Instance().bucketForObjectTest, region, "list1");
putRequest.SetFilter("dir/");
putRequest.SetOptionalFields("SIZE");
putRequest.SetOptionalFields("ETag");
putRequest.EnableSSE();
PutBucketInventoryResult putResult = cosXml.PutBucketInventory(putRequest);
Assert.IsTrue(putResult.httpCode == 200);
GetBucketInventoryRequest getRequest = new GetBucketInventoryRequest(bucket);
getRequest.SetInventoryId(inventoryId);
GetBucketInventoryResult getResult = cosXml.GetBucketInventory(getRequest);
InventoryConfiguration testConfig = getResult.inventoryConfiguration;
// Console.WriteLine(getResult.GetResultInfo());
Assert.IsNotEmpty((getResult.GetResultInfo()));
ListBucketInventoryRequest listRequest = new ListBucketInventoryRequest(bucket);
ListBucketInventoryResult listResult = cosXml.ListBucketInventory(listRequest);
Assert.IsTrue(listResult.httpCode == 200);
Assert.NotNull(listResult.GetResultInfo());
Assert.IsEmpty(listResult.listInventoryConfiguration.continuationToken);
Assert.False(listResult.listInventoryConfiguration.isTruncated);
Assert.AreEqual(listResult.listInventoryConfiguration.inventoryConfigurations.Count, 1);
InventoryConfiguration testConfig2 = listResult.listInventoryConfiguration.inventoryConfigurations[0];
InventoryConfiguration[] configurations = new InventoryConfiguration[] { testConfig, testConfig2 };
foreach (InventoryConfiguration configuration in configurations)
{
Assert.NotNull(configuration);
Assert.NotNull(configuration.destination.cosBucketDestination.accountId);
Assert.NotNull(configuration.destination.cosBucketDestination.bucket);
Assert.NotNull(configuration.destination.cosBucketDestination.encryption.sSECOS);
Assert.NotNull(configuration.destination.cosBucketDestination.format);
Assert.NotNull(configuration.destination.cosBucketDestination.prefix);
Assert.True(configuration.isEnabled);
Assert.NotNull(configuration.schedule.frequency);
Assert.NotNull(configuration.includedObjectVersions);
Assert.NotNull(configuration.filter.prefix);
Assert.AreEqual(configuration.optionalFields.fields.Count, 2);
}
DeleteBucketInventoryRequest deleteRequest = new DeleteBucketInventoryRequest(bucket);
deleteRequest.SetInventoryId(inventoryId);
DeleteBucketInventoryResult deleteResult = cosXml.DeleteBucketInventory(deleteRequest);
Assert.IsTrue(putResult.httpCode == 200);
}
catch (COSXML.CosException.CosClientException clientEx)
{
Console.WriteLine("CosClientException: " + clientEx.Message);
Assert.Fail();
}
catch (COSXML.CosException.CosServerException serverEx)
{
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
if (serverEx.statusCode != 409 && serverEx.statusCode != 451)
{
Assert.Fail();
}
}
}
public static string BuildInventoryConfiguration(InventoryConfiguration inventoryConfiguration)
{
StringWriter stringWriter = new StringWriter();
XmlWriterSettings xmlWriterSetting = new XmlWriterSettings();
xmlWriterSetting.Indent = true;
XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSetting);
xmlWriter.WriteStartDocument();
xmlWriter.WriteStartElement("InventoryConfiguration");
if (inventoryConfiguration.id != null)
{
xmlWriter.WriteElementString("Id", inventoryConfiguration.id);
}
xmlWriter.WriteElementString("IsEnabled", inventoryConfiguration.isEnabled ? "true" : "false");
if (inventoryConfiguration.destination != null)
{
xmlWriter.WriteStartElement("Destination");
if (inventoryConfiguration.destination.cosBucketDestination != null)
{
xmlWriter.WriteStartElement("COSBucketDestination");
if (inventoryConfiguration.destination.cosBucketDestination.format != null)
{
xmlWriter.WriteElementString("Format", inventoryConfiguration.destination.cosBucketDestination.format);
}
if (inventoryConfiguration.destination.cosBucketDestination.accountId != null)
{
xmlWriter.WriteElementString("AccountId", inventoryConfiguration.destination.cosBucketDestination.accountId);
}
if (inventoryConfiguration.destination.cosBucketDestination.bucket != null)
{
xmlWriter.WriteElementString("Bucket", inventoryConfiguration.destination.cosBucketDestination.bucket);
}
if (inventoryConfiguration.destination.cosBucketDestination.prefix != null)
{
xmlWriter.WriteElementString("Prefix", inventoryConfiguration.destination.cosBucketDestination.prefix);
}
if (inventoryConfiguration.destination.cosBucketDestination.encryption != null)
{
xmlWriter.WriteStartElement("Encryption");
xmlWriter.WriteElementString("SSE-COS", inventoryConfiguration.destination.cosBucketDestination.encryption.sSECOS);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
if (inventoryConfiguration.schedule != null && inventoryConfiguration.schedule.frequency != null)
{
xmlWriter.WriteStartElement("Schedule");
xmlWriter.WriteElementString("Frequency", inventoryConfiguration.schedule.frequency);
xmlWriter.WriteEndElement();
}
if (inventoryConfiguration.filter != null && inventoryConfiguration.filter.prefix != null)
{
xmlWriter.WriteStartElement("Filter");
xmlWriter.WriteElementString("Prefix", inventoryConfiguration.filter.prefix);
xmlWriter.WriteEndElement();
}
if (inventoryConfiguration.includedObjectVersions != null)
{
xmlWriter.WriteElementString("IncludedObjectVersions", inventoryConfiguration.includedObjectVersions);
}
if (inventoryConfiguration.optionalFields != null && inventoryConfiguration.optionalFields.fields != null)
{
xmlWriter.WriteStartElement("OptionalFields");
foreach (string field in inventoryConfiguration.optionalFields.fields)
{
xmlWriter.WriteElementString("Field", field);
}
xmlWriter.WriteEndElement();
}
// end to element
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
return(RemoveXMLHeader(stringWriter.ToString()));
}
internal override void ParseResponseBody(System.IO.Stream inputStream, string contentType, long contentLength)
{
inventoryConfiguration = new InventoryConfiguration();
XmlParse.ParseInventoryConfiguration(inputStream, inventoryConfiguration);
}
/// <summary>
/// Creates a instance of <see cref="SetBucketInventoryConfigurationRequest" />.
/// </summary>
/// <param name="bucketName">bucket name</param>
/// <param name="configuration">inventory configuration</param>
public SetBucketInventoryConfigurationRequest(string bucketName, InventoryConfiguration configuration)
{
BucketName = bucketName;
Configuration = configuration;
}
public IRequest Marshall(PutBucketInventoryConfigurationRequest putBucketInventoryConfigurationRequest)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_0360: Unknown result type (might be due to invalid IL or missing references)
IRequest val = new DefaultRequest(putBucketInventoryConfigurationRequest, "AmazonS3");
val.set_HttpMethod("PUT");
val.set_ResourcePath("/" + S3Transforms.ToStringValue(putBucketInventoryConfigurationRequest.BucketName));
val.AddSubResource("inventory");
if (putBucketInventoryConfigurationRequest.IsSetInventoryId())
{
val.AddSubResource("id", S3Transforms.ToStringValue(putBucketInventoryConfigurationRequest.InventoryId));
}
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings
{
Encoding = Encoding.UTF8,
OmitXmlDeclaration = true
}))
{
if (putBucketInventoryConfigurationRequest.IsSetInventoryConfiguration())
{
InventoryConfiguration inventoryConfiguration = putBucketInventoryConfigurationRequest.InventoryConfiguration;
xmlWriter.WriteStartElement("InventoryConfiguration", "http://s3.amazonaws.com/doc/2006-03-01/");
if (inventoryConfiguration != null)
{
if (inventoryConfiguration.IsSetDestination())
{
InventoryDestination destination = inventoryConfiguration.Destination;
xmlWriter.WriteStartElement("Destination", "http://s3.amazonaws.com/doc/2006-03-01/");
if (destination.isSetS3BucketDestination())
{
InventoryS3BucketDestination s3BucketDestination = destination.S3BucketDestination;
xmlWriter.WriteStartElement("S3BucketDestination", "http://s3.amazonaws.com/doc/2006-03-01/");
if (s3BucketDestination.IsSetAccountId())
{
xmlWriter.WriteElementString("AccountId", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(s3BucketDestination.AccountId));
}
if (s3BucketDestination.IsSetBucketName())
{
xmlWriter.WriteElementString("Bucket", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(s3BucketDestination.BucketName));
}
if (s3BucketDestination.IsSetInventoryFormat())
{
xmlWriter.WriteElementString("Format", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(s3BucketDestination.InventoryFormat)));
}
if (s3BucketDestination.IsSetPrefix())
{
xmlWriter.WriteElementString("Prefix", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(s3BucketDestination.Prefix));
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteElementString("IsEnabled", "http://s3.amazonaws.com/doc/2006-03-01/", inventoryConfiguration.IsEnabled.ToString().ToLowerInvariant());
if (inventoryConfiguration.IsSetInventoryFilter())
{
xmlWriter.WriteStartElement("Filter", "http://s3.amazonaws.com/doc/2006-03-01/");
inventoryConfiguration.InventoryFilter.InventoryFilterPredicate.Accept(new InventoryPredicateVisitor(xmlWriter));
xmlWriter.WriteEndElement();
}
if (inventoryConfiguration.IsSetInventoryId())
{
xmlWriter.WriteElementString("Id", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(inventoryConfiguration.InventoryId));
}
if (inventoryConfiguration.IsSetIncludedObjectVersions())
{
xmlWriter.WriteElementString("IncludedObjectVersions", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(inventoryConfiguration.IncludedObjectVersions)));
}
if (inventoryConfiguration.IsSetInventoryOptionalFields())
{
xmlWriter.WriteStartElement("OptionalFields", "http://s3.amazonaws.com/doc/2006-03-01/");
foreach (InventoryOptionalField inventoryOptionalField in inventoryConfiguration.InventoryOptionalFields)
{
xmlWriter.WriteElementString("Field", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(inventoryOptionalField)));
}
xmlWriter.WriteEndElement();
}
if (inventoryConfiguration.IsSetSchedule())
{
xmlWriter.WriteStartElement("Schedule", "http://s3.amazonaws.com/doc/2006-03-01/");
InventorySchedule schedule = inventoryConfiguration.Schedule;
if (schedule.IsFrequency())
{
xmlWriter.WriteElementString("Frequency", "http://s3.amazonaws.com/doc/2006-03-01/", S3Transforms.ToXmlStringValue(ConstantClass.op_Implicit(schedule.Frequency)));
}
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);
}
}
public void BucketInventoryConfigurationBasicTest()
{
//test case 1
var config = new InventoryConfiguration();
config.Id = "report1";
config.IsEnabled = true;
config.Filter = new InventoryFilter("filterPrefix");
config.Destination = new InventoryDestination();
config.Destination.OSSBucketDestination = new InventoryOSSBucketDestination();
config.Destination.OSSBucketDestination.Format = InventoryFormat.CSV;
config.Destination.OSSBucketDestination.AccountId = Config.RamUID;
config.Destination.OSSBucketDestination.RoleArn = Config.RamRoleArn;
config.Destination.OSSBucketDestination.Bucket = _bucketName2;
config.Destination.OSSBucketDestination.Prefix = "prefix1";
config.Destination.OSSBucketDestination.Encryption = new InventoryEncryption(new InventorySSEKMS("keyId"));
config.Schedule = new InventorySchedule(InventoryFrequency.Daily);
config.IncludedObjectVersions = InventoryIncludedObjectVersions.All;
config.OptionalFields.Add(InventoryOptionalField.Size);
config.OptionalFields.Add(InventoryOptionalField.LastModifiedDate);
config.OptionalFields.Add(InventoryOptionalField.StorageClass);
config.OptionalFields.Add(InventoryOptionalField.IsMultipartUploaded);
config.OptionalFields.Add(InventoryOptionalField.EncryptionStatus);
config.OptionalFields.Add(InventoryOptionalField.ETag);
_ossClient.SetBucketInventoryConfiguration(new SetBucketInventoryConfigurationRequest(_bucketName, config));
var result = _ossClient.GetBucketInventoryConfiguration(new GetBucketInventoryConfigurationRequest(_bucketName, config.Id));
Assert.AreEqual(result.Configuration.Id, "report1");
Assert.AreEqual(result.Configuration.IsEnabled, true);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Format, InventoryFormat.CSV);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.AccountId, Config.RamUID);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.RoleArn, Config.RamRoleArn);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Bucket, _bucketName2);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Prefix, "prefix1");
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Encryption.SSEOSS, null);
Assert.AreNotEqual(result.Configuration.Destination.OSSBucketDestination.Encryption.SSEKMS, null);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Encryption.SSEKMS.KeyId, "keyId");
Assert.AreEqual(result.Configuration.Schedule.Frequency, InventoryFrequency.Daily);
Assert.AreEqual(result.Configuration.Filter.Prefix, "filterPrefix");
Assert.AreEqual(result.Configuration.IncludedObjectVersions, InventoryIncludedObjectVersions.All);
Assert.AreEqual(result.Configuration.OptionalFields.Count, 6);
Assert.AreEqual(result.Configuration.OptionalFields[0], InventoryOptionalField.Size);
Assert.AreEqual(result.Configuration.OptionalFields[1], InventoryOptionalField.LastModifiedDate);
Assert.AreEqual(result.Configuration.OptionalFields[2], InventoryOptionalField.StorageClass);
Assert.AreEqual(result.Configuration.OptionalFields[3], InventoryOptionalField.IsMultipartUploaded);
Assert.AreEqual(result.Configuration.OptionalFields[4], InventoryOptionalField.EncryptionStatus);
Assert.AreEqual(result.Configuration.OptionalFields[5], InventoryOptionalField.ETag);
_ossClient.DeleteBucketInventoryConfiguration(new DeleteBucketInventoryConfigurationRequest(_bucketName, config.Id));
//test case 2
config = new InventoryConfiguration();
config.Id = "report1";
config.IsEnabled = false;
config.Filter = new InventoryFilter("filterPrefix");
config.Destination = new InventoryDestination();
config.Destination.OSSBucketDestination = new InventoryOSSBucketDestination();
config.Destination.OSSBucketDestination.Format = InventoryFormat.CSV;
config.Destination.OSSBucketDestination.AccountId = Config.RamUID;
config.Destination.OSSBucketDestination.RoleArn = Config.RamRoleArn;
config.Destination.OSSBucketDestination.Bucket = _bucketName2;
config.Destination.OSSBucketDestination.Prefix = "prefix1";
config.Destination.OSSBucketDestination.Encryption = new InventoryEncryption(new InventorySSEOSS());
config.Schedule = new InventorySchedule(InventoryFrequency.Weekly);
config.IncludedObjectVersions = InventoryIncludedObjectVersions.Current;
config.OptionalFields.Add(InventoryOptionalField.StorageClass);
_ossClient.SetBucketInventoryConfiguration(new SetBucketInventoryConfigurationRequest(_bucketName, config));
result = _ossClient.GetBucketInventoryConfiguration(new GetBucketInventoryConfigurationRequest(_bucketName, config.Id));
Assert.AreEqual(result.Configuration.Id, "report1");
Assert.AreEqual(result.Configuration.IsEnabled, false);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Format, InventoryFormat.CSV);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.AccountId, Config.RamUID);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.RoleArn, Config.RamRoleArn);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Bucket, _bucketName2);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Prefix, "prefix1");
Assert.AreNotEqual(result.Configuration.Destination.OSSBucketDestination.Encryption.SSEOSS, null);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Encryption.SSEKMS, null);
Assert.AreEqual(result.Configuration.Schedule.Frequency, InventoryFrequency.Weekly);
Assert.AreEqual(result.Configuration.Filter.Prefix, "filterPrefix");
Assert.AreEqual(result.Configuration.IncludedObjectVersions, InventoryIncludedObjectVersions.Current);
Assert.AreEqual(result.Configuration.OptionalFields.Count, 1);
Assert.AreEqual(result.Configuration.OptionalFields[0], InventoryOptionalField.StorageClass);
_ossClient.DeleteBucketInventoryConfiguration(new DeleteBucketInventoryConfigurationRequest(_bucketName, config.Id));
//test case 3
config = new InventoryConfiguration();
config.Id = "report1";
config.IsEnabled = false;
config.Destination = new InventoryDestination();
config.Destination.OSSBucketDestination = new InventoryOSSBucketDestination();
config.Destination.OSSBucketDestination.Format = InventoryFormat.CSV;
config.Destination.OSSBucketDestination.AccountId = Config.RamUID;
config.Destination.OSSBucketDestination.RoleArn = Config.RamRoleArn;
config.Destination.OSSBucketDestination.Bucket = _bucketName2;
config.Destination.OSSBucketDestination.Prefix = "prefix1";
config.Schedule = new InventorySchedule(InventoryFrequency.Weekly);
config.IncludedObjectVersions = InventoryIncludedObjectVersions.Current;
_ossClient.SetBucketInventoryConfiguration(new SetBucketInventoryConfigurationRequest(_bucketName, config));
result = _ossClient.GetBucketInventoryConfiguration(new GetBucketInventoryConfigurationRequest(_bucketName, config.Id));
Assert.AreEqual(result.Configuration.Id, "report1");
Assert.AreEqual(result.Configuration.IsEnabled, false);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Format, InventoryFormat.CSV);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.AccountId, Config.RamUID);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.RoleArn, Config.RamRoleArn);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Bucket, _bucketName2);
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Prefix, "prefix1");
Assert.AreEqual(result.Configuration.Destination.OSSBucketDestination.Encryption, null);
Assert.AreEqual(result.Configuration.Schedule.Frequency, InventoryFrequency.Weekly);
Assert.AreEqual(result.Configuration.Filter.Prefix, "");
Assert.AreEqual(result.Configuration.IncludedObjectVersions, InventoryIncludedObjectVersions.Current);
Assert.AreEqual(result.Configuration.OptionalFields.Count, 0);
_ossClient.DeleteBucketInventoryConfiguration(new DeleteBucketInventoryConfigurationRequest(_bucketName, config.Id));
try
{
_ossClient.GetBucketInventoryConfiguration(new GetBucketInventoryConfigurationRequest(_bucketName, config.Id));
Assert.Fail("should not here");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "NoSuchInventory");
}
}
internal static InventoryConfiguration ToInventoryConfiguration(InventoryConfigurationModel model)
{
var config = new InventoryConfiguration()
{
Id = model.Id,
IsEnabled = model.IsEnabled,
IncludedObjectVersions = model.IncludedObjectVersions,
};
if (model.Schedule != null)
{
config.Schedule = new InventorySchedule(model.Schedule.Frequency);
}
if (model.Filter != null)
{
config.Filter = new InventoryFilter(model.Filter.Prefix);
}
if (model.Destination != null && model.Destination.OSSBucketDestination != null)
{
var ossDst = new InventoryOSSBucketDestination
{
Format = model.Destination.OSSBucketDestination.Format,
AccountId = model.Destination.OSSBucketDestination.AccountId,
RoleArn = model.Destination.OSSBucketDestination.RoleArn,
Bucket = ToInventoryBucketShortName(model.Destination.OSSBucketDestination.Bucket),
Prefix = model.Destination.OSSBucketDestination.Prefix
};
if (model.Destination.OSSBucketDestination.Encryption != null)
{
if (model.Destination.OSSBucketDestination.Encryption.SSEKMS != null)
{
ossDst.Encryption = new InventoryEncryption(
new InventorySSEKMS(model.Destination.OSSBucketDestination.Encryption.SSEKMS.KeyId));
}
else if (model.Destination.OSSBucketDestination.Encryption.SSEOSS != null)
{
ossDst.Encryption = new InventoryEncryption(new InventorySSEOSS());
}
else
{
ossDst.Encryption = new InventoryEncryption();
}
}
config.Destination = new InventoryDestination()
{
OSSBucketDestination = ossDst
};
}
var fields = new List <InventoryOptionalField>();
if (model.OptionalFields != null && model.OptionalFields.Fields != null)
{
foreach (var e in model.OptionalFields.Fields)
{
fields.Add(e);
}
}
config.OptionalFields = fields;
return(config);
}
