public async Task MoreThanMaxKeys()
{
await CreateTempBucketAsync(async bucket =>
{
int concurrent = 10;
int count = 1001;
Queue <Task> tasks = new Queue <Task>(count);
using (SemaphoreSlim semaphore = new SemaphoreSlim(concurrent))
{
for (int i = 0; i < count; i++)
{
await semaphore.WaitAsync().ConfigureAwait(false);
string tempObjName = "object-" + Guid.NewGuid();
tasks.Enqueue(UploadString(bucket, tempObjName, semaphore));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
GetBucketResponse gResp = await BucketClient.GetBucketAsync(bucket).ConfigureAwait(false);
Assert.True(gResp.IsSuccess);
Assert.Equal(1000, gResp.KeyCount);
Assert.Equal(1000, gResp.Objects.Count);
Assert.NotEmpty(gResp.NextContinuationToken);
Assert.True(gResp.IsTruncated);
}).ConfigureAwait(false);
}
public async Task GetWithPrefix()
{
await CreateTempBucketAsync(async bucket =>
{
string tempObjName = "object-" + Guid.NewGuid();
string tempObjName2 = "something-" + Guid.NewGuid();
await ObjectClient.PutObjectStringAsync(bucket, tempObjName, "hello").ConfigureAwait(false);
await ObjectClient.PutObjectStringAsync(bucket, tempObjName2, "world!").ConfigureAwait(false);
GetBucketResponse gResp = await BucketClient.GetBucketAsync(bucket, request => request.Prefix = "object").ConfigureAwait(false);
Assert.True(gResp.IsSuccess);
Assert.Equal(1, gResp.KeyCount);
Assert.Equal(1, gResp.Objects.Count);
Assert.Equal("object", gResp.Prefix);
Assert.Equal(tempObjName, gResp.Objects[0].Name);
Assert.Equal(DateTime.UtcNow, gResp.Objects[0].LastModified.DateTime, TimeSpan.FromSeconds(5));
Assert.Equal("\"5d41402abc4b2a76b9719d911017c592\"", gResp.Objects[0].ETag);
Assert.Equal(5, gResp.Objects[0].Size);
Assert.Equal(StorageClass.Standard, gResp.Objects[0].StorageClass);
}).ConfigureAwait(false);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
GetBucketResponse response = new GetBucketResponse();
UnmarshallResult(context, response);
return(response);
}
public async Task PutAndGet()
{
string tempBucketName = "testbucket-" + Guid.NewGuid();
PutBucketResponse pResp = await BucketClient.PutBucketAsync(tempBucketName, request =>
{
request.Region = Config.Region;
request.Acl = BucketCannedAcl.Private;
}).ConfigureAwait(false);
Assert.True(pResp.IsSuccess);
//We prefix with a number here to keep sort order when we download the list of objects further down
string tempObjName = "object-1" + Guid.NewGuid();
string tempObjName2 = "object-2" + Guid.NewGuid();
await ObjectClient.PutObjectStringAsync(tempBucketName, tempObjName, "hello").ConfigureAwait(false);
await ObjectClient.PutObjectStringAsync(tempBucketName, tempObjName2, "world!", null, request => request.StorageClass = StorageClass.OneZoneIa).ConfigureAwait(false);
GetBucketResponse gResp = await BucketClient.GetBucketAsync(tempBucketName).ConfigureAwait(false);
Assert.True(gResp.IsSuccess);
Assert.Equal(2, gResp.KeyCount);
Assert.Equal(2, gResp.Objects.Count);
Assert.Equal(string.Empty, gResp.Prefix);
Assert.Equal(tempObjName, gResp.Objects[0].Name);
Assert.Equal(DateTime.UtcNow, gResp.Objects[0].LastModified.DateTime, TimeSpan.FromSeconds(5));
Assert.Equal("\"5d41402abc4b2a76b9719d911017c592\"", gResp.Objects[0].ETag);
Assert.Equal(5, gResp.Objects[0].Size);
Assert.Equal(StorageClass.Standard, gResp.Objects[0].StorageClass);
Assert.Equal(tempObjName2, gResp.Objects[1].Name);
Assert.Equal(DateTime.UtcNow, gResp.Objects[1].LastModified.DateTime, TimeSpan.FromSeconds(5));
Assert.Equal("\"08cf82251c975a5e9734699fadf5e9c0\"", gResp.Objects[1].ETag);
Assert.Equal(6, gResp.Objects[1].Size);
Assert.Equal(StorageClass.OneZoneIa, gResp.Objects[1].StorageClass);
GetBucketResponse gResp2 = await BucketClient.GetBucketAsync(tempBucketName, request => request.EncodingType = EncodingType.Url).ConfigureAwait(false);
Assert.True(gResp2.IsSuccess);
Assert.Equal(2, gResp2.KeyCount);
//The keys should be URL encoded at this point
Assert.Equal(UrlHelper.UrlEncode(tempObjName), gResp.Objects[0].Name);
Assert.Equal(UrlHelper.UrlEncode(tempObjName2), gResp.Objects[1].Name);
}
public async Task GetWithOwner()
{
await CreateTempBucketAsync(async bucket =>
{
string tempObjName = "object-" + Guid.NewGuid();
await ObjectClient.PutObjectStringAsync(bucket, tempObjName, string.Empty, config: request => request.AclGrantFullControl.AddEmail(TestConstants.TestEmail)).ConfigureAwait(false);
GetBucketResponse gResp = await BucketClient.GetBucketAsync(bucket, request => request.FetchOwner = true).ConfigureAwait(false);
Assert.True(gResp.IsSuccess);
Assert.Equal(1, gResp.KeyCount);
S3Object obj = gResp.Objects.First();
Assert.Equal(TestConstants.TestUsername, obj.Owner.Name);
Assert.Equal(TestConstants.TestUserId, obj.Owner.Id);
}).ConfigureAwait(false);
}
public async Task GetWithDelimiter()
{
await CreateTempBucketAsync(async bucket =>
{
string tempObjName = "object-" + Guid.NewGuid();
string tempObjName2 = "something-" + Guid.NewGuid();
await ObjectClient.PutObjectStringAsync(bucket, tempObjName, "hello").ConfigureAwait(false);
await ObjectClient.PutObjectStringAsync(bucket, tempObjName2, "world!").ConfigureAwait(false);
GetBucketResponse gResp = await BucketClient.GetBucketAsync(bucket, request => request.Delimiter = "-").ConfigureAwait(false);
Assert.True(gResp.IsSuccess);
Assert.Equal(2, gResp.KeyCount);
Assert.Equal(2, gResp.CommonPrefixes.Count);
Assert.Equal("object-", gResp.CommonPrefixes[0]);
Assert.Equal("something-", gResp.CommonPrefixes[1]);
}).ConfigureAwait(false);
}
private static void UnmarshallResult(XmlUnmarshallerContext context, GetBucketResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 1;
}
while (context.Read())
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("Bucket", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.Bucket = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("CreationDate", targetDepth))
{
var unmarshaller = DateTimeUnmarshaller.Instance;
response.CreationDate = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("PublicAccessBlockEnabled", targetDepth))
{
var unmarshaller = BoolUnmarshaller.Instance;
response.PublicAccessBlockEnabled = unmarshaller.Unmarshall(context);
continue;
}
}
else if (context.IsEndElement && context.CurrentDepth < originalDepth)
{
return;
}
}
return;
}
public async Task DeleteBucket()
{
string tempBucketName = "testbucket-" + Guid.NewGuid();
DeleteBucketResponse delete1 = await BucketClient.DeleteBucketAsync(tempBucketName).ConfigureAwait(false);
Assert.False(delete1.IsSuccess);
Assert.Equal(ErrorCode.NoSuchBucket, delete1.Error.Code);
await BucketClient.PutBucketAsync(tempBucketName, request => request.Region = Config.Region).ConfigureAwait(false);
DeleteBucketResponse delete2 = await BucketClient.DeleteBucketAsync(tempBucketName).ConfigureAwait(false);
Assert.True(delete2.IsSuccess);
Assert.Equal(204, delete2.StatusCode);
GetBucketResponse resp = await BucketClient.GetBucketAsync(tempBucketName).ConfigureAwait(false);
Assert.False(resp.IsSuccess);
Assert.Equal(404, resp.StatusCode);
}
public static async Task MainOSBucketTagging()
{
string compartmentId = Environment.GetEnvironmentVariable("OCI_COMPARTMENT_ID");
string bucketName = Environment.GetEnvironmentVariable("BUCKET_NAME");
string tagNamespace = Environment.GetEnvironmentVariable("TAG_NAMESPACE");
string tagName = Environment.GetEnvironmentVariable("TAG_NAME");
logger.Info("Starting example");
// Create Object Storage Client
var provider = new ConfigFileAuthenticationDetailsProvider("DEFAULT");
var osClient = new ObjectStorageClient(provider, new ClientConfiguration());
logger.Info("Object Storage client created.");
GetNamespaceRequest getNamespaceRequest = new GetNamespaceRequest
{
CompartmentId = compartmentId
};
GetNamespaceResponse getNamespaceResponse = await osClient.GetNamespace(getNamespaceRequest);
string nSpace = getNamespaceResponse.Value.Trim('"');
logger.Info($"namespace is {nSpace}");
/*
* We can assign tags to a bucket at creation time. Like other taggable resources, we can
* assign freeform and defined tags to a bucket. Freeform tags are a dictionary of
* string-to-string, where the key is the tag name and the value is the tag value.
*
* Defined tags are a dictionary where the key is the tag namespace (string) and the value is another dictionary. In
* this second dictionary, the key is the tag name (string) and the value is the tag value. The tag names have to
* correspond to the name of a tag within the specified namespace (and the namespace must exist).
*/
try
{
Dictionary <string, string> freeformTags = new Dictionary <string, string>()
{
{ "free", "form" },
{ "another", "item" }
};
Dictionary <string, object> definedTagsMap = new Dictionary <string, object>()
{
{ tagName, "original value" }
};
Dictionary <string, Dictionary <string, object> > definedTags = new Dictionary <string, Dictionary <string, object> >()
{
{ tagNamespace, definedTagsMap }
};
CreateBucketDetails createBucketDetails = new CreateBucketDetails
{
Name = bucketName,
CompartmentId = compartmentId,
FreeformTags = freeformTags,
DefinedTags = definedTags,
ObjectEventsEnabled = false
};
CreateBucketRequest createBucketRequest = new CreateBucketRequest
{
CreateBucketDetails = createBucketDetails,
NamespaceName = nSpace
};
CreateBucketResponse createBucketResponse = await osClient.CreateBucket(createBucketRequest);
logger.Info($"Created a bucket with tags Bucket name: {createBucketResponse.Bucket.Name}");
logger.Info("========================================");
definedTags = createBucketResponse.Bucket.DefinedTags;
foreach (KeyValuePair <string, Dictionary <string, object> > kvp in definedTags)
{
foreach (KeyValuePair <string, object> tags in kvp.Value)
{
logger.Info($"tag key name: {tags.Key} and tag value is {tags.Value}");
}
}
// Tags come back when retrieving the bucket
GetBucketRequest getBucketRequest = new GetBucketRequest
{
NamespaceName = nSpace,
BucketName = bucketName
};
GetBucketResponse getBucketResponse = await osClient.GetBucket(getBucketRequest);
logger.Info($"Retrieved a bucket with tags Bucket name: {getBucketResponse.Bucket.Name}");
logger.Info("==========================================");
definedTags = getBucketResponse.Bucket.DefinedTags;
foreach (KeyValuePair <string, Dictionary <string, object> > kvp in definedTags)
{
foreach (KeyValuePair <string, object> tags in kvp.Value)
{
logger.Info($"tag key name: {tags.Key} and tag value is {tags.Value}");
}
}
/*
* Unlike other resources (e.g. instances, VCNs, and block volumes), when listing buckets
* tags are not returned by default. Instead, you need to provide a value to the fields
* parameter when listing buckets in order to have those tags returned.
*
* Here we can see the result of providing and not providing that parameter.
*/
ListBucketsRequest listBucketsRequest = new ListBucketsRequest
{
CompartmentId = compartmentId,
NamespaceName = nSpace
};
IEnumerable <BucketSummary> bucketSummaries = osClient.Paginators.ListBucketsRecordEnumerator(listBucketsRequest);
foreach (BucketSummary bucketSummary in bucketSummaries)
{
if (bucketSummary.Name.Equals(bucketName))
{
logger.Info($"Bucket summary without tags: Bucket Name: {bucketSummary.Name}");
logger.Info("=========================================");
if (bucketSummary.DefinedTags != null)
{
logger.Error($"expected tags to be zero but got: {bucketSummary.DefinedTags.Count}");
}
break;
}
}
List <ListBucketsRequest.FieldsEnum> fields = new List <ListBucketsRequest.FieldsEnum>()
{
ListBucketsRequest.FieldsEnum.Tags
};
listBucketsRequest = new ListBucketsRequest
{
CompartmentId = compartmentId,
NamespaceName = nSpace,
Fields = fields
};
bucketSummaries = osClient.Paginators.ListBucketsRecordEnumerator(listBucketsRequest);
foreach (BucketSummary bucketSummary in bucketSummaries)
{
if (bucketSummary.Name.Equals(bucketName))
{
logger.Info($"Bucket summary with tags: Bucket Name: {bucketSummary.Name}");
logger.Info("======================================");
definedTags = bucketSummary.DefinedTags;
foreach (KeyValuePair <string, Dictionary <string, object> > kvp in definedTags)
{
foreach (KeyValuePair <string, object> tags in kvp.Value)
{
logger.Info($"tag key name: {tags.Key} and tag value is {tags.Value}");
}
}
}
}
/*
* We can also update tags on a bucket. Note that this is a total replacement for any
* previously set freeform or defined tags.
*/
Dictionary <string, string> updateFreeformTags = new Dictionary <string, string>()
{
{ "new", "freeform" }
};
Dictionary <string, object> updateDefinedTagsMap = new Dictionary <string, object>()
{
{ tagName, "replaced" }
};
Dictionary <string, Dictionary <string, object> > updateDefinedTags = new Dictionary <string, Dictionary <string, object> >()
{
{ tagNamespace, updateDefinedTagsMap }
};
UpdateBucketDetails updateBucketDetails = new UpdateBucketDetails
{
Name = bucketName,
FreeformTags = updateFreeformTags,
DefinedTags = updateDefinedTags
};
UpdateBucketRequest updateBucketRequest = new UpdateBucketRequest
{
NamespaceName = nSpace,
BucketName = bucketName,
UpdateBucketDetails = updateBucketDetails
};
UpdateBucketResponse updateBucketResponse = await osClient.UpdateBucket(updateBucketRequest);
logger.Info($"Updated the bucket with new tags Bucket name: {updateBucketResponse.Bucket.Name}");
logger.Info("==============================================");
definedTags = updateBucketResponse.Bucket.DefinedTags;
foreach (KeyValuePair <string, Dictionary <string, object> > kvp in definedTags)
{
foreach (KeyValuePair <string, object> tags in kvp.Value)
{
logger.Info($"tag key name: {tags.Key} and tag value is {tags.Value}");
}
}
updateBucketDetails = new UpdateBucketDetails
{
Name = bucketName,
FreeformTags = new Dictionary <string, string>(),
DefinedTags = new Dictionary <string, Dictionary <string, object> >()
};
updateBucketRequest = new UpdateBucketRequest
{
NamespaceName = nSpace,
BucketName = bucketName,
UpdateBucketDetails = updateBucketDetails
};
updateBucketResponse = await osClient.UpdateBucket(updateBucketRequest);
logger.Info($"cleared the tags for the bucket: {updateBucketResponse.Bucket.Name}");
logger.Info("=================================");
// Clean up
DeleteBucketRequest deleteBucketRequest = new DeleteBucketRequest
{
NamespaceName = nSpace,
BucketName = bucketName
};
await osClient.DeleteBucket(deleteBucketRequest);
logger.Info("Deleted the bucket");
logger.Info("Ending example.");
}
catch (Exception e)
{
logger.Error($"Failed Object Storage example: {e.Message}");
}
finally
{
osClient.Dispose();
}
}
