internal override void Execute()
{
FileInfo fi = new FileInfo(filePath);
FileStream input = File.OpenRead(filePath);
string checksum = TreeHashGenerator.CalculateTreeHash(input);
try
{
UploadArchiveRequest uploadRequest = new UploadArchiveRequest()
.WithAccountId(this.options.AccountId)
.WithArchiveDescription(archiveDescription)
.WithVaultName(vaultName)
.WithChecksum(checksum)
.WithBody(input);
uploadRequest.StreamTransferProgress += this.ProgressCallback;
uploadRequest.BeforeRequestEvent += new UserAgentPostFix("SingleUpload").UserAgentRequestEventHandlerSync;
UploadArchiveResult uploadArchiveResult =
this.manager.GlacierClient.UploadArchive(uploadRequest).UploadArchiveResult;
string archiveId = uploadArchiveResult.ArchiveId;
this.UploadResult = new UploadResult(archiveId, checksum);
}
finally
{
try { input.Close(); }
catch (Exception) { }
}
}
internal override void Execute()
{
FileStream input = File.OpenRead(filePath);
string checksum = TreeHashGenerator.CalculateTreeHash(input);
try
{
UploadArchiveRequest uploadRequest = new UploadArchiveRequest()
{
AccountId = this.options.AccountId,
ArchiveDescription = archiveDescription,
VaultName = vaultName,
Checksum = checksum,
Body = input
};
uploadRequest.StreamTransferProgress += this.ProgressCallback;
uploadRequest.BeforeRequestEvent += new UserAgentPostFix("SingleUpload").UserAgentRequestEventHandlerSync;
UploadArchiveResponse uploadArchivResponse =
this.manager.GlacierClient.UploadArchive(uploadRequest);
string archiveId = uploadArchivResponse.ArchiveId;
this.UploadResult = new UploadResult(archiveId, checksum);
}
finally
{
try { input.Close(); }
catch (Exception) { }
}
}
internal override async Task ExecuteAsync()
{
FileStream input = File.OpenRead(filePath);
string checksum = TreeHashGenerator.CalculateTreeHash(input);
try
{
UploadArchiveRequest uploadRequest = new UploadArchiveRequest()
{
AccountId = this.options.AccountId,
ArchiveDescription = archiveDescription,
VaultName = vaultName,
Checksum = checksum,
Body = input
};
uploadRequest.StreamTransferProgress += this.ProgressCallback;
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)uploadRequest).AddBeforeRequestHandler(new ArchiveTransferManager.UserAgentPostFix("SingleUpload").UserAgentRequestEventHandlerSync);
UploadArchiveResponse uploadArchivResponse =
await this.manager.GlacierClient.UploadArchiveAsync(uploadRequest).ConfigureAwait(false);
string archiveId = uploadArchivResponse.ArchiveId;
this.UploadResult = new UploadResult(archiveId, checksum);
}
finally
{
try { input.Dispose(); }
catch (Exception) { }
}
}
public void UploadVaultArchive()
{
var stream = File.OpenRead(AppDomain.CurrentDomain.BaseDirectory + "\\test.txt");
UploadArchiveRequest request = new UploadArchiveRequest
{
VaultName = vaultName,
AccountId = "-",
ArchiveDescription = "test desc",
Checksum = TreeHashGenerator.CalculateTreeHash(stream),
Body = stream
};
request.StreamTransferProgress += OnUploadProgress;
var response = client.UploadArchive(request);
if (response.HttpStatusCode.IsSuccess())
{
Console.WriteLine("Archive Uploaded successfully");
Console.WriteLine($"RequestId: {response.ResponseMetadata.RequestId}");
foreach (var item in response.ResponseMetadata.Metadata)
{
Console.WriteLine($"{item.Key}:{item.Value}");
}
}
}
internal UploadArchiveResponse UploadArchive(UploadArchiveRequest request)
{
var marshaller = new UploadArchiveRequestMarshaller();
var unmarshaller = UploadArchiveResponseUnmarshaller.Instance;
return(Invoke <UploadArchiveRequest, UploadArchiveResponse>(request, marshaller, unmarshaller));
}
private static string UploadArchive(AmazonGlacierClient glacier)
{
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes("data to archive"));
string treeHash = TreeHashGenerator.CalculateTreeHash(ms);
UploadArchiveRequest req = new UploadArchiveRequest();
req.VaultName = vaultName;
req.Body = ms;
req.Checksum = treeHash;
Task <UploadArchiveResponse> res = glacier.UploadArchiveAsync(req);
Task.WaitAll(res);
if (res.IsCompletedSuccessfully)
{
Console.WriteLine("ArchiveId: {0}", res.Result.ArchiveId);
return(res.Result.ArchiveId);
}
else
{
return(string.Empty);
}
}
// Commented out because the would leave data in glacier that would cost money
//[TestMethod]
//[TestCategory("Glacier")]
public void TestSimpleUpload()
{
var testingVaultName = "dotnet-sdk-test" + DateTime.Now.Ticks.ToString();
Client.CreateVault(new CreateVaultRequest()
{
VaultName = testingVaultName
});
const string accountID = "-";
string archiveID = null;
try
{
var memoryStream = new MemoryStream(Encoding.ASCII.GetBytes("data to archive"));
var uploadArchiveRequest = new UploadArchiveRequest
{
VaultName = testingVaultName,
Body = memoryStream,
Checksum = TreeHashGenerator.CalculateTreeHash(memoryStream),
AccountId = accountID,
ArchiveDescription = "my first archive"
};
var response = Client.UploadArchive(uploadArchiveRequest);
archiveID = response.ArchiveId;
}
finally
{
Client.DeleteArchive(new DeleteArchiveRequest {
AccountId = accountID, VaultName = testingVaultName, ArchiveId = archiveID
});
}
}
public async Task TestSimpleUpload()
{
await Client.CreateVaultAsync(new CreateVaultRequest()
{
VaultName = testingVaultName
}).ConfigureAwait(false);
const string accountID = "-";
string archiveID = null;
var memoryStream = new MemoryStream(Encoding.ASCII.GetBytes("data to archive"));
var uploadArchiveRequest = new UploadArchiveRequest
{
VaultName = testingVaultName,
Body = memoryStream,
Checksum = TreeHashGenerator.CalculateTreeHash(memoryStream),
AccountId = accountID,
ArchiveDescription = "my first archive"
};
var response = await Client.UploadArchiveAsync(uploadArchiveRequest).ConfigureAwait(false);
archiveID = response.ArchiveId;
await Client.DeleteArchiveAsync(new DeleteArchiveRequest { AccountId = accountID, VaultName = testingVaultName, ArchiveId = archiveID });
}
public override async Task <StorageFile> UploadFileAsync(Stream fileStream, string fn, StorageFile destFolder,
CancellationToken token, Action <TransferProgress> progressCallback)
{
var path = ((GlacierFile)destFolder).FolderPath;
if (!string.IsNullOrEmpty(path) && !path.EndsWith("/"))
{
path += "/";
}
var filePathName = path + fn;
var fileLen = fileStream.CanSeek ? fileStream.Length : 0;
var checksum = await Task.Run(() => TreeHashGenerator.CalculateTreeHash(fileStream));
var observed = new ObserverStream(fileStream);
var percent = 0;
observed.PositionChanged += (sender, e) =>
{
var currentPercent = fileLen == 0 ? 0 : (int)(100 * ((Stream)sender).Position / (float)fileLen);
if (currentPercent == percent)
{
return;
}
percent = currentPercent;
progressCallback(new TransferProgress(percent));
};
var req = new UploadArchiveRequest(Vault, filePathName.Unidecode(), checksum, observed);
var result = await client.UploadArchiveAsync(req, token);
return(new GlacierFile(this, result.ArchiveId, false, fn));
}
/// <summary>
/// Initiates the asynchronous execution of the UploadArchive operation.
/// <seealso cref="Amazon.Glacier.IAmazonGlacier"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UploadArchive operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <UploadArchiveResponse> UploadArchiveAsync(UploadArchiveRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new UploadArchiveRequestMarshaller();
var unmarshaller = UploadArchiveResponseUnmarshaller.Instance;
return(InvokeAsync <UploadArchiveRequest, UploadArchiveResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public static Task <UploadArchiveResponse> UploadArchiveAsync(string vaultName, string archiveDescription, string checksum, Stream body)
{
using (var client = GetGlacierClient())
{
UploadArchiveRequest request = new UploadArchiveRequest(GetAccountId(), vaultName, archiveDescription, checksum, body);
return(client.UploadArchiveAsync(request));
}
}
public void UploadVaultObject()
{
try
{
var stream = File.OpenRead(AppDomain.CurrentDomain.BaseDirectory + "\\example");
UploadArchiveRequest request = new UploadArchiveRequest
{
VaultName = vaultName,
AccountId = "",
ArchiveDescription = "Test Description Upload",
Body = stream,
Checksum = TreeHashGenerator.CalculateTreeHash(stream)
};
request.StreamTransferProgress += OnUploadProgress;
var response = client.UploadArchive(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.Created)
{
Console.WriteLine("Archive Upload Successsfully");
Console.WriteLine($"RequstId: {response.ResponseMetadata.RequestId}");
Console.WriteLine($"ArchiveID {response.ArchiveId}");
foreach (var item in response.ResponseMetadata.Metadata)
{
Console.WriteLine($"{item.Key} / {item.Value}");
}
}
}
catch (AmazonGlacierException e)
{
Console.WriteLine(e.Message);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadLine();
}
static string UploadArchive(IAmazonGlacier glacier)
{
var ms = new MemoryStream(Encoding.UTF8.GetBytes("some data to archive"));
var treeHash = TreeHashGenerator.CalculateTreeHash(ms);
var req = new UploadArchiveRequest
{
VaultName = VaultName,
Body = ms,
Checksum = treeHash
};
Task <UploadArchiveResponse> res = glacier.UploadArchiveAsync(req);
Task.WaitAll(res);
if (res.IsCompletedSuccessfully)
{
Console.WriteLine($"Upload archive to ArchiveId {res.Result.ArchiveId}");
return(res.Result.ArchiveId);
}
return(string.Empty);
}
public async Task <ImageUploadedModel> UploadImage(
string bucketName,
string bucketUrl,
string objectKey,
S3StorageClass storageClass,
S3CannedACL permissions,
string glacierVaultName,
ImageInfo image)
{
ImageUploadedModel model = new ImageUploadedModel();
try
{
PutObjectRequest putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = objectKey,
StorageClass = storageClass,
CannedACL = permissions,
ContentType = image.MimeType,
AutoCloseStream = false
};
putRequest.Metadata.Add("width", image.Width.ToString());
putRequest.Metadata.Add("height", image.Height.ToString());
putRequest.InputStream = image.Image;
byte[] md5Hash = image.Image.Md5Hash();
putRequest.MD5Digest = md5Hash.ToBase64String();
PutObjectResponse response = await S3Client.PutObjectAsync(putRequest);
string eTag = response.ETag.Trim('"').ToLowerInvariant();
string expectedETag = md5Hash.ToS3ETagString();
if (eTag != expectedETag)
{
throw new Exception("The eTag received from S3 doesn't match the eTag computed before uploading. This usually indicates that the image has been corrupted in transit.");
}
// upload to Glacier if needed
if (!string.IsNullOrWhiteSpace(glacierVaultName))
{
ArchiveDescription description = new ArchiveDescription
{
ObjectKey = objectKey,
ContentType = image.MimeType,
Width = image.Width,
Height = image.Height
};
// reset stream position in image
image.Image.Position = 0;
UploadArchiveRequest glacierRequest = new UploadArchiveRequest
{
ArchiveDescription = JsonConvert.SerializeObject(description, Formatting.None),
Body = image.Image,
VaultName = glacierVaultName,
Checksum = TreeHashGenerator.CalculateTreeHash(image.Image)
};
UploadArchiveResponse glacierResponse = await GlacierClient.UploadArchiveAsync(glacierRequest);
model.ArchiveId = glacierResponse.ArchiveId;
}
model.ObjectKey = objectKey;
model.ETag = eTag;
model.ObjectLocation = bucketUrl + objectKey;
model.VersionId = response.VersionId;
}
catch (Exception ex)
{
model.Exception = ex;
}
return(model);
}
