private void ValidateCredentials(IS3Client s3Client, bool isDirectory)
{
try
{
if (isDirectory)
{
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = path
};
s3Client.PutObjectAsync(putRequest).Wait();
}
else
{
var getRequest = new GetObjectRequest
{
BucketName = bucketName,
Key = path,
ByteRange = new ByteRange(0, 1)
};
s3Client.GetObjectAsync(getRequest).Wait();
}
}
catch (Exception exception)
{
var processedException = ExceptionUtilities.ProcessAmazonS3Exception(exception, this);
if (processedException is UserErrorException)
{
throw processedException;
}
}
}
private async Task <MemoryStream> GetRawStream(IObjectElementRawValue imageElementValue, CancellationToken token)
{
var response = await _s3Client.GetObjectAsync(_bucketName, imageElementValue.Raw, token);
using (response.ResponseStream)
{
var memoryStream = new MemoryStream();
response.ResponseStream.CopyTo(memoryStream);
memoryStream.Position = 0;
return(memoryStream);
}
}
private void ValidateCredentials(IS3Client s3Client, bool isDirectory)
{
int maxRetryCount = MaxRetryCount;
while (true)
{
try
{
if (isDirectory)
{
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = path
};
s3Client.PutObjectAsync(putRequest).Wait();
}
else
{
var getRequest = new GetObjectRequest
{
BucketName = bucketName,
Key = path,
ByteRange = new ByteRange(0, 1)
};
s3Client.GetObjectAsync(getRequest).Wait();
}
// validation successful. Break and return.
break;
}
catch (Exception exception)
{
var processedException = AwsExceptionUtilities.TryConvertUserException(exception, this);
if (processedException is UserErrorException)
{
throw processedException;
}
Logger.WriteLine($"Failed to validate S3 credentials\n{processedException.Message}");
maxRetryCount--;
if (maxRetryCount >= 0)
{
continue;
}
Logger.WriteLine("Max retry limit reached for validating S3 credentials.");
throw processedException;
}
}
}
public async Task <TemplateDescriptor> GetTemplateDescriptor(long id, string versionId)
{
var objectVersionId = string.IsNullOrEmpty(versionId) ? await GetTemplateLatestVersion(id) : versionId;
var templateDescriptor = await _memoryCache.GetOrCreateAsync(
id.AsCacheEntryKey(objectVersionId),
async entry =>
{
try
{
using (var response = await _s3Client.GetObjectAsync(_bucketName, id.ToString(), objectVersionId))
{
var metadataWrapper = MetadataCollectionWrapper.For(response.Metadata);
var author = metadataWrapper.Read <string>(MetadataElement.Author);
var authorLogin = metadataWrapper.Read <string>(MetadataElement.AuthorLogin);
var authorName = metadataWrapper.Read <string>(MetadataElement.AuthorName);
string json;
using (var reader = new StreamReader(response.ResponseStream, Encoding.UTF8))
{
json = reader.ReadToEnd();
}
var descriptor = new TemplateDescriptor
{
Id = id,
VersionId = objectVersionId,
LastModified = response.LastModified,
Author = author,
AuthorLogin = authorLogin,
AuthorName = authorName
};
JsonConvert.PopulateObject(json, descriptor, SerializerSettings.Default);
entry.SetValue(descriptor)
.SetPriority(CacheItemPriority.NeverRemove);
return(descriptor);
}
}
catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
throw new ObjectNotFoundException($"Template '{id}' version '{objectVersionId}' not found");
}
});
return(templateDescriptor);
}
private async Task <IReadOnlyDictionary <int, IReadOnlyCollection <BinaryValidationError> > > VerifyObjectBinaryElementsConsistency(
Language language,
IReadOnlyCollection <IObjectElementDescriptor> elements)
{
var errors = new Dictionary <int, IReadOnlyCollection <BinaryValidationError> >();
foreach (var binaryElement in elements.GetBinaryElements())
{
var elementErrors = new List <BinaryValidationError>();
var constraints = binaryElement.Constraints.For(language);
var fileKeys = binaryElement.Value.ExtractFileKeys();
foreach (var fileKey in fileKeys)
{
using (var getResponse = await _s3Client.GetObjectAsync(_filesBucketName, fileKey))
{
var memoryStream = new MemoryStream();
using (getResponse.ResponseStream)
{
await getResponse.ResponseStream.CopyToAsync(memoryStream);
memoryStream.Position = 0;
}
using (memoryStream)
{
var metadataWrapper = MetadataCollectionWrapper.For(getResponse.Metadata);
var fileName = metadataWrapper.Read <string>(MetadataElement.Filename);
IUploadedFileMetadata binaryMetadata;
if (binaryElement.Value is ICompositeBitmapImageElementValue compositeBitmapImageElementValue &&
compositeBitmapImageElementValue.Raw != fileKey)
{
var image = compositeBitmapImageElementValue.SizeSpecificImages.First(x => x.Raw == fileKey);
binaryMetadata = new UploadedImageMetadata(
fileName,
getResponse.Headers.ContentType,
getResponse.ContentLength,
image.Size);
}
public async Task <GetObjectResponse> GetObjectAsync(string bucketName, string key, CancellationToken cancellationToken = default) => await _s3Client.GetObjectAsync(bucketName, key, cancellationToken);
public async Task <GetObjectResponse> GetObjectAsync(string bucketName, string key) => await _s3Client.GetObjectAsync(bucketName, key);
public async Task <GetObjectResponse> GetObjectAsync(string bucketName, string key) => await ExecuteS3Request(() => _s3Client.GetObjectAsync(bucketName, key), bucketName);
public async Task <GetObjectResponse> GetObjectAsync(string bucketName, string key, CancellationToken cancellationToken) => await ExecuteS3Request(() => _s3Client.GetObjectAsync(bucketName, key, cancellationToken), bucketName);
