/// <summary>
/// Creates a response using a custom resource request
/// </summary>
/// <param name="status"></param>
/// <param name="reason"></param>
/// <param name="request"></param>
/// <param name="noEcho"></param>
/// <param name="data"></param>
public CustomResourceResponse(
RequestStatus status,
string reason,
CustomResourceRequest request,
bool noEcho = false,
IDictionary <string, object> data = null
)
{
this.Status = status;
if (this.Status == RequestStatus.FAILED)
{
this.Reason = NullEmptyCheck(reason, "reason");
}
else
{
this.Reason = reason;
}
this.PhysicalResourceId = request.PhysicalResourceId;
this.StackId = request.StackId;
this.RequestId = request.RequestId;
this.LogicalResourceId = request.LogicalResourceId;
this.NoEcho = noEcho;
this.Data = data;
}
/// <summary>
/// Creates a new custom resource result that assumes the request to S3 failed
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="exception"></param>
public CustomResourceResult(
CustomResourceRequest request,
CustomResourceResponse response,
HttpResponseMessage s3response,
Exception exception
) : this(request, response, s3response)
{
this.IsSuccess = false;
this.Exception = exception ?? throw new ArgumentNullException("exception");
}
/// <summary>
/// Creates a new custom resource result with the success being determined by the custom
/// resource response status and http status code from S3.
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="s3response"></param>
public CustomResourceResult(
CustomResourceRequest request,
CustomResourceResponse response,
HttpResponseMessage s3response
)
{
this.Request = request ?? throw new ArgumentNullException("request");
this.Response = response ?? throw new ArgumentNullException("response");
this.S3Response = s3response ?? throw new ArgumentNullException("s3response");
this.IsSuccess = (response.Status == CustomResourceResponse.RequestStatus.SUCCESS && s3response.IsSuccessStatusCode);
this.Exception = null;
}
/// <summary>
/// Creates a new custom resource result that assumes the request to S3 failed
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="exception"></param>
public CustomResourceResult(
CustomResourceRequest request,
CustomResourceResponse response,
Exception exception
)
{
this.Request = request ?? throw new ArgumentNullException("request");
this.Response = response ?? throw new ArgumentNullException("response");
this.S3Response = null;
this.IsSuccess = false;
this.Exception = exception ?? throw new ArgumentNullException("exception");
}
/// <summary>
/// Uploads the custom resource action response to the pre-signed s3 url. Use this method if
/// you want to use the default handling for generating the CustomResourceResult object. This
/// is the method used by the ExecuteAsync method in the base CustomResourceHandler abstract class.
/// </summary>
/// <param name="response">The response generated from performing the action</param>
/// <param name="request">The request to initiate the custom resource action</param>
/// <returns>The default method for generating the CustomResourceResult is used in this method</returns>
public async Task <CustomResourceResult> PutCustomResourceResponseAsync(CustomResourceRequest request, CustomResourceResponse response)
{
try
{
HttpResponseMessage responseMessage = await this.UploadResponseToS3Async(request, response);
if ((int)responseMessage.StatusCode < 200 || (int)responseMessage.StatusCode > 299)
{
string message = $"Failed to submit response successfully: {(int)responseMessage.StatusCode}\n{await responseMessage.Content.ReadAsStringAsync()}";
return(new CustomResourceResult(request, response, responseMessage, new HttpRequestException(message)));
}
else
{
return(new CustomResourceResult(request, response, responseMessage));
}
}
catch (Exception e)
{
return(new CustomResourceResult(request, response, e));
}
}
/// <summary>
/// Entrypoint for the Lambda function, calls the correct create, update, or delete function. While this method
/// can be overridden, you will probably not need to.
/// </summary>
/// <param name="request">The custom resource request</param>
/// <param name="context">The ILambdaContext object</param>
/// <returns>A custom resource result with the included request, response, http respone, and any exception thrown</returns>
public virtual async Task <CustomResourceResult> ExecuteAsync(CustomResourceRequest request, ILambdaContext context)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
CustomResourceResponse response = null;
switch (request.RequestType)
{
case CustomResourceRequest.StackOperation.CREATE:
{
response = await this.CreateAsync(request, context);
break;
}
case CustomResourceRequest.StackOperation.DELETE:
{
response = await this.DeleteAsync(request, context);
break;
}
case CustomResourceRequest.StackOperation.UPDATE:
{
response = await this.UpdateAsync(request, context);
break;
}
default:
{
throw new ArgumentException($"Unknown stack operation: {request.RequestType}.");
}
}
CustomResourceResult result = await helper.PutCustomResourceResponseAsync(request, response);
if (!result.IsSuccess)
{
context.LogError(JsonConvert.SerializeObject(result.Response));
if (result.S3Response != null)
{
context.LogError(JsonConvert.SerializeObject(result.S3Response));
}
if (result.Exception != null)
{
context.LogError(result.Exception);
}
}
return(result);
}
public abstract Task <CustomResourceResponse> DeleteAsync(CustomResourceRequest request, ILambdaContext context);
/// <summary>
/// Uploads the custom resource action response to the pre-signed s3 url. Use this method if
/// you want to handle generating the CustomResourceResult object yourself.
/// </summary>
/// <param name="response">The response generated from performing the action</param>
/// <param name="request">The request to initiate the custom resource action</param>
/// <returns>The HttpResponseMessage from S3 which can be used with the request and response
/// objects to generate the required CustomResourceResult.</returns>
public async Task <HttpResponseMessage> UploadResponseToS3Async(CustomResourceRequest request, CustomResourceResponse response)
{
return(await StaticUploadResponseToS3Async(request.ResponseUrl, FixUpResponseJson(response, request.RequestType)));
}
public override async Task <CustomResourceResponse> DeleteAsync(CustomResourceRequest request, ILambdaContext context)
{
return(await _DeleteAsync(request, context));
}
