public void CreateBucketTest()
{
var entity = new CreateBucketRequest("icyufile");
var response = ufile.CreateBucket(entity);
Assert.AreEqual(response.RetCode, 0);
}
/// <summary>
/// Creates a new bucket.
/// </summary>
/// <param name="bucketName">The name to give the new bucket.</param>
/// <param name="bucketType">The bucket secuirty authorization type.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
async Task <IApiResults <CreateBucketResponse> > IStorageBuckets.CreateAsync
(string bucketName, BucketType bucketType)
{
var request = new CreateBucketRequest(AccountId, bucketName, bucketType);
return(await _client.CreateBucketAsync(request, _cancellationToken));
}
/// <summary>
/// 创建Bucket
/// </summary>
/// <param name="requestParams">请求参数.</param>
/// <returns>返回对象<see cref="UCloudSDK.Models.CreateBucketResponse"/></returns>
public CreateBucketResponse CreateBucket(CreateBucketRequest requestParams)
{
var request = new RestRequest(Method.GET);
request.AddUObject(requestParams);
return(Execute <CreateBucketResponse>(request));
}
public Task <bool> CreateBucketAsync(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentNullException(nameof(bucketName));
}
//检查桶是否存在
Bucket bucket = ListBucketsAsync().Result?.Where(p => p.Name == bucketName)?.FirstOrDefault();
if (bucket != null)
{
string localtion = Options.Endpoint?.Split('.')[0];
if (bucket.Location.Equals(localtion, StringComparison.OrdinalIgnoreCase))
{
throw new BucketExistException($"Bucket '{bucketName}' already exists.");
}
else
{
throw new BucketExistException($"There have a same name bucket '{bucketName}' in other localtion '{bucket.Location}'.");
}
}
var request = new CreateBucketRequest(bucketName)
{
//设置存储空间访问权限ACL。
ACL = CannedAccessControlList.Private,
//设置数据容灾类型。
DataRedundancyType = DataRedundancyType.LRS
};
// 创建存储空间。
var result = _client.CreateBucket(request);
return(Task.FromResult(result != null));
}
public void CreateBucketWithColdArchiveStorageClassTest()
{
var client = new OssClient("http://oss-ap-southeast-2.aliyuncs.com", Config.AccessKeyId, Config.AccessKeySecret);
//get a random bucketName
var bucketName = OssTestUtils.GetBucketName(_className);
//assert bucket does not exist
Assert.IsFalse(OssTestUtils.BucketExists(client, bucketName),
string.Format("Bucket {0} should not exist before creation", bucketName));
//create a new bucket
var request = new CreateBucketRequest(bucketName, StorageClass.ColdArchive, CannedAccessControlList.PublicReadWrite);
client.CreateBucket(request);
OssTestUtils.WaitForCacheExpire();
Assert.IsTrue(OssTestUtils.BucketExists(client, bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
//delete the new created bucket
client.DeleteBucket(bucketName);
OssTestUtils.WaitForCacheExpire();
Assert.IsFalse(OssTestUtils.BucketExists(client, bucketName),
string.Format("Bucket {0} should not exist after deletion", bucketName));
}
public Task <CreateBucketResponse> CreateBucketAsync(string bucketName, Action <CreateBucketRequest>?config = null, CancellationToken token = default)
{
CreateBucketRequest request = new CreateBucketRequest(bucketName);
config?.Invoke(request);
return(BucketOperations.CreateBucketAsync(request, token));
}
private CreateBucketCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
string bucketName, CreateBucketRequest createBucketRequest)
: base(client, endpoint, context)
{
OssUtils.CheckBucketName(bucketName);
_bucketName = bucketName;
_createBucketRequest = createBucketRequest;
StorageClass = createBucketRequest.StorageClass;
ACL = createBucketRequest.ACL;
}
public CreateBucketResult CreateBucket(
string bucket,
CreateBucketRequest request)
{
// https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html
return(new CreateBucketResult()
{
BucketName = bucket,
});
}
public void TestNonArnOutpostRequestHasIdTrue()
{
var request = new CreateBucketRequest
{
Bucket = "test",
OutpostId = "op-1234567890"
};
string outpostId = null;
Assert.IsTrue(S3ArnUtils.DoesRequestHaveOutpostId(request, out outpostId));
Assert.AreEqual("op-1234567890", outpostId);
}
public void TestInitialize()
{
// テスト用バケットを作成
CreateBucketRequest createBucketRequest = new CreateBucketRequest
{
NamespaceName = NameSpaceName,
CreateBucketDetails = new OCISDK.ObjectStorage.Model.CreateBucketDetails
{
CompartmentId = TargetCompartmentOCID,
Name = TestBucketName
}
};
try
{
ObjectStorageClient.CreateBucket(createBucketRequest);
}
catch (Exception e)
{
Trace.WriteLine($"create bucket failed. message:{e.Message}");
}
// あらかじめファイルを登録しておく
var assembly = Assembly.GetExecutingAssembly();
PutObjectResponse updateRes;
PutObjectRequest putObjectRequest = new PutObjectRequest
{
NamespaceName = NameSpaceName,
BucketName = TestBucketName
};
for (var i = 0; i < InitializeTestFiles.Length; i++)
{
putObjectRequest.ObjectName = InitializeTestFiles[i];
using (var stream = assembly.GetManifestResourceStream("OCISDK.Test.Properties." + InitializeTestFiles[i]))
{
putObjectRequest.UploadPartBody = stream;
updateRes = ObjectStorageClient.PutObject(putObjectRequest);
}
}
// 削除確認用
for (var i = 0; i < DeleteTestFiles.Length; i++)
{
putObjectRequest.ObjectName = DeleteTestFiles[i];
using (var stream = assembly.GetManifestResourceStream("OCISDK.Test.Properties." + DeleteTestFiles[i]))
{
putObjectRequest.UploadPartBody = stream;
updateRes = ObjectStorageClient.PutObject(putObjectRequest);
}
}
}
public void VpceEndpointTests_CreateBucket(string bucketName, string serviceUrl, Flags flags,
string expectedUri, string expectedRegion, string expectedService)
{
var request = new CreateBucketRequest
{
OutpostId = "op-123",
Bucket = bucketName
};
RunTestRequest(request, CreateBucketRequestMarshaller.Instance,
isArn: false, serviceUrl, flags,
expectedUri, expectedRegion, expectedService);
}
private CreateBucketCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
string bucketName, StorageClass?storageClass)
: base(client, endpoint, context)
{
OssUtils.CheckBucketName(bucketName);
_bucketName = bucketName;
StorageClass = storageClass;
ACL = null;
if (storageClass != null)
{
_createBucketRequest = new CreateBucketRequest(bucketName, storageClass.Value, CannedAccessControlList.Default);
}
}
public void TestInitialize()
{
// テスト用バケットの作成
CreateBucketRequest createBucketRequest = new CreateBucketRequest
{
NamespaceName = NameSpaceName,
CreateBucketDetails = new OCISDK.ObjectStorage.Model.CreateBucketDetails
{
Name = TestBucketName,
CompartmentId = TargetCompartmentOCID,
}
};
try
{
ObjectStorageClient.CreateBucket(createBucketRequest);
}
catch
{
Trace.WriteLine("create failed test bucket");
}
PutObjectRequest putObjectRequest = new PutObjectRequest
{
NamespaceName = NameSpaceName,
BucketName = TestBucketName
};
foreach (var testFile in TestFileInfos)
{
foreach (var fileName in testFile.Value)
{
if (string.IsNullOrEmpty(testFile.Key))
{
putObjectRequest.ObjectName = fileName;
}
else
{
putObjectRequest.ObjectName = $"{testFile.Key}/{fileName}";
}
var resourceName = $"OCISDK.Test.Properties.{fileName}";
var assembly = Assembly.GetExecutingAssembly();
PutObjectResponse updateRes;
using (var stream = assembly.GetManifestResourceStream(resourceName))
{
putObjectRequest.UploadPartBody = stream;
updateRes = ObjectStorageClient.PutObject(putObjectRequest);
}
}
}
}
public void CreateBucketByCreateBucketRequest()
{
//create a new bucket by default, acl is private, storage class is standard
var bucketName = OssTestUtils.GetBucketName(_className);
var request = new CreateBucketRequest(bucketName);
_ossClient.CreateBucket(request);
Assert.IsTrue(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
var result = _ossClient.GetBucketInfo(bucketName);
Assert.AreEqual(result.Bucket.AccessControlList.Grant, CannedAccessControlList.Private);
Assert.AreEqual(result.Bucket.StorageClass, StorageClass.Standard);
Assert.AreEqual(result.Bucket.DataRedundancyType, DataRedundancyType.LRS);
_ossClient.DeleteBucket(bucketName);
OssTestUtils.WaitForCacheExpire(1);
//create a public bucket with IA
bucketName = OssTestUtils.GetBucketName(_className);
request = new CreateBucketRequest(bucketName, StorageClass.IA, CannedAccessControlList.PublicReadWrite);
request.DataRedundancyType = DataRedundancyType.LRS;
_ossClient.CreateBucket(request);
Assert.IsTrue(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
result = _ossClient.GetBucketInfo(bucketName);
Assert.AreEqual(result.Bucket.AccessControlList.Grant, CannedAccessControlList.PublicReadWrite);
Assert.AreEqual(result.Bucket.StorageClass, StorageClass.IA);
Assert.AreEqual(result.Bucket.DataRedundancyType, DataRedundancyType.LRS);
_ossClient.DeleteBucket(bucketName);
//create a public bucket with IA , ZRS
bucketName = OssTestUtils.GetBucketName(_className);
request = new CreateBucketRequest(bucketName, StorageClass.IA, CannedAccessControlList.PublicReadWrite);
request.DataRedundancyType = DataRedundancyType.ZRS;
_ossClient.CreateBucket(request);
Assert.IsTrue(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
result = _ossClient.GetBucketInfo(bucketName);
Assert.AreEqual(result.Bucket.AccessControlList.Grant, CannedAccessControlList.PublicReadWrite);
Assert.AreEqual(result.Bucket.StorageClass, StorageClass.IA);
Assert.AreEqual(result.Bucket.DataRedundancyType, DataRedundancyType.ZRS);
_ossClient.DeleteBucket(bucketName);
}
public async Task <bool> CreateBucketAsync(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentNullException(nameof(bucketName));
}
var request = new CreateBucketRequest(bucketName)
{
//设置存储空间访问权限ACL。
ACL = CannedAccessControlList.Private,
//设置数据容灾类型。
DataRedundancyType = DataRedundancyType.ZRS
};
// 创建存储空间。
var result = _client.CreateBucket(request);
return(await Task.FromResult(result != null));
}
static void CreateBucket()
{
try
{
CreateBucketRequest request = new CreateBucketRequest()
{
BucketName = bucketName
};
CreateBucketResponse response = client.CreateBucket(request);
Console.WriteLine("Create bucket response: {0}", response.StatusCode);
}
catch (ObsException ex)
{
Console.WriteLine("Exception errorcode: {0}, when create a bucket.", ex.ErrorCode);
Console.WriteLine("Exception errormessage: {0}", ex.ErrorMessage);
}
}
public void CreateBucketTest()
{
var bucketName = "testBucket";
var s3ControlConfig = new AmazonS3ControlConfig
{
UseArnRegion = false,
RegionEndpoint = RegionEndpoint.USWest2
};
var createBucketRequest = new CreateBucketRequest
{
Bucket = bucketName,
OutpostId = "op-01234567890123456"
};
var marshalledRequest = S3ControlArnTestUtils.RunMockRequest(createBucketRequest, CreateBucketRequestMarshaller.Instance, s3ControlConfig);
Assert.AreEqual(new Uri("https://s3-outposts.us-west-2.amazonaws.com"), marshalledRequest.Endpoint);
Assert.AreEqual("op-01234567890123456", marshalledRequest.Headers["x-amz-outpost-id"]);
}
/// <summary>
/// 创建桶
/// </summary>
/// <param name="bucketName"></param>
/// <returns></returns>
public async Task <bool> CreateBucketAsync(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentNullException(nameof(bucketName));
}
if (await BucketExistsAsync(bucketName))
{
throw new BucketExistException($"Bucket '{bucketName}' already exists.");
}
CreateBucketRequest request = new CreateBucketRequest
{
Location = Options.Region,
BucketName = bucketName,
};
CreateBucketResponse response = _client.CreateBucket(request);
return(response != null && response.StatusCode == HttpStatusCode.OK);
}
/// <summary>
/// Sends an HTTP request to GCP to create a bucket with the configured name, and invokes the response
/// handler on the HTTP response.
/// </summary>
/// <param name="onCreateBucketResponseAction">An action to be invoked on the www instance holding the HTTP request
/// once the response to the request to create bucket is available.</param>
private static void CreateBucket(Action <WWW> onCreateBucketResponseAction)
{
var credentials = OAuth2Credentials.GetCredentials();
// see https://cloud.google.com/storage/docs/creating-buckets on creating buckets.
var createBucketEndPoint = string.Format("https://www.googleapis.com/storage/v1/b?project={0}",
credentials.project_id);
var createBucketRequest = new CreateBucketRequest
{
name = QuickDeployWindow.Config.CloudStorageBucketName
};
var jsonBytes = Encoding.UTF8.GetBytes(JsonUtility.ToJson(createBucketRequest));
var createBucketWww = SendAuthenticatedPostRequest(createBucketEndPoint, jsonBytes, "application/json");
WwwRequestInProgress.TrackProgress(
createBucketWww,
string.Format("Creating bucket with name \"{0}\"", createBucketRequest.name),
onCreateBucketResponseAction);
}
public async Task <IActionResult> CreateBucket([FromBody] CreateBucketRequest request)
{
await _s3.PutBucketAsync(request.BucketName);
var corsConfigurationRequest = new PutCORSConfigurationRequest
{
BucketName = request.BucketName,
Configuration = new CORSConfiguration
{
Rules = new List <CORSRule>
{
new CORSRule
{
AllowedOrigins = new List <string> {
"https://localhost:3000"
},
AllowedMethods = new List <string> {
"PUT", "POST", "DELETE"
},
AllowedHeaders = new List <string> {
"*"
},
ExposeHeaders = new List <string> {
"ETag"
}
},
new CORSRule
{
AllowedOrigins = new List <string> {
"*"
},
AllowedMethods = new List <string> {
"GET"
},
}
}
}
};
await _s3.PutCORSConfigurationAsync(corsConfigurationRequest);
return(new OkObjectResult(request.BucketName));
}
public HttpStatusCode CreateBucket(string name, int maxRecordSize, int maxRecordsPerBin)
{
var hostUrl = ConfigurationManager.AppSettings["ApiHostUrl"];
var createBucket = new CreateBucketRequest
{
BucketName = name, MaxRecordSize = maxRecordSize, MaxRecordsPerBin = maxRecordsPerBin
};
var requstJson = JsonConvert.SerializeObject(createBucket);
var request = HttpWebRequest.Create(hostUrl + "/buckets/") as HttpWebRequest;
request.Timeout = 400000;
request.Method = "PUT";
request.ContentLength = requstJson.Length;
request.GetRequestStream().Write(Encoding.ASCII.GetBytes(requstJson), 0, requstJson.Length);
var response = request.GetResponse() as HttpWebResponse;
return(response.StatusCode);
}
public void CreateBucket()
{
ServerNode.ActivateDatabase();
var hostUrl = ConfigurationManager.AppSettings["ApiHostUrl"];
var createBucket = new CreateBucketRequest
{
BucketName = "TestBucket", MaxRecordSize = 1024, MaxRecordsPerBin = 250000
};
var requstJson = JsonConvert.SerializeObject(createBucket);
var request = HttpWebRequest.Create(hostUrl + "/buckets/") as HttpWebRequest;
request.Method = "PUT";
request.ContentLength = requstJson.Length;
request.GetRequestStream().Write(Encoding.ASCII.GetBytes(requstJson), 0, requstJson.Length);
var response = request.GetResponse();
var reader = new StreamReader(response.GetResponseStream());
var message = reader.ReadToEnd();
}
/// <summary>
/// バケットを作成する
/// </summary>
/// <param name="nameSpaceName"></param>
/// <param name="bucketName"></param>
/// <param name="regionName"></param>
/// <returns></returns>
public bool CreateBucket(string nameSpaceName, string bucketName, string compartmentId, string regionName)
{
try
{
ObjectStorageClient.SetRegion(regionName);
CreateBucketRequest createBucketRequest = new CreateBucketRequest
{
NamespaceName = nameSpaceName,
CreateBucketDetails = new OCISDK.ObjectStorage.Model.CreateBucketDetails
{
CompartmentId = compartmentId,
Name = bucketName
}
};
ObjectStorageClient.CreateBucket(createBucketRequest);
}
catch
{
return(false);
}
return(true);
}
protected virtual async Task CreateBucketIfNotExists(IOss ossClient, BlobProviderArgs args, IList <string> refererList = null)
{
if (!await BucketExistsAsync(ossClient, args))
{
var bucketName = GetBucketName(args);
var request = new CreateBucketRequest(bucketName)
{
//设置存储空间访问权限ACL。
ACL = CannedAccessControlList.PublicReadWrite,
//设置数据容灾类型。
DataRedundancyType = DataRedundancyType.ZRS
};
ossClient.CreateBucket(request);
if (refererList != null && refererList.Count > 0)
{
var srq = new SetBucketRefererRequest(bucketName, refererList);
ossClient.SetBucketReferer(srq);
}
}
}
public void TestS3OutpostsSignerCreateBucket()
{
var signer = new S3Signer();
var createBucketRequest = new CreateBucketRequest
{
Bucket = "test",
OutpostId = "op-123456789012"
};
var config = new AmazonS3ControlConfig
{
SignatureVersion = "4",
UseArnRegion = true,
RegionEndpoint = RegionEndpoint.USWest2
};
var originalAuthService = config.AuthenticationServiceName;
var iRequest = S3ControlArnTestUtils.RunMockRequest(createBucketRequest, CreateBucketRequestMarshaller.Instance, config);
signer.Sign(iRequest, config, new RequestMetrics(), new ImmutableCredentials("ACCESS", "SECRET", ""));
Assert.IsTrue(iRequest.Headers.ContainsKey(HeaderKeys.AuthorizationHeader));
Assert.IsTrue((iRequest.Headers["Authorization"]).Contains("s3-outposts"));
Assert.IsTrue(config.AuthenticationServiceName == originalAuthService);
}
/// <summary>
/// Creates the bucket.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>System.String.</returns>
private HttpStatusCode CreateBucket(CreateBucketRequest request)
{
try
{
request.BucketName = request.BucketName.ToLower();
if (string.IsNullOrEmpty(request.BucketName))
{
return(HttpStatusCode.BadRequest);
}
if (Buckets.ContainsKey(request.BucketName))
{
return(HttpStatusCode.BadRequest);
}
Buckets.Add(request.BucketName, DataBucket.CreateNewBucket(request.BucketName, DbLocation, request.MaxRecordSize, request.MaxRecordsPerBin));
return(HttpStatusCode.OK);
}
catch (Exception ex)
{
return(HttpStatusCode.InternalServerError);
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateBucketRequest request;
try
{
request = new CreateBucketRequest
{
NamespaceName = NamespaceName,
CreateBucketDetails = CreateBucketDetails,
OpcClientRequestId = OpcClientRequestId
};
response = client.CreateBucket(request).GetAwaiter().GetResult();
WriteOutput(response, response.Bucket);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <summary>
/// Creates a bucket in the given namespace with a bucket name and optional user-defined metadata. Avoid entering confidential information in bucket names.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <CreateBucketResponse> CreateBucket(CreateBucketRequest request)
{
var uri = new Uri(GetEndPointNoneVersion(ObjectStorageServices.Bucket(request.NamespaceName), this.Region));
var webResponse = await this.RestClientAsync.Post(uri, request.CreateBucketDetails, new HttpRequestHeaderParam()
{
OpcClientRequestId = request.OpcClientRequestId
});
using (var stream = webResponse.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var response = reader.ReadToEnd();
return(new CreateBucketResponse()
{
Bucket = JsonSerializer.Deserialize <Bucket>(response),
ETag = webResponse.Headers.Get("ETag"),
OpcRequestId = webResponse.Headers.Get("opc-request-id"),
OpcClientRequestId = webResponse.Headers.Get("opc-client-request-id"),
Location = webResponse.Headers.Get("Location")
});
}
}
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();
}
}
public async Task CreateAsync()
{
var request = new CreateBucketRequest(Storage.AccountId, _bucketName, BucketType.AllPrivate)
{
BucketInfo = new BucketInfo
{
{ "key1", "value1" },
{ "key2", "value2" }
},
CacheControl = new CacheControlHeaderValue
{
MaxAge = TimeSpan.FromSeconds(120)
},
LifecycleRules = new LifecycleRules
{
new LifecycleRule
{
DaysFromHidingToDeleting = 6,
DaysFromUploadingToHiding = 5,
FileNamePrefix = "backup/",
},
new LifecycleRule
{
DaysFromHidingToDeleting = 45,
DaysFromUploadingToHiding = 7,
FileNamePrefix = "files/",
},
},
CorsRules = new CorsRules
{
new CorsRule(
"downloadFromAnyOrigin",
new List <string> {
"https"
},
new List <string> {
"b2_download_file_by_id", "b2_download_file_by_name"
},
3600)
{
AllowedHeaders = new List <string> {
"range"
},
ExposeHeaders = new List <string> {
"x-bz-content-sha1"
},
}
}
};
var results = await Storage.Buckets.CreateAsync(request);
results.EnsureSuccessStatusCode();
_bucketId = results.Response.BucketId;
Assert.Equal(typeof(CreateBucketResponse), results.Response.GetType());
Assert.Equal(_bucketName, results.Response.BucketName);
Assert.Equal(request.BucketInfo.Count, results.Response.BucketInfo.Count);
Assert.Equal(request.LifecycleRules.Count, results.Response.LifecycleRules.Count);
Assert.Equal(request.CorsRules.Count, results.Response.CorsRules.Count);
Assert.True(results.Response.CorsRules.Equals(request.CorsRules));
Assert.Equal(request.CorsRules.ToList(), results.Response.CorsRules.ToList());
Assert.True(results.Response.LifecycleRules.Equals(request.LifecycleRules));
Assert.Equal(request.LifecycleRules.ToList(), results.Response.LifecycleRules.ToList());
}
