private void InvalidateCloudFront(params string[] paths)
{
if (!_revalidateCloudFront || string.IsNullOrEmpty(_distributionId))
{
return;
}
using (var cfClient = GetCloudFrontClient())
{
var invalidationRequest = new CreateInvalidationRequest
{
DistributionId = _distributionId,
InvalidationBatch = new InvalidationBatch
{
CallerReference = Guid.NewGuid().ToString(),
Paths = new Paths
{
Items = paths.ToList(),
Quantity = paths.Count()
}
}
};
cfClient.CreateInvalidation(invalidationRequest);
}
}
private async Task <HttpStatusCode> InvalidateCacheAsync(List <string> paths)
{
var invalidationBatch = new InvalidationBatch()
{
CallerReference = DateTime.Now.Ticks.ToString(),
Paths = new Paths()
{
Items = paths,
Quantity = paths.Count()
}
};
var req = new CreateInvalidationRequest(_cloudFrontConfig.DistributionID, invalidationBatch);
var invalidateCacheResponse = (await _cloudFrontService.CreateInvalidationAsync(req));
var invalidateCacheResponseCode = invalidateCacheResponse.HttpStatusCode;
var requestId = invalidateCacheResponse?.ResponseMetadata?.RequestId;
var invalidationId = invalidateCacheResponse?.Invalidation?.Id;
if (invalidateCacheResponseCode != HttpStatusCode.Created)
{
_logger.LogError($"Cache invalidation failed.\n Status code: {invalidateCacheResponseCode}\n Request ID: {requestId}\n Invalidation ID: {invalidationId}");
}
return(invalidateCacheResponseCode);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateInvalidation operation.
/// <seealso cref="Amazon.CloudFront.IAmazonCloudFront"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateInvalidation 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 <CreateInvalidationResponse> CreateInvalidationAsync(CreateInvalidationRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new CreateInvalidationRequestMarshaller();
var unmarshaller = CreateInvalidationResponseUnmarshaller.Instance;
return(Invoke <IRequest, CreateInvalidationRequest, CreateInvalidationResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
public void InvalidateCloudFrontDistribution(string distId, List <string> invalidPaths)
{
Log.Debug("Invalidating paths", invalidPaths);
var invReq = new CreateInvalidationRequest
{
DistributionId = distId,
InvalidationBatch = new InvalidationBatch
{
Paths = new Paths
{
Quantity = invalidPaths.Count,
Items = invalidPaths
},
CallerReference = DateTime.Now.Ticks.ToString()
}
};
var resp = _cfclient.CreateInvalidation(invReq);
if (resp.HttpStatusCode == HttpStatusCode.Created)
{
Log.Info(string.Format("Created invalidation for Cloudfront Distribution {0}", distId));
}
else
{
Log.Error(string.Format("Got unexpected result creating invalidation for Cloudfront Distribution {0}: {1}", distId, resp.HttpStatusCode));
}
}
internal CreateInvalidationResponse CreateInvalidation(CreateInvalidationRequest request)
{
var marshaller = new CreateInvalidationRequestMarshaller();
var unmarshaller = CreateInvalidationResponseUnmarshaller.Instance;
return(Invoke <CreateInvalidationRequest, CreateInvalidationResponse>(request, marshaller, unmarshaller));
}
private static void UploadWeb()
{
var path = "../../../Web/";
try
{
var m = Directory.GetFiles(path);
Console.WriteLine("Starting Web Upload");
TransferUtility directoryTransferUtility = new TransferUtility(new AmazonS3Client(Amazon.RegionEndpoint.USWest2), new TransferUtilityConfig()
{
ConcurrentServiceRequests = 50,
});
var transferUtilityUploadDirectoryRequest = new TransferUtilityUploadDirectoryRequest()
{
Directory = path,
BucketName = "socialwargames.com",
SearchPattern = "*.*",
SearchOption = SearchOption.AllDirectories,
UploadFilesConcurrently = true,
CannedACL = S3CannedACL.PublicRead
};
transferUtilityUploadDirectoryRequest.UploadDirectoryProgressEvent += (sender, e) =>
{
Console.WriteLine("Files Uploaded: " + e.NumberOfFilesUploaded);
};
directoryTransferUtility.UploadDirectory(transferUtilityUploadDirectoryRequest);
Console.WriteLine("Starting Invalidate");
AmazonCloudFrontClient oClient = new AmazonCloudFrontClient(Amazon.RegionEndpoint.USWest2);
CreateInvalidationRequest oRequest = new CreateInvalidationRequest();
oRequest.DistributionId = "E34LW6CB5ZCWQU";
oRequest.InvalidationBatch = new InvalidationBatch
{
CallerReference = DateTime.Now.Ticks.ToString(),
Paths = new Paths()
{
Items = new List <string>()
{
"/*"
}, Quantity = 1
}
};
CreateInvalidationResponse oResponse = oClient.CreateInvalidation(oRequest);
oClient.Dispose();
Console.WriteLine("Done Web Upload");
}
catch (AmazonS3Exception e)
{
Console.WriteLine(e.Message, e.InnerException);
}
}
internal CreateInvalidationResponse CreateInvalidation(CreateInvalidationRequest request)
{
var task = CreateInvalidationAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
public async Task CreateInvalidationByPath(string distributionId, string path)
{
_logger.LogInformation($"Creating invalidation for {distributionId}: {path}");
var invalidationRequest = new CreateInvalidationRequest
{
DistributionId = distributionId,
InvalidationBatch = new InvalidationBatch
{
Paths = new Paths
{
Items = new List <string> {
path
},
Quantity = 1
},
CallerReference = DateTime.Now.ToString("yyyyMMddHHmmssffff")
}
};
await _amazonCloudFront.CreateInvalidationAsync(invalidationRequest);
}
/// <summary>
/// Invalidates objects from a CloudFront distribution.
/// </summary>
/// <param name="distributionId">The distribution to invalidate objects from.</param>
/// <param name="items">The path of the objects to invalidate.</param>
/// <param name="reference">A unique name that ensures the request can't be replayed.</param>
/// <param name="settings">The <see cref="CloudFrontSettings"/> required to connect to Amazon CloudFront.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
public async Task <string> CreateInvalidation(string distributionId, IList <string> items, string reference, CloudFrontSettings settings, CancellationToken cancellationToken = default(CancellationToken))
{
//Get Reference
if (String.IsNullOrEmpty(reference))
{
reference = DateTime.Now.Ticks.ToString();
}
//Correct Paths
List <string> paths = new List <string>();
foreach (string item in items)
{
if (!item.StartsWith("/"))
{
paths.Add("/" + item);
}
else
{
paths.Add(item);
}
}
//Create Request
InvalidationBatch batch = new InvalidationBatch()
{
Paths = new Paths()
{
Items = paths.ToList(),
Quantity = items.Count
},
CallerReference = reference
};
CreateInvalidationRequest request = new CreateInvalidationRequest()
{
DistributionId = distributionId,
InvalidationBatch = batch
};
//Send Request
_Log.Verbose("Create Invalidation {0}", distributionId);
AmazonCloudFrontClient client = this.GetClient(settings);
CreateInvalidationResponse response = await client.CreateInvalidationAsync(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.Created)
{
return(response.Invalidation.Id);
}
else
{
_Log.Error("Error invalidating object {0}", distributionId);
return("");
}
}
/// <summary>
/// This method is called for every Lambda invocation. This method takes in an S3 event object and can be used
/// to respond to S3 notifications.
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <string> FunctionHandler(S3Event evnt, ILambdaContext context)
{
var s3Event = evnt.Records?[0].S3;
if (s3Event == null)
{
return(null);
}
try
{
Task <CreateInvalidationResponse> invalidationResponseTask = null;
if (!string.IsNullOrWhiteSpace(distribuitionCloudFrontId))
{
CreateInvalidationRequest invaliationReq = new CreateInvalidationRequest()
{
DistributionId = distribuitionCloudFrontId,
InvalidationBatch = new InvalidationBatch(DateTime.Now.Ticks.ToString())
{
Paths = new Paths()
{
Quantity = 1,
Items = new List <string>()
{
$"/{s3Event.Object.Key}"
}
}
}
};
invalidationResponseTask = this.cfClient.CreateInvalidationAsync(invaliationReq);
}
HttpResponseMessage message = null;
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Add("X-Auth-Email", Environment.GetEnvironmentVariable("Email"));
client.DefaultRequestHeaders.Add("X-Auth-Key", Environment.GetEnvironmentVariable("Key"));
StringBuilder msg = new StringBuilder();
msg.Append(@"{""files"":[""");
msg.Append(Environment.GetEnvironmentVariable("Domain"));
msg.Append("/");
msg.Append(s3Event.Object.Key);
msg.Append(@"""]}");
StringContent content = new StringContent(msg.ToString(), Encoding.UTF8, "application/json");
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Delete, new Uri(string.Format("https://api.cloudflare.com/client/v4/zones/{0}/purge_cache", Environment.GetEnvironmentVariable("Zone")))))
{
request.Content = content;
message = await client.SendAsync(request);
}
}
if (invalidationResponseTask != null)
{
await invalidationResponseTask;
}
return(await message.Content.ReadAsStringAsync());
}
catch (Exception e)
{
context.Logger.LogLine($"Error getting object {s3Event.Object.Key} from bucket {s3Event.Bucket.Name}. Make sure they exist and your bucket is in the same region as this function.");
context.Logger.LogLine(e.Message);
context.Logger.LogLine(e.StackTrace);
throw;
}
}
