public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.IdentityManagement.Model.UploadServerCertificateRequest(); if (cmdletContext.CertificateBody != null) { request.CertificateBody = cmdletContext.CertificateBody; } if (cmdletContext.CertificateChain != null) { request.CertificateChain = cmdletContext.CertificateChain; } if (cmdletContext.Path != null) { request.Path = cmdletContext.Path; } if (cmdletContext.PrivateKey != null) { request.PrivateKey = cmdletContext.PrivateKey; } if (cmdletContext.ServerCertificateName != null) { request.ServerCertificateName = cmdletContext.ServerCertificateName; } if (cmdletContext.Tag != null) { request.Tags = cmdletContext.Tag; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return(output); }
internal UploadServerCertificateResponse UploadServerCertificate(UploadServerCertificateRequest request) { var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.Instance; return Invoke<UploadServerCertificateRequest,UploadServerCertificateResponse>(request, marshaller, unmarshaller); }
IAsyncResult invokeUploadServerCertificate(UploadServerCertificateRequest uploadServerCertificateRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new UploadServerCertificateRequestMarshaller().Marshall(uploadServerCertificateRequest); var unmarshaller = UploadServerCertificateResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }
/// <summary> /// <para>Uploads a server certificate entity for the AWS account. The server certificate entity includes a public key certificate, a private /// key, and an optional certificate chain, which should all be PEM-encoded.</para> <para>For information about the number of server /// certificates you can upload, see Limitations on IAM Entities in <i>Using AWS Identity and Access Management</i> .</para> /// <para><b>NOTE:</b>Because the body of the public key certificate, private key, and the certificate chain can be large, you should use POST /// rather than GET when calling UploadServerCertificate. For information about setting up signatures and authorization through the API, go to /// Signing AWS API Requests in the AWS General Reference. For general information about using the Query API with IAM, go to Making Query /// Requests in Using IAM.</para> /// </summary> /// /// <param name="uploadServerCertificateRequest">Container for the necessary parameters to execute the UploadServerCertificate service method on /// AmazonIdentityManagementService.</param> /// /// <returns>The response from the UploadServerCertificate service method, as returned by AmazonIdentityManagementService.</returns> /// /// <exception cref="KeyPairMismatchException"/> /// <exception cref="MalformedCertificateException"/> /// <exception cref="LimitExceededException"/> /// <exception cref="EntityAlreadyExistsException"/> public UploadServerCertificateResponse UploadServerCertificate(UploadServerCertificateRequest uploadServerCertificateRequest) { IAsyncResult asyncResult = invokeUploadServerCertificate(uploadServerCertificateRequest, null, null, true); return EndUploadServerCertificate(asyncResult); }
/// <summary> /// Initiates the asynchronous execution of the UploadServerCertificate operation. /// <seealso cref="Amazon.IdentityManagement.AmazonIdentityManagementService.UploadServerCertificate"/> /// </summary> /// /// <param name="uploadServerCertificateRequest">Container for the necessary parameters to execute the UploadServerCertificate operation on /// AmazonIdentityManagementService.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking /// EndUploadServerCertificate operation.</returns> public IAsyncResult BeginUploadServerCertificate(UploadServerCertificateRequest uploadServerCertificateRequest, AsyncCallback callback, object state) { return invokeUploadServerCertificate(uploadServerCertificateRequest, callback, state, false); }
/// <summary> /// Initiates the asynchronous execution of the UploadServerCertificate operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UploadServerCertificate operation on AmazonIdentityManagementServiceClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUploadServerCertificate /// operation.</returns> public IAsyncResult BeginUploadServerCertificate(UploadServerCertificateRequest request, AsyncCallback callback, object state) { var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.Instance; return BeginInvoke<UploadServerCertificateRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// <para>Uploads a server certificate entity for the AWS account. The /// server certificate entity includes a public key certificate, a private /// key and an optional certificate chain. The uploaded public key /// certificate, the private key and certificate chain should all be PEM /// encoded.</para> <para>For information about the number of server /// certificates you can upload, see Limitations on IAM Entities in Using /// AWS Identity and Access Management.</para> <para><b>NOTE:</b>Because /// the body of the public key certificate, private key and the /// certificate chain can be large, you should use POST rather than GET /// when calling UploadServerCertificate. For more information, see Using /// the Query API in Using AWS Identity and Access Management.</para> /// </summary> /// /// <param name="uploadServerCertificateRequest">Container for the /// necessary parameters to execute the UploadServerCertificate service /// method on AmazonIdentityManagementService.</param> /// /// <returns>The response from the UploadServerCertificate service method, /// as returned by AmazonIdentityManagementService.</returns> /// /// <exception cref="KeyPairMismatchException"/> /// <exception cref="MalformedCertificateException"/> /// <exception cref="LimitExceededException"/> /// <exception cref="EntityAlreadyExistsException"/> public UploadServerCertificateResponse UploadServerCertificate(UploadServerCertificateRequest uploadServerCertificateRequest) { IRequest<UploadServerCertificateRequest> request = new UploadServerCertificateRequestMarshaller().Marshall(uploadServerCertificateRequest); UploadServerCertificateResponse response = Invoke<UploadServerCertificateRequest, UploadServerCertificateResponse> (request, this.signer, UploadServerCertificateResponseUnmarshaller.GetInstance()); return response; }
IAsyncResult invokeUploadServerCertificate(UploadServerCertificateRequest request, AsyncCallback callback, object state, bool synchronized) { var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.Instance; return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer); }
/// <summary> /// Initiates the asynchronous execution of the UploadServerCertificate operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UploadServerCertificate operation on AmazonIdentityManagementServiceClient.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public void UploadServerCertificateAsync(UploadServerCertificateRequest request, AmazonServiceCallback<UploadServerCertificateRequest, UploadServerCertificateResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<UploadServerCertificateRequest,UploadServerCertificateResponse> responseObject = new AmazonServiceResult<UploadServerCertificateRequest,UploadServerCertificateResponse>((UploadServerCertificateRequest)req, (UploadServerCertificateResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<UploadServerCertificateRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Initiates the asynchronous execution of the UploadServerCertificate operation. /// <seealso cref="Amazon.IdentityManagement.IAmazonIdentityManagementService.UploadServerCertificate"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UploadServerCertificate 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 async Task<UploadServerCertificateResponse> UploadServerCertificateAsync(UploadServerCertificateRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, UploadServerCertificateRequest, UploadServerCertificateResponse>(request, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// <para>Uploads a server certificate entity for the AWS account. The server certificate entity includes a public key certificate, a private /// key, and an optional certificate chain, which should all be PEM-encoded.</para> <para>For information about the number of server /// certificates you can upload, see <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">Limitations on IAM Entities</a> in <i>Using AWS Identity and Access Management</i> .</para> <para><b>NOTE:</b>Because the body of the /// public key certificate, private key, and the certificate chain can be large, you should use POST rather than GET when calling /// UploadServerCertificate. For information about setting up signatures and authorization through the API, go to Signing AWS API Requests in /// the AWS General Reference. For general information about using the Query API with IAM, go to Making Query Requests in Using IAM.</para> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UploadServerCertificate service method on /// AmazonIdentityManagementService.</param> /// /// <returns>The response from the UploadServerCertificate service method, as returned by AmazonIdentityManagementService.</returns> /// /// <exception cref="T:Amazon.IdentityManagement.Model.KeyPairMismatchException" /> /// <exception cref="T:Amazon.IdentityManagement.Model.MalformedCertificateException" /> /// <exception cref="T:Amazon.IdentityManagement.Model.LimitExceededException" /> /// <exception cref="T:Amazon.IdentityManagement.Model.EntityAlreadyExistsException" /> public UploadServerCertificateResponse UploadServerCertificate(UploadServerCertificateRequest request) { var task = UploadServerCertificateAsync(request); try { return task.Result; } catch(AggregateException e) { throw e.InnerException; } }
/// <summary> /// <para>Uploads a server certificate entity for the AWS account. The server certificate entity includes a public key certificate, a private /// key, and an optional certificate chain, which should all be PEM-encoded.</para> <para>For information about the number of server /// certificates you can upload, see <a href="http://docs.aws.amazon.com/IAM/latest/UserGuide/index.html?LimitationsOnEntities.html">Limitations on IAM Entities</a> in <i>Using AWS Identity and Access Management</i> .</para> <para><b>NOTE:</b>Because the body of the /// public key certificate, private key, and the certificate chain can be large, you should use POST rather than GET when calling /// UploadServerCertificate. For information about setting up signatures and authorization through the API, go to Signing AWS API Requests in /// the AWS General Reference. For general information about using the Query API with IAM, go to Making Query Requests in Using IAM.</para> /// </summary> /// /// <param name="uploadServerCertificateRequest">Container for the necessary parameters to execute the UploadServerCertificate service method on /// AmazonIdentityManagementService.</param> /// /// <returns>The response from the UploadServerCertificate service method, as returned by AmazonIdentityManagementService.</returns> /// /// <exception cref="T:Amazon.IdentityManagement.Model.KeyPairMismatchException" /> /// <exception cref="T:Amazon.IdentityManagement.Model.MalformedCertificateException" /> /// <exception cref="T:Amazon.IdentityManagement.Model.LimitExceededException" /> /// <exception cref="T:Amazon.IdentityManagement.Model.EntityAlreadyExistsException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public Task<UploadServerCertificateResponse> UploadServerCertificateAsync(UploadServerCertificateRequest uploadServerCertificateRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.GetInstance(); return Invoke<IRequest, UploadServerCertificateRequest, UploadServerCertificateResponse>(uploadServerCertificateRequest, marshaller, unmarshaller, signer, cancellationToken); }
internal UploadServerCertificateResponse UploadServerCertificate(UploadServerCertificateRequest request) { var task = UploadServerCertificateAsync(request); try { return task.Result; } catch(AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return null; } }
/// <summary> /// Initiates the asynchronous execution of the UploadServerCertificate operation. /// <seealso cref="Amazon.IdentityManagement.IAmazonIdentityManagementService"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UploadServerCertificate 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<UploadServerCertificateResponse> UploadServerCertificateAsync(UploadServerCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new UploadServerCertificateRequestMarshaller(); var unmarshaller = UploadServerCertificateResponseUnmarshaller.Instance; return InvokeAsync<UploadServerCertificateRequest,UploadServerCertificateResponse>(request, marshaller, unmarshaller, cancellationToken); }
private Amazon.IdentityManagement.Model.UploadServerCertificateResponse CallAWSServiceOperation(IAmazonIdentityManagementService client, Amazon.IdentityManagement.Model.UploadServerCertificateRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "AWS Identity and Access Management", "UploadServerCertificate"); try { #if DESKTOP return client.UploadServerCertificate(request); #elif CORECLR return client.UploadServerCertificateAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } }
public void Install(PrivateKey pk, Crt crt, IEnumerable<PKI.Crt> chain, IPkiTool cp) { AssertNotDisposed(); string pkPem; using (var ms = new MemoryStream()) { cp.ExportPrivateKey(pk, EncodingFormat.PEM, ms); pkPem = Encoding.UTF8.GetString(ms.ToArray()); } string crtPem; using (var ms = new MemoryStream()) { cp.ExportCertificate(crt, EncodingFormat.PEM, ms); crtPem = Encoding.UTF8.GetString(ms.ToArray()); } string chainPem = null; if (chain != null) { using (var ms = new MemoryStream()) { foreach (var c in chain) { cp.ExportCertificate(c, EncodingFormat.PEM, ms); } chainPem = Encoding.UTF8.GetString(ms.ToArray()); } } using (var client = new AmazonIdentityManagementServiceClient( CommonParams.ResolveCredentials(), CommonParams.RegionEndpoint)) { var iamRequ = new UploadServerCertificateRequest { PrivateKey = pkPem, CertificateBody = crtPem, CertificateChain = chainPem, ServerCertificateName = this.ServerCertificateName, Path = this.Path }; var iamResp = client.UploadServerCertificate(iamRequ); // TODO: any checks we should do? } }
/// <summary> /// Uploads the Server Cert /// </summary> /// <param name="certNameWithDateTime"></param> /// <param name="iam"></param> /// <returns></returns> private async Task<UploadServerCertificateResponse> UploadServerCertificateAsync(string certNameWithDateTime, AmazonIdentityManagementServiceClient iam) { loggerProvider.GetLogger().Debug($"Uploading ssl. [Name: {configurationProvider.CertName}]"); var certChain = await GetCertificateChainForCertAsync(); var uploadRequest = new UploadServerCertificateRequest { ServerCertificateName = certNameWithDateTime, CertificateBody = configurationProvider.CertBody, PrivateKey = configurationProvider.CertPrivateKey, CertificateChain = certChain }; var uploadResult = await iam.UploadServerCertificateAsync(uploadRequest); return uploadResult; }