public async Task PostAsync(S3FileKey key, TValue source)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var stream = _containerConverter.GetStream(source);
var metaData = _containerConverter.GetMetaData(source);
stream.Position = 0;
var request = new PutObjectRequest
{
BucketName = BucketNameConstructor.GetBucketName(key),
Key = key.Key,
InputStream = stream,
TagSet = metaData.ToTagSet(_containerConverter.GetOriginKey()).ToList(),
AutoCloseStream = false
};
metaData.CopyToMetadataCollection(request.Metadata, _containerConverter.GetOriginKey());
await AmazonS3.PutObjectAsync(request);
stream.Position = 0;
}
public async Task <IEnumerable <S3FileKey> > GetS3FileKeyVersionsAsync(S3FileKey key)
{
IEnumerable <S3FileKey> response = Enumerable.Empty <S3FileKey>();
await ExcecuteAsync(async() => response = await _repositoryHistoryReader.GetS3FileKeyVersionsAsync(key), key);
return(response);
}
public async Task <IEnumerable <TValue> > GetHistoryAsync(S3FileKey key, bool includeMetadata)
{
IEnumerable <TValue> response = Enumerable.Empty <TValue>();
await ExcecuteAsync(async() => response = await _repositoryHistoryReader.GetHistoryAsync(key, includeMetadata), key);
return(response);
}
public async Task <TValue> GetAsync(S3FileKey key, bool includeMetadata)
{
TValue response = default(TValue);
await ExcecuteAsync(async() => response = await _s3ClientReader.GetAsync(key, includeMetadata), key);
return(response);
}
public async Task <TValue> GetAsync(S3FileKey key, bool includeMetadata)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(includeMetadata ? await GetWithMetadataAsync(key)
: await GetWithoutMetadataAsync(key));
}
public async Task <IEnumerable <S3FileKey> > GetS3FileKeyVersionsAsync(S3FileKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var objectVersions = await GetS3ObjectVersions(key);
return(objectVersions.Select(x => x.ToVersionedS3FileKey(key)));
}
private async Task <GetObjectResponse> GetObjectAsync(S3FileKey key)
{
var request = new GetObjectRequest
{
BucketName = BucketNameConstructor.GetBucketName(key),
Key = key.Key,
VersionId = key.VersionId
};
return(await AmazonS3.GetObjectAsync(request));
}
private async Task <IDictionary <string, string> > GetTagsAsync(S3FileKey key)
{
var getTagsRequest = new GetObjectTaggingRequest
{
BucketName = BucketNameConstructor.GetBucketName(key),
Key = key.Key,
VersionId = key.VersionId
};
var objectTags = await AmazonS3.GetObjectTaggingAsync(getTagsRequest);
return(objectTags.Tagging.ToDictionary());
}
private async Task <TValue> GetWithoutMetadataAsync(S3FileKey key)
{
var getObjectsTask = GetObjectAsync(key);
var result = new MemoryStream();
using (var response = await getObjectsTask)
{
await response.ResponseStream.CopyToAsync(result);
}
result.Position = 0;
return(_containerConverter.GetDataContainer(result, new Dictionary <string, string>()));
}
public async Task <IEnumerable <TValue> > GetHistoryAsync(S3FileKey key, bool includeMetadata)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var fileVersions = await GetS3ObjectVersions(key);
var recentVersions = fileVersions.TakeWhile(item => !item.IsDeleteMarker).ToList();
var recentFileKeys = recentVersions.Select(x => x.ToVersionedS3FileKey(key)).ToList();
var recentFiles = await GetOrderedVersionsAsync(recentFileKeys, includeMetadata);
return(recentFiles);
}
private async Task <TValue> GetWithMetadataAsync(S3FileKey key)
{
var getObjectsTask = GetObjectAsync(key);
var getTagsTask = GetTagsAsync(key);
await Task.WhenAll(getObjectsTask, getTagsTask);
var result = new MemoryStream();
IDictionary <string, string> metaData;
using (var response = await getObjectsTask)
{
await response.ResponseStream.CopyToAsync(result);
metaData = response.Metadata.ToDictionary();
}
result.Position = 0;
var tags = await getTagsTask;
return(_containerConverter.GetDataContainer(result, Merge(metaData, tags)));
}
private async Task <IEnumerable <S3ObjectVersion> > GetS3ObjectVersions(S3FileKey key)
{
var request = new ListVersionsRequest
{
BucketName = BucketNameConstructor.GetBucketName(key),
Prefix = key.Key
};
var result = new List <S3ObjectVersion>();
ListVersionsResponse response;
do
{
response = await AmazonS3.ListVersionsAsync(request);
result.AddRange(response.Versions);
request.VersionIdMarker = response.NextVersionIdMarker;
request.KeyMarker = response.NextKeyMarker;
} while (response.IsTruncated);
return(result);
}
public async Task <TValue> GetAsync(S3FileKey key, bool includeMetadata)
{
return(await RetryPolicy.ExecuteAsync(() => _repositoryReader.GetAsync(key, includeMetadata)));
}
public async Task PostAsync(S3FileKey key, TValue fileContainer)
{
await CircuitBreakerPolicy.ExecuteAsync(() =>
_repositoryWriter.PostAsync(key, fileContainer));
}
public async Task PostAsync(S3FileKey key, TValue value)
{
await RetryPolicy.ExecuteAsync(() => _repositoryWriter.PostAsync(key, value));
}
public async Task PostAsync(S3FileKey key, TValue fileContainer)
{
await ExcecuteAsync(async() => await _s3ClientWriter.PostAsync(key, fileContainer), key);
}
public static S3FileKey ToVersionedS3FileKey(this S3ObjectVersion objectVersion, S3FileKey initialKey)
{
if (objectVersion == null)
{
throw new ArgumentNullException(nameof(objectVersion));
}
if (initialKey == null)
{
throw new ArgumentNullException(nameof(initialKey));
}
return(FileKeyGenerator.New()
.WithFileName(initialKey.FileName)
.WithFolderPath(initialKey.FolderPath)
.WithBucketType(initialKey.BucketType)
.WithVersion(objectVersion.VersionId)
.Build());
}