public async Task <IActionResult> Download(int id)
{
if (id == 0)
{
return(Content("File not found"));
}
var userId = userManager.GetUserId(HttpContext.User);
var result = dbContext.OcrElements.Where(x => x.UserId == userId && x.Id == id).FirstOrDefault();
if (result == null)
{
return(Content("File not found"));
}
var memory = new MemoryStream();
var downloadRequest = new TransferUtilityOpenStreamRequest
{
Key = result.ImageFilenamePath,
BucketName = _awsAccess.S3BucketName,
};
using (var stream = fileTransferUtility.OpenStream(downloadRequest))
{
await stream.CopyToAsync(memory);
}
memory.Position = 0;
return(File(memory, result.ImageFileContentType, result.ImageFilename));
}
public Stream getMyFilesFromS3(string bucketName, string subDirectoryInBucket, string fileNameInS3)
{
string accessKey = "AKIAWXS64BGGY47QHRWQ";
string secretKey = "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";
AmazonS3Client client = new AmazonS3Client(accessKey, secretKey, RegionEndpoint.USEast2);
// input explained :
// localFilePath = the full local file path e.g. "c:\mydir\mysubdir\myfilename.zip"
// bucketName : the name of the bucket in S3 ,the bucket should be alreadt created
// subDirectoryInBucket : if this string is not empty the file will be uploaded to
// a subdirectory with this name
// fileNameInS3 = the file name in the S3
// create an instance of IAmazonS3 class ,in my case i choose RegionEndpoint.EUWest1
// you can change that to APNortheast1 , APSoutheast1 , APSoutheast2 , CNNorth1
// SAEast1 , USEast1 , USGovCloudWest1 , USWest1 , USWest2 . this choice will not
// store your file in a different cloud storage but (i think) it differ in performance
// depending on your location
//IAmazonS3 client = new AmazonS3Client(RegionEndpoint.USEast2);
// create a TransferUtility instance passing it the IAmazonS3 created in the first step
TransferUtility utility = new TransferUtility(client);
// making a TransferUtilityUploadRequest instance
TransferUtilityOpenStreamRequest request = new TransferUtilityOpenStreamRequest();
if (subDirectoryInBucket == "" || subDirectoryInBucket == null)
{
request.BucketName = bucketName; //no subdirectory just bucket name
}
else
{ // subdirectory and bucket name
request.BucketName = bucketName + @"/" + subDirectoryInBucket;
}
request.Key = fileNameInS3; //file name up in S3
Stream stream = utility.OpenStream(request); //commensing the transfer
return(stream); //indicate that the file was sent
}
/// <summary>
/// Gets the download stream for a specific content..
/// </summary>
/// <param name="content">Descriptor of the item on the remote blob storage.</param>
/// <returns>The binary stream of the content item.</returns>
public override Stream GetDownloadStream(IBlobContent content)
{
TransferUtilityOpenStreamRequest request = new TransferUtilityOpenStreamRequest()
.WithBucketName(this.bucketName).WithKey(content.FilePath);
var stream = this.transferUtility.OpenStream(request);
return(stream);
}
public void ServerSideEncryptionBYOKTransferUtility()
{
var bucketName = S3TestUtils.CreateBucket(Client);
try
{
Aes aesEncryption = Aes.Create();
aesEncryption.KeySize = 256;
aesEncryption.GenerateKey();
string base64Key = Convert.ToBase64String(aesEncryption.Key);
TransferUtility utility = new TransferUtility(Client);
var uploadRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
uploadRequest.InputStream = new MemoryStream(UTF8Encoding.UTF8.GetBytes("Encrypted Content"));
utility.Upload(uploadRequest);
GetObjectMetadataRequest getObjectMetadataRequest = new GetObjectMetadataRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
GetObjectMetadataResponse getObjectMetadataResponse = Client.GetObjectMetadata(getObjectMetadataRequest);
Assert.AreEqual(ServerSideEncryptionCustomerMethod.AES256, getObjectMetadataResponse.ServerSideEncryptionCustomerMethod);
var openRequest = new TransferUtilityOpenStreamRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
using (var stream = new StreamReader(utility.OpenStream(openRequest)))
{
var content = stream.ReadToEnd();
Assert.AreEqual(content, "Encrypted Content");
}
}
finally
{
AmazonS3Util.DeleteS3BucketWithObjects(Client, bucketName);
}
}
public Stream DownloadStream(string bucketName, string fileName)
{
var request = new TransferUtilityOpenStreamRequest()
{
BucketName = bucketName,
Key = fileName,
};
return(base.CreateDefaultRetryPolicy().Execute(() => new TransferUtility(S3Client).OpenStream(request)));
}
public async Task <Stream> DownloadStreamAsync(string bucketName, string fileName, CancellationToken cancellationToken = default)
{
var request = new TransferUtilityOpenStreamRequest()
{
BucketName = bucketName,
Key = fileName,
};
var policy = base.CreateDefaultRetryAsyncPolicy();
return(await policy.ExecuteAsync(async() => await new TransferUtility(S3Client).OpenStreamAsync(request, cancellationToken)));
}
/// <summary>
/// Opens a stream of the content from Amazon S3
/// </summary>
/// <param name="key">The key under which the Amazon S3 object is stored.</param>
/// <param name="version">The identifier for the specific version of the object to be downloaded, if required.</param>
/// <param name="settings">The <see cref="DownloadSettings"/> required to download from Amazon S3.</param>
/// <returns>A stream.</returns>
public Stream Open(string key, string version, DownloadSettings settings)
{
TransferUtility utility = this.GetUtility(settings);
TransferUtilityOpenStreamRequest request = this.CreateOpenRequest(settings);
request.Key = key;
if (!String.IsNullOrEmpty(version))
{
request.VersionId = version;
}
_Log.Verbose("Opening stream {0} from bucket {1}...", key, settings.BucketName);
return(utility.OpenStream(request));
}
public async Task <Stream> StreamFileDownload(string path, string bucket = null)
{
var finalBucket = bucket ?? DefaultBucket;
if (string.IsNullOrWhiteSpace(finalBucket))
{
throw new Exception("S3 Bucket Is Required");
}
using var utility = new TransferUtility(s3Client);
var request = new TransferUtilityOpenStreamRequest
{
BucketName = finalBucket,
Key = path
};
return(await utility.OpenStreamAsync(request));
}
public byte[] DownloadFileByteContents(string remoteFilename)
{
byte[] buffer = null;
TransferUtilityOpenStreamRequest req = new TransferUtilityOpenStreamRequest();
req.BucketName = CurrentBucketName;
req.Key = remoteFilename;
using (Stream s = _transfer.OpenStream(req))
{
buffer = new byte[s.Length];
s.Position = 0;
s.Read(buffer, 0, (int)s.Length);
s.Flush();
}
return(buffer);
}
private TransferUtilityOpenStreamRequest CreateOpenRequest(DownloadSettings settings)
{
TransferUtilityOpenStreamRequest request = new TransferUtilityOpenStreamRequest();
request.BucketName = settings.BucketName;
request.ServerSideEncryptionCustomerProvidedKey = settings.EncryptionKey;
request.ServerSideEncryptionCustomerProvidedKeyMD5 = settings.EncryptionKeyMD5;
request.ServerSideEncryptionCustomerMethod = settings.EncryptionMethod;
if (!String.IsNullOrEmpty(settings.EncryptionKey))
{
request.ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256;
}
request.ModifiedSinceDate = settings.ModifiedDate;
return(request);
}
/// <summary>
/// Get file from s3 bucket
/// </summary>
/// <param name="bucketName">bucket name</param>
/// <param name="key">s3 key - path + file name</param>
/// <returns><see cref="MemoryStream"/>Memory file object</returns>
public async Task <MemoryStream> DownloadMemoryStreamAsync(string bucketName, string key)
{
var memory = new MemoryStream();
try
{
var streamRequest = new TransferUtilityOpenStreamRequest
{
BucketName = bucketName,
Key = key
};
var request = new GetObjectRequest()
{
BucketName = bucketName,
Key = key
};
using (var transferUtility = new TransferUtility(_s3Client))
{
var objectResponse = await transferUtility.S3Client.GetObjectAsync(request);
var stream = objectResponse.ResponseStream;
await stream.CopyToAsync(memory);
}
memory.Position = 0;
return(memory);
}
catch (AmazonS3Exception e)
{
Console.Write("Error encountered on server. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.Write("Download fail", e.Message);
}
return(memory);
}
public async Task <Stream> GetPhotoAsync(string userId, string key, bool isThumbnail)
{
var user = await this.userClient.GetUserAsync(userId);
if (user?.PhotoKeys == null || !user.PhotoKeys.Any())
{
return(null);
}
var details = user.PhotoKeys.FirstOrDefault(d => string.Equals(d.Key, key, StringComparison.OrdinalIgnoreCase));
var photo = this.photoFactory.BuildPhoto(userId, details);
var downloadRequest = new TransferUtilityOpenStreamRequest
{
BucketName = "novelgram",
Key = GetKey(photo, isThumbnail)
};
return(await this.transferUtility.OpenStreamAsync(downloadRequest));
}
public static async Task <Stream> GetFile(string FileId)
{
try
{
TransferUtilityOpenStreamRequest request = new TransferUtilityOpenStreamRequest();
request.BucketName = Config.S3BucketName;
request.Key = FileId;
return(await S3Utility.OpenStreamAsync(request));
}
catch (Exception e)
{
if (Globals.Config.IsDebug)
{
Console.WriteLine("[S3] " + e.ToString());
}
return(null);
}
}
internal OpenStreamCommand(AmazonS3 s3Client, TransferUtilityOpenStreamRequest request)
{
this._s3Client = s3Client;
this._request = request;
}
internal OpenStreamCommand(AmazonS3 s3Client, TransferUtilityOpenStreamRequest request)
{
this._s3Client = s3Client;
this._request = request;
}
