public void SetObject(HeadObjectResponse headObject, string objName, string regionName)
{
List <ListViewItem> items = new List <ListViewItem>()
{
new ListViewItem(new string[] { "Name", objName }),
new ListViewItem(new string[] { "Region", regionName }),
new ListViewItem(new string[] { "URL", headObject.FileURL }),
new ListViewItem(new string[] { "ContentLength", (headObject.ContentLength ?? 0) + "" }),
new ListViewItem(new string[] { "ArchivalState", headObject.ArchivalState }),
new ListViewItem(new string[] { "CacheControl", headObject.CacheControl }),
new ListViewItem(new string[] { "ContentDisposition", headObject.ContentDisposition }),
new ListViewItem(new string[] { "ContentEncoding", headObject.ContentEncoding }),
new ListViewItem(new string[] { "ContentLanguage", headObject.ContentLanguage }),
new ListViewItem(new string[] { "ContentMd5", headObject.ContentMd5 }),
new ListViewItem(new string[] { "ContentType", headObject.ContentType }),
new ListViewItem(new string[] { "ETag", headObject.ETag }),
new ListViewItem(new string[] { "LastModified", headObject.LastModified }),
new ListViewItem(new string[] { "OpcClientRequestId", headObject.OpcClientRequestId }),
new ListViewItem(new string[] { "OpcMultipartMd5", headObject.OpcMultipartMd5 }),
new ListViewItem(new string[] { "OpcRequestId", headObject.OpcRequestId }),
new ListViewItem(new string[] { "TimeOfArchival", headObject.TimeOfArchival })
};
ObjectPropartiesView.Items.AddRange(items.ToArray());
}
public async Task FullPreSignTest()
{
int expireIn = 100;
string url = SignedObjectClient.SignPutObject(BucketName, "test.zip", null, TimeSpan.FromSeconds(expireIn));
using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes("hello world")))
{
PutObjectResponse?putResp = await SignedObjectClient.PutObjectAsync(url, ms).ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
}
url = SignedObjectClient.SignGetObject(BucketName, "test.zip", TimeSpan.FromSeconds(expireIn));
GetObjectResponse?getResp = await SignedObjectClient.GetObjectAsync(url).ConfigureAwait(false);
Assert.Equal(200, getResp.StatusCode);
url = SignedObjectClient.SignDeleteObject(BucketName, "test.zip", TimeSpan.FromSeconds(expireIn));
DeleteObjectResponse deleteResp = await SignedObjectClient.DeleteObjectAsync(url).ConfigureAwait(false);
Assert.Equal(204, deleteResp.StatusCode);
url = SignedObjectClient.SignHeadObject(BucketName, "test.zip", TimeSpan.FromSeconds(expireIn));
HeadObjectResponse headResp = await SignedObjectClient.HeadObjectAsync(url).ConfigureAwait(false);
Assert.Equal(404, headResp.StatusCode);
}
public async Task HeadObject()
{
await UploadAsync(nameof(HeadObject)).ConfigureAwait(false);
HeadObjectResponse gResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(HeadObject)).ConfigureAwait(false);
Assert.Equal(200, gResp.StatusCode);
}
public async Task HeadObjectContentRange(S3Provider _, string bucket, ISimpleClient client)
{
await client.PutObjectStringAsync(bucket, nameof(HeadObjectContentRange), "test").ConfigureAwait(false);
HeadObjectResponse headResp = await client.HeadObjectAsync(bucket, nameof(HeadObjectContentRange), r => r.Range.Add(0, 2)).ConfigureAwait(false);
Assert.Equal("bytes", headResp.AcceptRanges);
Assert.Equal("bytes 0-2/4", headResp.ContentRange);
}
public async Task HeadObjectWebsiteRedirect()
{
await UploadAsync(nameof(HeadObjectWebsiteRedirect), request => request.WebsiteRedirectLocation = "https://google.com").ConfigureAwait(false);
HeadObjectResponse resp1 = await ObjectClient.HeadObjectAsync(BucketName, nameof(HeadObjectWebsiteRedirect)).ConfigureAwait(false);
Assert.Equal("https://google.com", resp1.WebsiteRedirectLocation);
Assert.Equal(200, resp1.StatusCode);
}
public async Task HeadObjectContentRange()
{
await UploadAsync(nameof(HeadObjectContentRange)).ConfigureAwait(false);
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(HeadObjectContentRange), req => req.Range.Add(0, 2)).ConfigureAwait(false);
Assert.Equal("bytes", headResp.AcceptRanges);
Assert.Equal("bytes 0-2/4", headResp.ContentRange);
}
public async Task HeadObject(S3Provider _, string bucket, ISimpleClient client)
{
PutObjectResponse putResp = await client.PutObjectAsync(bucket, nameof(HeadObject), null).ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
HeadObjectResponse headResp = await client.HeadObjectAsync(bucket, nameof(HeadObject)).ConfigureAwait(false);
Assert.Equal(200, headResp.StatusCode);
}
public async IAsyncEnumerable <GetObjectResponse> MultipartDownloadAsync(string bucketName, string objectKey, Stream output, int bufferSize = 16777216, int numParallelParts = 4, Action <GetObjectRequest>?config = null, [EnumeratorCancellation] CancellationToken token = default)
{
Validator.RequireNotNull(output, nameof(output));
//Use a HEAD request on the object key to determine if the file was originally uploaded with multipart
HeadObjectResponse headResp = await _objectClient.HeadObjectAsync(bucketName, objectKey, req => req.PartNumber = 1, token).ConfigureAwait(false);
Queue <Task <GetObjectResponse> > queue = new Queue <Task <GetObjectResponse> >();
if (headResp.NumberOfParts == null)
{
GetObjectResponse getResp = await _objectClient.GetObjectAsync(bucketName, objectKey, config, token).ConfigureAwait(false);
if (!getResp.IsSuccess)
{
throw new S3RequestException(getResp);
}
await getResp.Content.CopyToAsync(output, 81920, token).ConfigureAwait(false);
yield return(getResp);
}
else
{
int parts = headResp.NumberOfParts.Value;
using (SemaphoreSlim semaphore = new SemaphoreSlim(numParallelParts))
using (Mutex mutex = new Mutex())
{
for (int i = 1; i <= parts; i++)
{
await semaphore.WaitAsync(token).ConfigureAwait(false);
if (token.IsCancellationRequested)
{
yield break;
}
queue.Enqueue(DownloadPartAsync(bucketName, objectKey, output, headResp.ContentLength, i, bufferSize, semaphore, mutex, config, token));
}
while (queue.TryDequeue(out Task <GetObjectResponse>?task))
{
if (token.IsCancellationRequested)
{
yield break;
}
GetObjectResponse response = await task !.ConfigureAwait(false);
yield return(response);
}
}
}
}
public async Task HeadObjectWebsiteRedirect(S3Provider _, string bucket, ISimpleClient client)
{
PutObjectResponse putResp = await client.PutObjectAsync(bucket, nameof(HeadObjectWebsiteRedirect), null, r => r.WebsiteRedirectLocation = "https://google.com").ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
HeadObjectResponse headResp = await client.HeadObjectAsync(bucket, nameof(HeadObjectWebsiteRedirect)).ConfigureAwait(false);
Assert.Equal(200, headResp.StatusCode);
Assert.Equal("https://google.com", headResp.WebsiteRedirectLocation);
}
public async Task HeadObjectMultipleTags(S3Provider _, string bucket, ISimpleClient client)
{
await client.PutObjectAsync(bucket, nameof(HeadObjectMultipleTags), null, r =>
{
r.Tags.Add("mykey1", "myvalue1");
r.Tags.Add("mykey2", "myvalue2");
}).ConfigureAwait(false);
HeadObjectResponse resp = await client.HeadObjectAsync(bucket, nameof(HeadObjectMultipleTags)).ConfigureAwait(false);
Assert.Equal(2, resp.TagCount);
}
public async Task HeadObjectLifecycle(S3Provider _, string bucket, ISimpleClient client)
{
PutObjectResponse putResp = await client.PutObjectAsync(bucket, nameof(HeadObjectLifecycle), null).ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
HeadObjectResponse headResp = await client.HeadObjectAsync(bucket, nameof(HeadObjectLifecycle)).ConfigureAwait(false);
//Expiration should work on head too
Assert.Equal(DateTime.UtcNow.AddDays(2).Date, headResp.LifeCycleExpiresOn !.Value.UtcDateTime.Date);
Assert.Equal("ExpireAll", headResp.LifeCycleRuleId);
}
public async Task PutObjectLegalHold()
{
await UploadAsync(nameof(PutObjectLegalHold), req => req.LockLegalHold = true).ConfigureAwait(false);
GetObjectResponse getResp = await AssertAsync(nameof(PutObjectLegalHold)).ConfigureAwait(false);
Assert.True(getResp.LockLegalHold);
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(PutObjectLegalHold)).ConfigureAwait(false);
Assert.True(headResp.LockLegalHold);
}
public async Task HeadObjectMultipleTags()
{
await UploadAsync(nameof(HeadObjectMultipleTags), request =>
{
request.Tags.Add("mykey1", "myvalue1");
request.Tags.Add("mykey2", "myvalue2");
}).ConfigureAwait(false);
HeadObjectResponse gResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(HeadObjectMultipleTags)).ConfigureAwait(false);
Assert.Equal(2, gResp.TagCount);
}
public async Task HeadObjectLifecycle()
{
PutObjectResponse putResp = await UploadAsync(nameof(HeadObjectLifecycle)).ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(HeadObjectLifecycle)).ConfigureAwait(false);
//Expiration should work on head too
Assert.Equal(DateTime.UtcNow.AddDays(2).Date, headResp.LifeCycleExpiresOn !.Value.UtcDateTime.Date);
Assert.Equal("ExpireAll", headResp.LifeCycleRuleId);
}
public async Task HeadObjectResponseHeaders()
{
//Upload a file for tests
await UploadAsync(nameof(HeadObjectResponseHeaders)).ConfigureAwait(false);
HeadObjectResponse response = await ObjectClient.HeadObjectAsync(BucketName, nameof(HeadObjectResponseHeaders), request =>
{
request.ResponseCacheControl.Set(CacheControlType.MaxAge, 42);
request.ResponseContentDisposition.Set(ContentDispositionType.Attachment, "filename.txt");
request.ResponseContentEncoding.Add(ContentEncodingType.Gzip);
request.ResponseContentLanguage.Add("da-DK");
request.ResponseContentType.Set("text/html", "utf-8");
request.ResponseExpires = DateTimeOffset.UtcNow;
}).ConfigureAwait(false);
Assert.Equal("max-age=42", response.CacheControl);
Assert.Equal("attachment; filename=\"filename.txt\"", response.ContentDisposition);
Assert.Equal("da-DK", response.ContentLanguage);
Assert.Equal("text/html; charset=utf-8", response.ContentType);
Assert.Equal(DateTime.UtcNow, response.ExpiresOn !.Value.DateTime, TimeSpan.FromSeconds(5));
}
public async Task MultipartViaClient()
{
byte[] data = new byte[10 * 1024 * 1024]; //10 Mb
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 255);
}
using (MemoryStream ms = new MemoryStream(data))
{
MultipartUploadStatus resp = await MultipartClient.MultipartUploadAsync(BucketName, nameof(MultipartViaClient), ms, 5 * 1024 * 1024).ConfigureAwait(false);
Assert.Equal(MultipartUploadStatus.Ok, resp);
}
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, nameof(MultipartViaClient)).ConfigureAwait(false);
Assert.True(getResp.IsSuccess);
using (MemoryStream ms = new MemoryStream())
{
await getResp.Content.CopyToAsync(ms).ConfigureAwait(false);
Assert.Equal(data, ms.ToArray());
}
//Try multipart downloading it
using (MemoryStream ms = new MemoryStream())
{
await MultipartClient.MultipartDownloadAsync(BucketName, nameof(MultipartViaClient), ms).ConfigureAwait(false);
Assert.Equal(data, ms.ToArray());
}
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(MultipartViaClient), req => req.PartNumber = 1).ConfigureAwait(false);
Assert.Equal(2, headResp.NumberOfParts);
}
public async Task MultipartFluid()
{
byte[] data = new byte[10 * 1024 * 1024]; //10 Mb
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 255);
}
MultipartUploadStatus resp = await Transfer.UploadData(BucketName, nameof(MultipartFluid), data)
.ExecuteMultipartAsync()
.ConfigureAwait(false);
Assert.Equal(MultipartUploadStatus.Ok, resp);
GetObjectResponse getResp = await ObjectClient.GetObjectAsync(BucketName, nameof(MultipartViaClient)).ConfigureAwait(false);
Assert.True(getResp.IsSuccess);
using (MemoryStream ms = new MemoryStream())
{
await getResp.Content.CopyToAsync(ms).ConfigureAwait(false);
Assert.Equal(data, ms.ToArray());
}
//TODO: Need Download Transfer support first
//Try multipart downloading it
//using (MemoryStream ms = new MemoryStream())
//{
// await ObjectClient.MultipartDownloadAsync(BucketName, nameof(MultipartViaClient), ms).ConfigureAwait(false);
// Assert.Equal(data, ms.ToArray());
//}
HeadObjectResponse headResp = await ObjectClient.HeadObjectAsync(BucketName, nameof(MultipartViaClient), req => req.PartNumber = 1).ConfigureAwait(false);
Assert.Equal(2, headResp.NumberOfParts);
}
public async Task HeadObjectResponseHeaders(S3Provider _, string bucket, ISimpleClient client)
{
//Upload a file for tests
PutObjectResponse putResp = await client.PutObjectAsync(bucket, nameof(HeadObjectResponseHeaders), null).ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
HeadObjectResponse resp = await client.HeadObjectAsync(bucket, nameof(HeadObjectResponseHeaders), r =>
{
r.ResponseCacheControl.Set(CacheControlType.MaxAge, 42);
r.ResponseContentDisposition.Set(ContentDispositionType.Attachment, "filename.txt");
r.ResponseContentEncoding.Add(ContentEncodingType.Gzip);
r.ResponseContentLanguage.Add("da-DK");
r.ResponseContentType.Set("text/html", "utf-8");
r.ResponseExpires = DateTimeOffset.UtcNow;
}).ConfigureAwait(false);
Assert.Equal("max-age=42", resp.CacheControl);
Assert.Equal("attachment; filename=\"filename.txt\"", resp.ContentDisposition);
Assert.Equal("da-DK", resp.ContentLanguage);
Assert.Equal("text/html; charset=utf-8", resp.ContentType);
Assert.Equal(DateTime.UtcNow, resp.ExpiresOn !.Value.DateTime, TimeSpan.FromSeconds(5));
}
private void UploadFiles(List <ListViewItem> targets, bool isForce)
{
ParallelOptions po = new ParallelOptions();
CancellationTokenSource = new CancellationTokenSource();
po.CancellationToken = CancellationTokenSource.Token;
po.MaxDegreeOfParallelism = System.Environment.ProcessorCount;
try
{
Parallel.ForEach(targets, po, item =>
{
var paths = item.Text.Split('\\');
var filename = paths[paths.Length - 1];
DialogResult resulet = DialogResult.Yes;
HeadObjectResponse head = null;
if (!isForce)
{
try
{
head = OciResources.GetObjectHead(NamespaceName, BucketName, TargetPath + filename, RegionName);
}
catch (WebException we)
{
if (we.Status.Equals(WebExceptionStatus.ProtocolError) && ((HttpWebResponse)we.Response).StatusCode == HttpStatusCode.NotFound)
{
head = null;
}
else
{
throw;
}
}
if (head != null)
{
resulet = DialogManagement.ShowMessageDialog("確認", "オブジェクト [" + TargetPath + filename + "] を上書きしますか？", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);
}
}
if (resulet == DialogResult.Yes)
{
if (!OciResources.PutObject(NamespaceName, BucketName, TargetPath + filename, RegionName, item.Text))
{
DialogManagement.ShowMessageDialog("エラー", "ファイル [" + item.Text + "] のアップロードに失敗しました", MessageBoxButtons.OK, MessageBoxIcon.Error);
FileListView.Invoke((MethodInvoker) delegate {
item.SubItems[1].Text = "Failed";
});
}
else
{
FileListView.Invoke((MethodInvoker) delegate {
item.SubItems[1].Text = "Successed";
});
}
ProgressBar.Invoke((MethodInvoker) delegate {
ProgressBar.Value++;
});
}
});
}
catch (OperationCanceledException oce)
{
DialogManagement.ShowMessageDialog("警告", "アップロードはキャンセルされました。\nMessage:" + oce.Message, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
finally
{
CancellationTokenSource.Dispose();
ProgressBar.Invoke((MethodInvoker) delegate {
ProgressBar.Value = 0;
});
UploadMode(false);
DialogManagement.ShowMessageDialog("完了", "アップロードが完了しました", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
