/// <summary>
/// Deletes the artifacts associated with an import task using a presigned
/// url to address the manifest for the import. No check is performed to
/// determine whether the associated conversion task is in progress.
/// </summary>
/// <param name="s3Client">
/// An Amazon S3 client for the operation to use. This should have been constructed
/// using credentials that have access to the bucket containing the image file
/// artifacts and be scoped to the region containing the bucket.
/// </param>
/// <param name="manifestUrl">
/// Presigned URL to the import manifest file
/// </param>
/// <param name="progressCallback">Optional progress callback</param>
public static void DeleteImageArtifacts(ICoreAmazonS3 s3Client,
string manifestUrl,
CleanupProgressCallback progressCallback)
{
if (string.IsNullOrEmpty(manifestUrl))
{
throw new ArgumentException("Expected valid presigned url to the import manifest.");
}
var s3Uri = new S3Uri(manifestUrl);
// strip the manifest object name away from the key to get the overall key prefix
// to the objects
var lastSlashPos = s3Uri.Key.LastIndexOf('/');
DeleteImageArtifacts(s3Client, s3Uri.Bucket, s3Uri.Key.Substring(0, lastSlashPos), progressCallback);
}
/// <summary>
/// Returns the canonicalized resource path for the service endpoint
/// </summary>
/// <param name="endpoint">Endpoint URL for the request</param>
/// <param name="resourcePath">Resource path for the request</param>
/// <param name="detectPreEncode">If true pre URL encode path segments if necessary.
/// S3 is currently the only service that does not expect pre URL encoded segments.</param>
/// <remarks>
/// If resourcePath begins or ends with slash, the resulting canonicalized
/// path will follow suit.
/// </remarks>
/// <returns>Canonicalized resource path for the endpoint</returns>
public static string CanonicalizeResourcePath(Uri endpoint, string resourcePath, bool detectPreEncode)
{
if (endpoint != null)
{
var path = endpoint.AbsolutePath;
if (string.IsNullOrEmpty(path) || string.Equals(path, Slash, StringComparison.Ordinal))
{
path = string.Empty;
}
if (!string.IsNullOrEmpty(resourcePath) && resourcePath.StartsWith(Slash, StringComparison.Ordinal))
{
resourcePath = resourcePath.Substring(1);
}
if (!string.IsNullOrEmpty(resourcePath))
{
path = path + Slash + resourcePath;
}
resourcePath = path;
}
if (string.IsNullOrEmpty(resourcePath))
{
return(Slash);
}
// split path at / into segments
var pathSegments = resourcePath.Split(new char[] { SlashChar }, StringSplitOptions.None);
IEnumerable <string> encodedSegments = pathSegments;
var pathWasPreEncoded = false;
if (detectPreEncode)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint), "A non-null endpoint is necessary to decide whether or not to pre URL encode.");
}
// S3 is a special case. For S3 skip the pre encode.
// For everything else URL pre encode the resource path segments.
if (!S3Uri.IsS3Uri(endpoint))
{
encodedSegments = encodedSegments.Select(segment => ProtectEncodedSlashUrlEncode(segment, true));
pathWasPreEncoded = true;
}
}
// Encode for canonicalization
encodedSegments = encodedSegments.Select(segment => UrlEncode(segment, false));
// join the encoded segments with /
var canonicalizedResourcePath = string.Join(Slash, encodedSegments.ToArray());
// Get the logger each time (it's cached) because we shouldn't store it in a static variable.
Logger.GetLogger(typeof(AWSSDKUtils)).DebugFormat("{0} encoded {1}{2} for canonicalization: {3}",
pathWasPreEncoded ? "Double" : "Single",
resourcePath,
endpoint == null ? "" : " with endpoint " + endpoint.AbsoluteUri,
canonicalizedResourcePath);
return(canonicalizedResourcePath);
}