public async Task DeleteRecursiveAsync(string fullPath, CancellationToken cancellationToken)
{
ListObjectsV2Request request = new ListObjectsV2Request
{
BucketName = this._bucketName, Prefix = fullPath + "/"
};
while (true)
{
ListObjectsV2Response response =
await this._client.ListObjectsV2Async(request, cancellationToken).ConfigureAwait(false);
await Task.WhenAll(
response.S3Objects.Select(
s3 =>
this._client.DeleteObjectAsync(this._bucketName, s3.Key, cancellationToken)));
if (response.NextContinuationToken != null)
{
request.ContinuationToken = response.NextContinuationToken;
}
else
{
break;
}
}
}
/// <summary>
/// Lists all buckets, optionaly filtering by prefix. Prefix filtering happens on client side.
/// </summary>
public async Task <IEnumerable <BlobId> > ListAsync(ListOptions options, CancellationToken cancellationToken)
{
if (options == null)
{
options = new ListOptions();
}
GenericValidation.CheckBlobPrefix(options.Prefix);
var request = new ListObjectsV2Request()
{
BucketName = _bucketName,
Prefix = options.Prefix ?? null
};
if (options.MaxResults.HasValue)
{
request.MaxKeys = options.MaxResults.Value;
}
//todo: paging
ListObjectsV2Response response = await _client.ListObjectsV2Async(request, cancellationToken);
return(response.S3Objects
.Select(s3Obj => new BlobId(StoragePath.RootFolderPath, s3Obj.Key, BlobItemKind.File)));
}
static async Task CreateFoldersAsync(string bucketName, string path)
{
var findFolderRequest = new ListObjectsV2Request();
findFolderRequest.BucketName = bucketName;
findFolderRequest.Prefix = path;
ListObjectsV2Response findFolderResponse =
await s3Client.ListObjectsV2Async(findFolderRequest);
if (findFolderResponse.S3Objects.Any())
{
return;
}
PutObjectRequest request = new PutObjectRequest()
{
BucketName = bucketName,
Key = path,
ContentBody = string.Empty
};
// add try catch in case you have exceptions shield/handling here
PutObjectResponse response = await s3Client.PutObjectAsync(request);
}
internal void RenameFolder(String sourceKey, String destKey)
{
String fullSource = GetFullPrefix(sourceKey);
String fullDest = GetFullPrefix(destKey);
ListObjectsV2Request request = new ListObjectsV2Request()
{
BucketName = _bucketName,
FetchOwner = false,
Prefix = VirtualPathUtility.AppendTrailingSlash(fullSource),
};
ListObjectsV2Response response = null;
do
{
if (response != null && response.IsTruncated)
{
request.ContinuationToken = response.NextContinuationToken;
}
response = _S3Client.ListObjectsV2(request);
foreach (S3Object s3Object in response.S3Objects)
{
String newKey = fullDest + s3Object.Key.Substring(fullSource.Length);
RenameObject(s3Object.Key, newKey);
}
} while (response != null && response.IsTruncated);
}
public async Task <IEnumerable <TaggedImage> > GetAllImages()
{
using (var scope = _logger.BeginScope(nameof(GetAllImages)))
{
var request = new ListObjectsV2Request
{
BucketName = _s3BucketName
};
ListObjectsV2Response response = null;
var taggedFiles = new List <TaggedImage>();
do
{
response = await _s3Client.ListObjectsV2Async(request);
_logger.LogDebug($"Response: {JsonConvert.SerializeObject(response)}");
var batch = response.S3Objects
.Where(o => IsSupportedImageFormat(o.Key))
.Select(o => GetTaggedImage(o).Result);
taggedFiles.AddRange(batch);
} while (response.HttpStatusCode == HttpStatusCode.OK && response.IsTruncated);
return(taggedFiles);
}
}
public ListObjectsV2Response ListObjectsByPrefixOrDelimiter(string bucketName, string key, string delimiter = null)
{
try
{
var request = new ListObjectsV2Request()
{
BucketName = bucketName, Prefix = key
};
if (delimiter != null)
{
request.Delimiter = delimiter;
}
var listObjectV2Response = new ListObjectsV2Response();
do
{
var response = _amazonS3.ListObjectsV2Async(request).Result;
if (response == null || response?.KeyCount == 0)
{
return(listObjectV2Response);
}
listObjectV2Response.IsTruncated = response.IsTruncated;
listObjectV2Response.S3Objects.AddRange(response.S3Objects);
} while (listObjectV2Response.IsTruncated);
return(listObjectV2Response);
}
catch (Exception ex)
{
Console.WriteLine(JsonConvert.SerializeObject(ex));
throw ex;
}
}
/// <summary>
/// GetListing generates a list of <see cref="T:Amazon.S3.Model.S3Object" /> within a certain prefix, without recursing by default (folder specific listing)
/// </summary>
/// <param name="prefix">Prefix to list</param>
/// <param name="recursive">Request recursive listing under folder</param>
/// <returns>List of <see cref="T:Amazon.S3.Model.S3Object" /></returns>
/// <remarks>In Amazon S3, folders are non-existing items. This function generates pseudo-items for folders.</remarks>
internal IEnumerable <S3ItemData> GetListing(String prefix, bool recursive = false)
{
ListObjectsV2Request request = new ListObjectsV2Request()
{
BucketName = _bucketName,
FetchOwner = false,
Prefix = VirtualPathUtility.AppendTrailingSlash(GetFullPrefix(prefix)),
Delimiter = recursive ? null : "/"
};
ListObjectsV2Response response = null;
do
{
if (response != null && response.IsTruncated)
{
request.ContinuationToken = response.NextContinuationToken;
}
response = _S3Client.ListObjectsV2(request);
foreach (String subPrefix in response.CommonPrefixes)
{
yield return(GetFolder(StripPrefix(subPrefix)));
}
foreach (S3Object s3Object in response.S3Objects)
{
yield return(new S3ItemData(StripPrefix(s3Object.Key), _bucketUrl, s3Object));
}
} while (response != null && response.IsTruncated);
}
public void GetAllIdsReturnsAllIdsFromListObjectsV2Test()
{
var response = new ListObjectsV2Response
{
S3Objects = new List <S3Object>()
{
new S3Object {
Key = "keyprefix/1"
},
new S3Object {
Key = "keyprefix/2"
},
new S3Object {
Key = "keyprefix/3"
}
}
};
_mockS3Client
.Setup(
x => x.ListObjectsV2Async(
It.Is <ListObjectsV2Request>(
y => y.BucketName == "mybucket" && y.Prefix == "keyprefix/" && y.Delimiter == "/"),
It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
var result = _store.GetAllIds().Result;
Assert.Equal(3, result.Count);
Assert.Contains(1, result);
Assert.Contains(2, result);
Assert.Contains(3, result);
}
public async Task <IReadOnlyCollection <XElement> > GetAllElementsAsync(CancellationToken cancellation)
{
var items = new List <S3Object>();
ListObjectsV2Response response = null;
do
{
response = await _client.ListObjectsV2Async(new ListObjectsV2Request
{
BucketName = Config.Bucket,
Prefix = Config.KeyPrefix,
ContinuationToken = response?.NextContinuationToken
}, cancellation);
items.AddRange(response.S3Objects);
} while (response.IsTruncated);
using (var throttler = new SemaphoreSlim(Config.MaxS3QueryConcurrency))
{
var queries = new List <Task <XElement> >();
foreach (var item in items)
{
queries.Add(GetElementFromKeyAsync(item, throttler, cancellation));
}
await Task.WhenAll(queries).ConfigureAwait(false);
return(new ReadOnlyCollection <XElement>(queries.Select(x => x.Result).Where(x => x != null).ToList()));
}
}
private async Task <ListObjectsV2Response> ListContainerObjects(string folderKey, bool useDelimiter = true)
{
var request = new ListObjectsV2Request
{
BucketName = _amazonS3Config.Bucket,
Prefix = $"{folderKey}/",
Delimiter = useDelimiter ? "/" : string.Empty
};
var response = new ListObjectsV2Response();
var paginatedResponse = new ListObjectsV2Response
{
IsTruncated = true
};
while (paginatedResponse.IsTruncated)
{
request.ContinuationToken = paginatedResponse.NextContinuationToken;
paginatedResponse = await _amazonS3.ListObjectsV2Async(request);
response.S3Objects.AddRange(paginatedResponse.S3Objects);
response.CommonPrefixes.AddRange(paginatedResponse.CommonPrefixes);
}
return(response);
}
/// <summary>
/// Uses the client object to get a list of the objects in the Amazon
/// S3 bucket in the bucketName parameter.
/// </summary>
/// <param name="client">The initialized Amazon S3 client object used to call
/// the ListObjectsAsync method.</param>
/// <param name="bucketName">The bucket name for which you want to
/// retrieve a list of objects.</param>
public static async Task ListingObjectsAsync(IAmazonS3 client, string bucketName)
{
try
{
ListObjectsV2Request request = new()
{
BucketName = bucketName,
MaxKeys = 5,
};
var response = new ListObjectsV2Response();
do
{
response = await client.ListObjectsV2Async(request);
response.S3Objects
.ForEach(obj => Console.WriteLine($"{obj.Key,-35}{obj.LastModified.ToShortDateString(),10}{obj.Size,10}"));
// If the response is truncated, set the request ContinuationToken
// from the NextContinuationToken property of the response.
request.ContinuationToken = response.NextContinuationToken;
} while (response.IsTruncated);
}
catch (AmazonS3Exception ex)
{
Console.WriteLine($"Error encountered on server. Message:'{ex.Message}' getting list of objects.");
}
}
public async Task <List <string> > GetCensusFiles()
{
var request = new ListObjectsV2Request
{
BucketName = environmentModel.Bucket,
Prefix = environmentModel.KeyPrefix
};
ListObjectsV2Response listResponse = null;
listResponse = await awsClient.ListObjectsV2Async(request);
var keys = listResponse.S3Objects
.Select(a => a.Key)
.ToList();
while (listResponse.IsTruncated)
{
request = new ListObjectsV2Request
{
BucketName = environmentModel.Bucket,
ContinuationToken = listResponse.NextContinuationToken
};
listResponse = await awsClient.ListObjectsV2Async(request);
var newKeys = listResponse.S3Objects
.Select(a => a.Key)
.ToList();
keys.AddRange(newKeys);
}
return(keys);
}
private Batch ProcessResponse(int batchId, ListObjectsV2Response response)
{
// move to the next batch
Interlocked.Exchange(ref _continuationToken, response.NextContinuationToken);
Interlocked.Exchange(ref _startAtKey, null);
// build the batch for the target objects
Batch batch = new Batch(_prefix, batchId, _stopAtKey, response);
// we should only ever add batches whose key ranges are after the ones we already had
if (!string.IsNullOrEmpty(_unprefixedGreatestKey) && String.CompareOrdinal(batch.LeastKey, _unprefixedGreatestKey) < 0)
{
throw new InvalidOperationException("The specified response is for objects that are lesser than the ones already processing. Responses must be processed in order (" + batch.LeastKey + "/" + _unprefixedGreatestKey + ").");
}
if (!string.IsNullOrEmpty(_unprefixedGreatestKey) && String.CompareOrdinal(batch.GreatestKey, _unprefixedGreatestKey) < 0)
{
throw new InvalidOperationException("The specified response is for objects that are lesser than the ones already processing. Responses must be processed in order (" + batch.GreatestKey + "/" + _unprefixedGreatestKey + ").");
}
// no least key specified yet? use the one from the batch
if (string.IsNullOrEmpty(_unprefixedLeastKey))
{
Interlocked.Exchange(ref _unprefixedLeastKey, batch.LeastKey);
}
// the greatest key should be the one from this new batch
Interlocked.Exchange(ref _unprefixedGreatestKey, batch.GreatestKey);
// add this batch to the queue
_queue.Enqueue(batch);
Interlocked.Exchange(ref _lastQueuedBatchId, batchId);
// is this the last batch?
Interlocked.Exchange(ref _lastBatchHasBeenRead, batch.Response.IsTruncated ? 0 : 1);
return(batch);
}
public void ExpectEmptyQueryToSucceed()
{
var listResponse = new ListObjectsV2Response
{
Name = Bucket,
Prefix = Prefix
};
config.Setup(x => x.Bucket).Returns(Bucket);
config.Setup(x => x.KeyPrefix).Returns(Prefix);
config.Setup(x => x.MaxS3QueryConcurrency).Returns(10);
s3Client.Setup(x => x.ListObjectsV2Async(It.IsAny <ListObjectsV2Request>(), CancellationToken.None))
.ReturnsAsync(listResponse)
.Callback <ListObjectsV2Request, CancellationToken>((lr, ct) =>
{
Assert.Equal(Bucket, lr.BucketName);
Assert.Equal(Prefix, lr.Prefix);
Assert.Null(lr.ContinuationToken);
});
IReadOnlyCollection <XElement> list = xmlRepository.GetAllElements();
Assert.Equal(0, list.Count);
}
private Batch GetNextBatch()
{
// already queued the last batch? return an indicator that we're at the end!
if (_lastBatchHasBeenRead != 0)
{
return(null);
}
ListObjectsV2Request request = BuildRequest();
Program.State.AddChargeForQueries(1);
int batchId = _batchIdCounter.Next;
string operation = "QUERY: Get batch " + batchId + " from " + _bucket + "/" + _prefix;
Interlocked.Exchange(ref _lastQuery, operation);
Stopwatch timer = Stopwatch.StartNew();
ListObjectsV2Response response = null;
using (Program.TrackOperation(operation))
{
response = _s3.ListObjectsV2(request);
}
if (!response.IsTruncated)
{
Program.LogVerbose("Last batch from " + _bucket + "/" + _prefix + "!");
}
using (Program.TrackOperation("QUERY: processing batch " + batchId + " from " + _bucket + "/" + _prefix + " (" + response.S3Objects.Count + ")"))
{
return(ProcessResponse(batchId, response));
}
}
private S3Object getFile()
{
AmazonS3Client client = getConfig();
ListObjectsV2Request request = new ListObjectsV2Request()
{
BucketName = _bucketName
};
ListObjectsV2Response list = client.ListObjectsV2(request);
long data = 0;
S3Object file = new S3Object();
foreach (var item in list.S3Objects)
{
if (data < item.Size)
{
file = item;
data = item.Size;
}
}
// Convert Bytes to MB
double t = (file.Size / 1024f) / 1024f;
// Check how many files we need to achieve x quantity of GB (This case 4.9GB)
t = 4900 / t;
// Round number and converted to Int
cantidad = Convert.ToInt32(Math.Round(t));
// Return S3 Object
return(file);
}
public void ListBucketContents()
{
var andrew = "";
var secret = "";
//this.bucket = "stuff.tiz.digital";
AmazonS3Client client = new AmazonS3Client(andrew, secret, RegionEndpoint.APSoutheast2);
// Issue call
ListBucketsResponse response = client.ListBuckets();
// View response data
Debug.WriteLine($"Buckets owner - {response.Owner.DisplayName}");
foreach (S3Bucket bucket in response.Buckets)
{
Debug.WriteLine($"{bucket.BucketName}, Created {bucket.CreationDate}");
}
ListObjectsV2Request objRequest = new ListObjectsV2Request
{
BucketName = "rmccomb"
};
ListObjectsV2Response objResponse = client.ListObjectsV2(objRequest);
foreach (S3Object obj in objResponse.S3Objects)
{
Debug.WriteLine($"{obj.BucketName} {obj.Key}");
}
}
public async Task <List <string> > IndexSchema()
{
if (!_distributedCacheConfiguration.UseDistributedCache)
{
_logger.LogWarning($"S3FileSchemaProvider::IndexSchema, A request to index form schema was made but UseDistributedCache is disabled");
return(new List <string>());
}
var result = new ListObjectsV2Response();
try
{
result = await _s3Gateway.ListObjectsV2(_configuration["S3BucketKey"], $"{_environment.EnvironmentName.ToS3EnvPrefix()}/{_configuration["ApplicationVersion"]}");
}
catch (Exception e)
{
_logger.LogWarning($"S3FileSchemaProvider::IndexSchema, Failed to retrieve list of forms from s3 bucket {_environment.EnvironmentName.ToS3EnvPrefix()}/{_configuration["ApplicationVersion"]}, Exception: {e.Message}");
return(new List <string>());
}
var indexKeys = result.S3Objects.Select(_ => _.Key).ToList();
_ = _distributedCacheWrapper.SetStringAsync(CacheConstants.INDEX_SCHEMA, JsonConvert.SerializeObject(indexKeys), _distributedCacheExpirationConfiguration.Index);
return(indexKeys);
}
static void ListBucket()
{
string continuationToken = Common.InputString("Continuation token:", null, true);
ListObjectsV2Request request = new ListObjectsV2Request();
request.BucketName = _Bucket;
request.ContinuationToken = continuationToken;
ListObjectsV2Response response = _S3Client.ListObjectsV2Async(request).Result;
if (response != null)
{
foreach (S3Object curr in response.S3Objects)
{
Console.WriteLine(curr.Key + ": " + curr.Size + " bytes");
}
if (!String.IsNullOrEmpty(response.NextContinuationToken))
{
Console.WriteLine("Continuation token: " + response.NextContinuationToken);
}
Console.WriteLine("Success");
}
else
{
Console.WriteLine("Failed");
}
}
public async Task <IList <AwsFileInfo> > GetBucketFiles(string bucketName)
{
client = new AmazonS3Client(bucketRegion);
try
{
ListObjectsV2Request request = new ListObjectsV2Request
{
BucketName = bucketName,
MaxKeys = 50
};
ListObjectsV2Response response = await client.ListObjectsV2Async(request);
return(response.S3Objects.Select(x => new AwsFileInfo
{
FileName = x.Key,
Size = x.Size
}).ToList());
// request.ContinuationToken = response.NextContinuationToken;
// while (response.IsTruncated);
}
catch (AmazonS3Exception amazonS3Exception)
{
throw new Exception("S3 error occurred. Exception: " + amazonS3Exception.ToString());
}
catch (Exception e)
{
throw new Exception("Exception: " + e.ToString());
}
}
/// <summary>
/// Lists all buckets, optionaly filtering by prefix. Prefix filtering happens on client side.
/// </summary>
public async Task <IReadOnlyCollection <BlobId> > ListAsync(ListOptions options = null, CancellationToken cancellationToken = default)
{
if (options == null)
{
options = new ListOptions();
}
GenericValidation.CheckBlobPrefix(options.FilePrefix);
var request = new ListObjectsV2Request()
{
BucketName = _bucketName,
Prefix = options.FilePrefix ?? null
};
if (options.MaxResults.HasValue)
{
request.MaxKeys = options.MaxResults.Value;
}
//todo: paging
AmazonS3Client client = await GetClientAsync();
ListObjectsV2Response response = await client.ListObjectsV2Async(request, cancellationToken);
return(response.S3Objects
.Select(s3Obj => new BlobId(StoragePath.RootFolderPath, s3Obj.Key, BlobItemKind.File))
.Where(options.IsMatch)
.Where(bid => (options.FolderPath == null || bid.FolderPath == options.FolderPath))
.Where(bid => options.BrowseFilter == null || options.BrowseFilter(bid))
.ToList());
}
public List <DocumentEntity> ListDocuments(string username)
{
List <DocumentEntity> documents = new List <DocumentEntity>();
SetS3Client();
ListObjectsV2Request request = new ListObjectsV2Request()
{
BucketName = this.BucketName,
Prefix = username
};
try
{
ListObjectsV2Response response = s3Client.ListObjectsV2(request);
if (response.S3Objects.Count > 0)
{
foreach (S3Object s3object in response.S3Objects)
{
documents.Add(ConvertS3ObjectToDocumentEntity(s3object));
}
}
}
catch (Exception ex)
{
throw ex;
}
return(documents);
}
public async Task <IActionResult> ListFiles(string bucketName)
{
string continuationToken = null;
List <ListFilesResponse> result = new List <ListFilesResponse>();
do
{
ListObjectsV2Response response = await _s3Client.ListObjectsV2Async(new ListObjectsV2Request
{
BucketName = bucketName,
ContinuationToken = continuationToken
});
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
return(StatusCode((int)response.HttpStatusCode));
}
continuationToken = response.ContinuationToken;
if (response.S3Objects != null && response.S3Objects.Count > 0)
{
result.AddRange(response.S3Objects.Select(c => new ListFilesResponse
{
BucketName = c.BucketName,
Key = c.Key,
Size = c.Size,
LastModified = c.LastModified,
Owner = c.Owner?.DisplayName
}));
}
} while (continuationToken != null);
return(Ok(result));
}
public async Task <AwsListResponse> GetListAsync(int take, string startKey = "")
{
AwsListResponse awsResponses = new AwsListResponse();
AwsItemListResponse awsResponse = new AwsItemListResponse();
try
{
ListObjectsV2Request request = new ListObjectsV2Request
{
BucketName = BucketPath,
StartAfter = startKey,
MaxKeys = take
};
ListObjectsV2Response response = await _client.ListObjectsV2Async(request);
awsResponse.RequestId = response.ResponseMetadata.RequestId;
awsResponse.HttpStatusCode = response.HttpStatusCode;
do
{
response = await _client.ListObjectsV2Async(request);
awsResponse = new AwsItemListResponse()
{
RequestId = response.ResponseMetadata.RequestId,
HttpStatusCode = response.HttpStatusCode
};
awsResponses.Responses.Add(awsResponse);
foreach (S3Object entry in response.S3Objects)
{
awsResponse.Items.Add(new AwsListItem()
{
Key = entry.Key,
ETag = entry.ETag,
LastModified = entry.LastModified
});
}
Console.WriteLine("Next Continuation Token: {0}", response.NextContinuationToken);
request.ContinuationToken = response.NextContinuationToken;
} while (response.IsTruncated);
}
catch (AmazonS3Exception amazonS3Exception)
{
awsResponses.Exception = amazonS3Exception;
}
catch (Exception e)
{
awsResponses.Exception = e;
}
return(awsResponses);
}
private static async Task <IEnumerable <string> > TransformData(IAmazonS3 client)
{
string outputBucket = _config["OutputBucket"];
await Setup(client);
ListObjectsV2Request listObjectsRequest = new ListObjectsV2Request();
listObjectsRequest.BucketName = _config["InputBucket"];
ListObjectsV2Response listResponse = client.ListObjectsV2Async(listObjectsRequest).Result;
if (listResponse.KeyCount == 0)
{
Console.WriteLine("No items found in input bucket");
return(null);
}
else
{
Console.WriteLine($"Transforming {listResponse.KeyCount} objects");
}
List <string> urls = new List <string>();
foreach (S3Object inputItem in listResponse.S3Objects)
{
GetObjectResponse response =
await client.GetObjectAsync(
inputItem.BucketName,
inputItem.Key
);
PutObjectRequest putRequest = new PutObjectRequest();
putRequest.BucketName = outputBucket;
string outputKey = $"{inputItem.Key.Split("-")[0]}-output";
using (TextReader reader = new StreamReader(response.ResponseStream))
{
putRequest.ContentBody = Convert.ToBase64String(Encoding.UTF8.GetBytes(await reader.ReadToEndAsync()));
putRequest.ContentType = "text/plain";
putRequest.Key = outputKey;
}
await client.PutObjectAsync(putRequest);
GetPreSignedUrlRequest presignedRequest = new GetPreSignedUrlRequest();
presignedRequest.BucketName = outputBucket;
presignedRequest.Key = outputKey;
presignedRequest.Expires = DateTime.Now.AddMinutes(30);
urls.Add(client.GetPreSignedURL(presignedRequest));
}
return(urls);
}
public static IReadOnlyCollection <Blob> ToBlobs(
this ListObjectsV2Response response,
ListOptions options)
{
List <Blob> blobList = new List <Blob>();
blobList.AddRange(response.S3Objects.Where(b => !b.Key.EndsWith("/")).Select(b => b.ToBlob()).Where(options.IsMatch).Where(b => options.BrowseFilter == null || options.BrowseFilter(b)));
blobList.AddRange(response.CommonPrefixes.Select(p => new Blob(p, BlobItemKind.Folder)));
return(blobList);
}
public async Task <List <S3Object> > ListFilesInS3(IAmazonS3 s3Client, string bucketName, string keyPrefix)
{
ListObjectsV2Response response = await s3Client.ListObjectsV2Async(new ListObjectsV2Request()
{
BucketName = bucketName,
Prefix = keyPrefix
});
return(response.S3Objects);
}
private async Task <string> GetNewDirectoryPathIfExists(string folderKey, string folderKeyToCheck, int number = 0)
{
ListObjectsV2Response response = await ListContainerObjects(folderKeyToCheck);
if (response.S3Objects.Count <= 0)
{
return(folderKeyToCheck);
}
return(await GetNewDirectoryPathIfExists(folderKey, $"{folderKey} - Copy {(number > 1 ? $"({number + 1})" : "")}", number + 1));
}
public static async Task Main(string[] args)
{
var client = new AmazonS3Client(RegionEndpoint.EUWest2);
ListBucketsResponse buckets_response = await client.ListBucketsAsync();
foreach (var bucket in buckets_response.Buckets)
{
ListObjectsV2Request req = new ListObjectsV2Request();
req.BucketName = bucket.BucketName;
// NOTE if this finds a folder it includes the folder as an object, and its content as
// more objects. I thought folders didn't exist as such, but it seems they do.
ListObjectsV2Response res = await client.ListObjectsV2Async(req);
int len = res.S3Objects.Count;
Console.WriteLine(bucket.BucketName + " date:" + bucket.CreationDate + " has " + len + " objects.");
if (len > 0)
{
foreach (var obj in res.S3Objects)
{
Console.WriteLine(" " + obj.Key + " " + obj.Size + " " + obj.StorageClass + " " + obj.ETag);
}
}
}
var pollyclient = new AmazonPollyClient();
SynthesizeSpeechRequest request = new SynthesizeSpeechRequest();
request.Text = "Hello my lovely little world.";
request.OutputFormat = OutputFormat.Mp3;
request.VoiceId = VoiceId.Emma;
var pollyres = await pollyclient.SynthesizeSpeechAsync(request);
var fs = new FileStream("c:/tmp/hw.mp3", FileMode.Create);
var instr = pollyres.AudioStream;
byte[] bytes = new byte[256];
int count = 0;
while (true) //count < instr.Length)
{
int c = instr.Read(bytes, 0, 256);
if (c == 0)
{
break;
}
fs.Write(bytes, 0, c);
count += c;
}
fs.Close();
var okater = new NetCoreAudio.Player();
okater.Play("c:/tmp/hw.mp3").Wait();
Console.WriteLine("Thanks for all the fish");
Console.ReadLine();
}
public void fetchKeys()
{
request = new ListObjectsV2Request
{
BucketName = BucketName,
MaxKeys = 5
};
response = client.ListObjectsV2(request);
enumerator = response.S3Objects.GetEnumerator();
}
