private async Task AbortMultiUpload(HttpClient client, string url) { var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url) { Headers = { { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } } }; var headers = ConvertToHeaders(requestMessage.Headers); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Delete, url, now, headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode) { return; } // The specified multipart upload does not exist. // The upload ID might be invalid, // or the multipart upload might have been aborted or completed. if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); }
public void PutContainer() { var url = GetUrl(_serverUrlForContainer, "restype=container"); var now = SystemTime.UtcNow; var content = new EmptyContent { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion } } }; var client = GetClient(); SetAuthorizationHeader(client, HttpMethods.Put, url, content.Headers); var response = client.PutAsync(url, content, CancellationToken).Result; if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.Conflict) { return; } throw StorageException.FromResponseMessage(response); }
private bool VaultExists() { var url = GetUrl(); var now = SystemTime.UtcNow; var content = new HttpRequestMessage(HttpMethods.Get, url); UpdateHeaders(content.Headers, now, null); var headers = ConvertToHeaders(content.Headers); var client = GetClient(); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = client.SendAsync(content, CancellationToken).Result; if (response.IsSuccessStatusCode) { return(true); } if (response.StatusCode == HttpStatusCode.NotFound) { return(false); } throw StorageException.FromResponseMessage(response); }
public void DeleteContainer() { var url = GetUrl(_serverUrlForContainer, "restype=container"); var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url) { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion } } }; var client = GetClient(); SetAuthorizationHeader(client, HttpMethods.Delete, url, requestMessage.Headers); var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); }
private string GetBucketLocation(bool returnWhenNotFound = false) { using (UseRegionInvariantRequest()) { var url = $"{GetUrl()}?location"; var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Get, url); UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, now, headers); var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.StatusCode == HttpStatusCode.NotFound) { if (returnWhenNotFound) { return(null); } throw new BucketNotFoundException($"Bucket name '{_bucketName}' doesn't exist!"); } if (response.IsSuccessStatusCode == false) { var storageException = StorageException.FromResponseMessage(response); if (response.StatusCode == HttpStatusCode.Forbidden) { throw new AwsForbiddenException(storageException.ResponseString); } throw storageException; } using (var stream = response.Content.ReadAsStreamAsync().Result) using (var reader = new StreamReader(stream)) { var xElement = XElement.Load(reader); var value = xElement.Value; if (value.Equals(string.Empty)) { // when the bucket's region is US East (N. Virginia - us-east-1), // Amazon S3 returns an empty string for the bucket's region value = DefaultRegion; } else if (value.Equals("EU", StringComparison.OrdinalIgnoreCase)) { // EU (Ireland) => EU or eu-west-1 value = "eu-west-1"; } return(value == string.Empty ? DefaultRegion : value); } } }
public async Task <Blob> GetObjectAsync(string key) { var url = $"{GetUrl()}/{key}"; var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Get, url); UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, now, headers); var response = await client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, CancellationToken); if (response.StatusCode == HttpStatusCode.NotFound) { return(null); } if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } var data = await response.Content.ReadAsStreamAsync(); var metadataHeaders = response.Headers.ToDictionary(x => x.Key, x => x.Value.FirstOrDefault()); return(new Blob(data, metadataHeaders)); }
private void CompleteMultiUpload(string url, HttpClient client, List <Tuple <int, string> > partNumbersWithEtag) { var now = SystemTime.UtcNow; var doc = CreateCompleteMultiUploadDocument(partNumbersWithEtag); var xmlString = doc.OuterXml; var requestMessage = new HttpRequestMessage(HttpMethods.Post, url) { Content = new StringContent(xmlString, Encoding.UTF8, "text/plain") }; UpdateHeaders(requestMessage.Headers, now, stream: null, RavenAwsHelper.CalculatePayloadHashFromString(xmlString)); var headers = ConvertToHeaders(requestMessage.Headers); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode) { return; } throw StorageException.FromResponseMessage(response); }
private async Task PutBlockList(string baseUrl, HttpClient client, List <string> blockIds, Dictionary <string, string> metadata) { var url = baseUrl + "?comp=blocklist"; var now = SystemTime.UtcNow; var doc = CreateXmlDocument(blockIds); var xmlString = doc.OuterXml; var content = new StringContent(xmlString, Encoding.UTF8, "text/plain") { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion }, { "Content-Length", Encoding.UTF8.GetBytes(xmlString).Length.ToString(CultureInfo.InvariantCulture) } } }; foreach (var metadataKey in metadata.Keys) { content.Headers.Add("x-ms-meta-" + metadataKey.ToLower(), metadata[metadataKey]); } client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Put, url, content.Headers); var response = await client.PutAsync(url, content, CancellationToken); if (response.IsSuccessStatusCode) { return; } throw StorageException.FromResponseMessage(response); }
private string GetUploadId(string url, string archiveDescription, long lengthPerPartPowerOf2) { var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Post, url) { Headers = { { "x-amz-archive-description", archiveDescription }, { "x-amz-part-size", lengthPerPartPowerOf2.ToString() } } }; UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } return(response.Headers .GetValues("x-amz-multipart-upload-id") .First()); }
public async Task DeleteContainer() { var url = _serverUrlForContainer + "?restype=container"; var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url) { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion } } }; var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Delete, url, requestMessage.Headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); }
public async Task DeleteArchive(string archiveId) { var url = $"{GetUrl()}/archives/{archiveId}"; var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var content = new HttpRequestMessage(HttpMethods.Delete, url) { Headers = { { "x-amz-glacier-version", "2012-06-01" }, { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } } }; var headers = ConvertToHeaders(content.Headers); var client = GetClient(); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Delete, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = await client.SendAsync(content, CancellationToken); if (response.IsSuccessStatusCode) { return; } throw StorageException.FromResponseMessage(response); }
private async Task <string> CompleteMultiUpload( string url, HttpClient client, long archiveSize, string payloadTreeHash) { var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Post, url) { Headers = { { "x-amz-glacier-version", "2012-06-01" }, { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-archive-size", archiveSize.ToString() }, { "x-amz-content-sha256", payloadHash }, { "x-amz-sha256-tree-hash", payloadTreeHash } } }; var headers = ConvertToHeaders(requestMessage.Headers); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } return(ReadArchiveId(response)); }
private async Task <string> UploadPart(Stream baseStream, HttpClient client, string url, long length, int retryCount) { // saving the position if we need to retry var position = baseStream.Position; using (var subStream = new SubStream(baseStream, offset: 0, length: length)) { var now = SystemTime.UtcNow; // stream is disposed by the HttpClient var content = new ProgressableStreamContent(subStream, Progress) { Headers = { { "Content-Length", subStream.Length.ToString(CultureInfo.InvariantCulture) } } }; UpdateHeaders(content.Headers, now, subStream); var headers = ConvertToHeaders(content.Headers); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Put, url, now, headers); try { var response = await client.PutAsync(url, content, CancellationToken); if (response.IsSuccessStatusCode) { var etagHeader = response.Headers.GetValues("ETag"); return(etagHeader.First()); } if (retryCount == MaxRetriesForMultiPartUpload) { throw StorageException.FromResponseMessage(response); } } catch (Exception) { if (retryCount == MaxRetriesForMultiPartUpload) { throw; } } // revert the uploaded count before retry Progress?.UploadProgress.UpdateUploaded(-content.Uploaded); } // wait for one second before trying again to send the request // maybe there was a network issue? await Task.Delay(1000); CancellationToken.ThrowIfCancellationRequested(); // restore the stream position before retrying baseStream.Position = position; return(await UploadPart(baseStream, client, url, length, ++retryCount)); }
private async Task <string> GetUploadId(string url, string archiveDescription, long lengthPerPartPowerOf2) { var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Post, url) { Headers = { { "x-amz-glacier-version", "2012-06-01" }, { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-archive-description", archiveDescription }, { "x-amz-part-size", lengthPerPartPowerOf2.ToString() }, { "x-amz-content-sha256", payloadHash } } }; var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } return(response.Headers .GetValues("x-amz-multipart-upload-id") .First()); }
private string CompleteMultiUpload(string url, HttpClient client, long archiveSize, string payloadTreeHash) { var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Post, url) { Headers = { { "x-amz-archive-size", archiveSize.ToString() }, { "x-amz-sha256-tree-hash", payloadTreeHash } } }; UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } return(ReadArchiveId(response)); }
private void AbortMultiUpload(string url, HttpClient client) { var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url); UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Delete, url, now, headers); var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode) { return; } // The specified multipart upload does not exist. // The upload ID might be invalid, // or the multipart upload might have been aborted or completed. if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); }
public void DeleteObject(string key) { var url = $"{GetUrl()}/{key}"; var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url); UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(TimeSpan.FromHours(1)); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Delete, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); }
private void DeleteBlobsWithSasToken(List <string> blobs) { foreach (var blob in blobs) { var url = GetUrl($"{_serverUrlForContainer}/{blob}"); var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url) { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion } } }; var client = GetClient(); var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.IsSuccessStatusCode) { continue; } if (response.StatusCode == HttpStatusCode.NotFound) { continue; } throw StorageException.FromResponseMessage(response); } }
public async Task DeleteMultipleObjects(List <string> objects) { var url = $"{GetUrl()}/?delete"; var now = SystemTime.UtcNow; var xml = new XElement("Delete"); foreach (var objectPath in objects) { var obj = new XElement("Object"); var key = new XElement("Key", objectPath); obj.Add(key); xml.Add(obj); } var xmlString = xml.ToString(); var md5Hash = CalculateMD5Hash(xmlString); var requestMessage = new HttpRequestMessage(HttpMethods.Post, url) { Content = new StringContent(xmlString, Encoding.UTF8, "text/plain") { Headers = { { "Content-Length", xmlString.Length.ToString(CultureInfo.InvariantCulture) }, { "Content-MD5", md5Hash } } } }; UpdateHeaders(requestMessage.Headers, now, null, RavenAwsHelper.CalculatePayloadHashFromString(xmlString)); var headers = ConvertToHeaders(requestMessage.Headers); headers.Add("Content-MD5", md5Hash); var client = GetClient(TimeSpan.FromHours(1)); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = await client.SendAsync(requestMessage); if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); }
private async Task <string> GetBucketLocation(bool returnWhenNotFound = false) { using (UseRegionInvariantRequest()) { var url = $"{GetUrl()}?location"; var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Get, url) { Headers = { { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } } }; var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, now, headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.StatusCode == HttpStatusCode.NotFound) { if (returnWhenNotFound) { return(null); } throw new BucketNotFoundException($"Bucket name '{_bucketName}' doesn't exist!"); } if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } using (var stream = await response.Content.ReadAsStreamAsync()) using (var reader = new StreamReader(stream)) { var xElement = XElement.Load(reader); var value = xElement.Value; // when the bucket's region is US East (N. Virginia - us-east-1), // Amazon S3 returns an empty string for the bucket's region return(value == string.Empty ? DefaultRegion : value); } } }
public async Task <string> UploadArchive(Stream stream, string archiveDescription) { await TestConnection(); if (stream.Length > MaxUploadArchiveSizeInBytes) { // for objects over 256MB return(await MultiPartUpload(archiveDescription, stream)); } var url = $"{GetUrl()}/archives"; var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(stream); var payloadTreeHash = RavenAwsHelper.CalculatePayloadTreeHash(stream); UploadProgress?.SetTotal(stream.Length); // stream is disposed by the HttpClient var content = new ProgressableStreamContent(stream, UploadProgress) { Headers = { { "x-amz-glacier-version", "2012-06-01" }, { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash }, { "x-amz-sha256-tree-hash", payloadTreeHash }, { "x-amz-archive-description", archiveDescription }, { "Content-Length", stream.Length.ToString(CultureInfo.InvariantCulture) } } }; var headers = ConvertToHeaders(content.Headers); var client = GetClient(TimeSpan.FromHours(24)); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Post, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = await client.PostAsync(url, content, CancellationToken); UploadProgress?.ChangeState(UploadState.Done); if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } return(ReadArchiveId(response)); }
public async Task PutObject(string key, Stream stream, Dictionary <string, string> metadata) { await TestConnection(); if (stream.Length > MaxUploadPutObjectSizeInBytes) { // for objects over 256MB await MultiPartUpload(key, stream, metadata); return; } var url = $"{GetUrl()}/{key}"; var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(stream); Progress?.UploadProgress.SetTotal(stream.Length); // stream is disposed by the HttpClient var content = new ProgressableStreamContent(stream, Progress) { Headers = { { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } } }; foreach (var metadataKey in metadata.Keys) { content.Headers.Add("x-amz-meta-" + metadataKey.ToLower(), metadata[metadataKey]); } var headers = ConvertToHeaders(content.Headers); var client = GetClient(TimeSpan.FromHours(24)); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Put, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = await client.PutAsync(url, content, CancellationToken); Progress?.UploadProgress.ChangeState(UploadState.Done); if (response.IsSuccessStatusCode) { return; } throw StorageException.FromResponseMessage(response); }
private void ThrowError(HttpResponseMessage response) { switch (response.StatusCode) { case HttpStatusCode.Moved: AssertBucketLocation(); break; case HttpStatusCode.Forbidden: AssertBucketPermissions(); break; } throw StorageException.FromResponseMessage(response); }
public async Task PutBlob(string key, Stream stream, Dictionary <string, string> metadata) { await TestConnection(); if (stream.Length > MaxUploadPutBlobInBytes) { // for blobs over 256MB await PutBlockApi(key, stream, metadata); return; } var url = _serverUrlForContainer + "/" + key; Progress?.UploadProgress.SetTotal(stream.Length); var now = SystemTime.UtcNow; // stream is disposed by the HttpClient var content = new ProgressableStreamContent(stream, Progress) { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion }, { "x-ms-blob-type", "BlockBlob" }, { "Content-Length", stream.Length.ToString(CultureInfo.InvariantCulture) } } }; foreach (var metadataKey in metadata.Keys) { content.Headers.Add("x-ms-meta-" + metadataKey.ToLower(), metadata[metadataKey]); } var client = GetClient(TimeSpan.FromHours(3)); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Put, url, content.Headers); var response = await client.PutAsync(url, content, CancellationToken); Progress?.UploadProgress.ChangeState(UploadState.Done); if (response.IsSuccessStatusCode) { return; } throw StorageException.FromResponseMessage(response); }
public async Task PutBucket(string awsRegion = null) { // we set the bucket region in the request message using (UseRegionInvariantRequest()) { var doc = CreatePutBucketXmlDocument(awsRegion ?? AwsRegion); var xmlString = doc.OuterXml; var url = GetUrl(); var now = SystemTime.UtcNow; var hasLocationConstraint = AwsRegion != DefaultRegion; var payloadHash = hasLocationConstraint ? RavenAwsHelper.CalculatePayloadHashFromString(xmlString) : RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Put, url) { Headers = { { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } }, Content = hasLocationConstraint == false ? null : new StringContent(xmlString, Encoding.UTF8, "text/plain") }; var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(TimeSpan.FromHours(1)); var authorizationHeaderValue = CalculateAuthorizationHeaderValue(HttpMethods.Put, url, now, headers); client.DefaultRequestHeaders.Authorization = authorizationHeaderValue; var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); } }
public void PutBlob(string key, Stream stream, Dictionary <string, string> metadata) { AsyncHelpers.RunSync(TestConnectionAsync); if (stream.Length > MaxUploadPutBlob.GetValue(SizeUnit.Bytes)) { // for blobs over 256MB PutBlockApi(key, stream, metadata); return; } var url = GetUrl($"{_serverUrlForContainer}/{key}"); Progress?.UploadProgress.SetTotal(stream.Length); var now = SystemTime.UtcNow; // stream is disposed by the HttpClient var content = new ProgressableStreamContent(stream, Progress) { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion }, { "x-ms-blob-type", "BlockBlob" }, { "Content-Length", stream.Length.ToString(CultureInfo.InvariantCulture) } } }; foreach (var metadataKey in metadata.Keys) { content.Headers.Add("x-ms-meta-" + metadataKey.ToLower(), metadata[metadataKey]); } var client = GetClient(TimeSpan.FromHours(3)); SetAuthorizationHeader(client, HttpMethods.Put, url, content.Headers); var response = client.PutAsync(url, content, CancellationToken).Result; Progress?.UploadProgress.ChangeState(UploadState.Done); if (response.IsSuccessStatusCode) { return; } throw StorageException.FromResponseMessage(response); }
public async Task <List <string> > GetContainerNames(int maxResults) { var url = GetBaseServerUrl() + $"?comp=list&maxresults={maxResults}"; var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Get, url) { Headers = { { "x-ms-date", now.ToString("R") }, { "x-ms-version", AzureStorageVersion } } }; var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, requestMessage.Headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } var containersList = new List <string>(); using (var stream = await response.Content.ReadAsStreamAsync()) using (var reader = new StreamReader(stream)) { var xDocument = XDocument.Load(reader); foreach (var node in xDocument.Descendants("Containers")) { foreach (var containerNode in node.Descendants("Container")) { var nodeName = containerNode.Element("Name").Value; containersList.Add(nodeName); } } } return(containersList); }
private string GetBucketPermission() { var url = $"{GetUrl()}?acl"; var now = SystemTime.UtcNow; var requestMessage = new HttpRequestMessage(HttpMethods.Get, url); UpdateHeaders(requestMessage.Headers, now, null); var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, now, headers); var response = client.SendAsync(requestMessage, CancellationToken).Result; if (response.StatusCode == HttpStatusCode.NotFound) { throw new BucketNotFoundException($"Bucket name '{_bucketName}' doesn't exist!"); } if (response.IsSuccessStatusCode == false) { var storageException = StorageException.FromResponseMessage(response); if (response.StatusCode == HttpStatusCode.Forbidden) { throw new UnauthorizedAccessException(storageException.ResponseString); } throw storageException; } using (var stream = response.Content.ReadAsStreamAsync().Result) using (var reader = new StreamReader(stream)) { var xDocument = XDocument.Load(reader); var permissionElement = xDocument .Descendants() .First(x => x.Name.LocalName == "Permission"); return(permissionElement.Value); } }
public async Task DeleteBucket() { var region = await GetBucketLocation(returnWhenNotFound : true); if (region == null) { return; } using (UseSpecificRegion(region)) { var url = GetUrl(); var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Delete, url) { Headers = { { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } } }; var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Delete, url, now, headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.IsSuccessStatusCode) { return; } if (response.StatusCode == HttpStatusCode.NotFound) { return; } throw StorageException.FromResponseMessage(response); } }
private async Task <string> GetBucketPermission() { var url = $"{GetUrl()}?acl"; var now = SystemTime.UtcNow; var payloadHash = RavenAwsHelper.CalculatePayloadHash(null); var requestMessage = new HttpRequestMessage(HttpMethods.Get, url) { Headers = { { "x-amz-date", RavenAwsHelper.ConvertToString(now) }, { "x-amz-content-sha256", payloadHash } } }; var headers = ConvertToHeaders(requestMessage.Headers); var client = GetClient(); client.DefaultRequestHeaders.Authorization = CalculateAuthorizationHeaderValue(HttpMethods.Get, url, now, headers); var response = await client.SendAsync(requestMessage, CancellationToken); if (response.StatusCode == HttpStatusCode.NotFound) { throw new BucketNotFoundException($"Bucket name '{_bucketName}' doesn't exist!"); } if (response.IsSuccessStatusCode == false) { throw StorageException.FromResponseMessage(response); } using (var stream = await response.Content.ReadAsStreamAsync()) using (var reader = new StreamReader(stream)) { var xDocument = XDocument.Load(reader); var permissionElement = xDocument .Descendants() .First(x => x.Name.LocalName == "Permission"); return(permissionElement.Value); } }