static void CreateVault(IAmazonGlacier glacier)
{
var req = new CreateVaultRequest
{
VaultName = VaultName
};
Task <CreateVaultResponse> res = glacier.CreateVaultAsync(req);
Task.WaitAll(res);
if (res.IsCompletedSuccessfully)
{
Console.WriteLine($"Successfully created vault {VaultName}");
// if the user did not update the sample code with their account ID before
// running, recover the ID from the vault location path as we need the ID
// to construct the Amazon Resource Name (ARN) of the vault when setting
// the access policy
if (_accountId.Equals("-"))
{
_accountId = res.Result.Location.Split('/', StringSplitOptions.RemoveEmptyEntries)[0];
}
}
}
/// <summary>
/// Creates a new vault. The type of vault you create determines key placement, pricing, and
/// available options. Options include storage isolation, a dedicated service endpoint instead
/// of a shared service endpoint for API calls, and either a dedicated hardware security module
/// (HSM) or a multitenant HSM.
/// <br/>
/// As a provisioning operation, this call is subject to a Key Management limit that applies to
/// the total number of requests across all provisioning write operations. Key Management might
/// throttle this call to reject an otherwise valid request when the total rate of provisioning
/// write operations exceeds 10 requests per second for a given tenancy.
///
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/keymanagement/CreateVault.cs.html">here</a> to see an example of how to use CreateVault API.</example>
public async Task <CreateVaultResponse> CreateVault(CreateVaultRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called createVault");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/20180608/vaults".Trim('/')));
HttpMethod method = new HttpMethod("POST");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <CreateVaultResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"CreateVault failed with error: {e.Message}");
throw;
}
}
internal CreateVaultResponse CreateVault(CreateVaultRequest request)
{
var marshaller = new CreateVaultRequestMarshaller();
var unmarshaller = CreateVaultResponseUnmarshaller.Instance;
return(Invoke <CreateVaultRequest, CreateVaultResponse>(request, marshaller, unmarshaller));
}
public static Task <CreateVaultResponse> CreateVaultAsync(string vaultName)
{
using (var client = GetGlacierClient())
{
CreateVaultRequest request = new CreateVaultRequest(GetAccountId(), vaultName);
return(client.CreateVaultAsync(request));
}
}
/// <summary>
/// Initiates the asynchronous execution of the CreateVault operation.
/// <seealso cref="Amazon.Glacier.IAmazonGlacier"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateVault operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <CreateVaultResponse> CreateVaultAsync(CreateVaultRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new CreateVaultRequestMarshaller();
var unmarshaller = CreateVaultResponseUnmarshaller.Instance;
return(InvokeAsync <CreateVaultRequest, CreateVaultResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public static bool CreateVault(string vaultName)
{
using (var client = GetGlacierClient())
{
CreateVaultRequest request = new CreateVaultRequest(GetAccountId(), vaultName);
CreateVaultResponse response = client.CreateVault(request);
return(response.HttpStatusCode == HttpStatusCode.OK);
}
}
/// <summary>
/// 创建存储库
/// </summary>
public async Task <CreateVaultResponse> CreateVaultAsync(CreateVaultRequest createVaultRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/v3/{project_id}/vaults", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createVaultRequest);
HttpResponseMessage response = await DoHttpRequestAsync("POST", request);
return(JsonUtils.DeSerialize <CreateVaultResponse>(response));
}
/// <summary>
/// Creates a vault.
/// </summary>
/// <param name="vaultName">The name of the vault to create.</param>
public Task CreateVaultAsync(string vaultName)
{
CreateVaultRequest request = new CreateVaultRequest()
{
VaultName = vaultName
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)request).AddBeforeRequestHandler(new UserAgentPostFix("CreateVault").UserAgentRequestEventHandlerSync);
return(this.glacierClient.CreateVaultAsync(request));
}
/// <summary>
/// Creates a vault.
/// </summary>
/// <param name="vaultName">The name of the vault to create.</param>
public void CreateVault(string vaultName)
{
CreateVaultRequest request = new CreateVaultRequest()
{
VaultName = vaultName
};
request.BeforeRequestEvent += new UserAgentPostFix("CreateVault").UserAgentRequestEventHandlerSync;
this.glacierClient.CreateVault(request);
}
private async Task CreateVaultAsync(string containerName)
{
var createRequest = new CreateVaultRequest {
VaultName = containerName
};
var createResponse = await _client.CreateVaultAsync(createRequest);
if (!createResponse.IsSuccess())
{
throw new OperationFailedException <CreateVaultResponse>("Unable to create the container", createResponse);
}
}
private CreateVaultRequest CreateVaultRequest(DeveloperOptions devOptions)
{
var request = new CreateVaultRequest()
{
// TODO - need to determine where defaults are used, and then not create the constructor where value is null (to use default)
// These are required values.
AccountId = devOptions.AccountId,
VaultName = devOptions.VaultName
};
return(request);
}
public void CreateVault()
{
CreateVaultRequest request = new CreateVaultRequest
{
AccountId = "-",
VaultName = vaultName
};
var response = client.CreateVault(request);
if (response.HttpStatusCode.IsSuccess())
{
Console.WriteLine("Vault Created Successfully");
}
}
private static void CreateVault(AmazonGlacierClient glacier)
{
CreateVaultRequest req = new CreateVaultRequest();
req.VaultName = vaultName;
Task <CreateVaultResponse> res = glacier.CreateVaultAsync(req);
Task.WaitAll(res);
if (res.IsCompletedSuccessfully)
{
Console.Write("Created Vault {0} successfully", vaultName);
}
}
public void CreateVault()
{
CreateVaultRequest request = new CreateVaultRequest
{
VaultName = vaultName,
AccountId = "-"
};
var response = client.CreateVault(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.Created)
{
Console.WriteLine("Create Vault Sucessfully");
}
Console.ReadLine();
}
static async Task Main(string[] args)
{
string vaultName = "example-vault";
var client = new AmazonGlacierClient();
var request = new CreateVaultRequest
{
// Setting the AccountId to "-" means that
// the account associated with the default
// client will be used.
AccountId = "-",
VaultName = vaultName,
};
var response = await client.CreateVaultAsync(request);
Console.WriteLine($"Created {vaultName} at: {response.Location}");
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateVaultRequest request;
try
{
request = new CreateVaultRequest
{
CreateVaultDetails = CreateVaultDetails,
OpcRequestId = OpcRequestId,
OpcRetryToken = OpcRetryToken
};
response = client.CreateVault(request).GetAwaiter().GetResult();
WriteOutput(response, response.Vault);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task CreateVaultAsync(CancellationToken token)
{
var req = new CreateVaultRequest(Vault);
await client.CreateVaultAsync(req, token);
}
