public async Task <List <Bucket> > ListBucketsAsync()
{
ListAllMyBucketsResult list = await _client.ListBucketsAsync();
if (list == null)
{
throw new Exception("List buckets failed, result obj is null");
}
List <Bucket> result = new List <Bucket>();
foreach (var item in list.Buckets)
{
result.Add(new Bucket()
{
Name = item.Name,
Location = Options.Region,
CreationDate = item.CreationDate,
Owner = new Owner()
{
Id = Options.AccessKey,
Name = Options.AccessKey,
}
});
}
return(result);
}
public void TestToBody()
{
TeaModel modelNull = new TeaModel();
Assert.Empty((string)TestHelper.RunInstanceMethod(typeof(BaseClient), "_toXML", baseClient, new object[] { modelNull }));
ToBodyModel model = new ToBodyModel();
ListAllMyBucketsResult result = new ListAllMyBucketsResult();
Buckets buckets = new Buckets();
buckets.bucket = new List <Bucket>();
buckets.bucket.Add(new Bucket {
CreationDate = "2015-12-17T18:12:43.000Z", ExtranetEndpoint = "oss-cn-shanghai.aliyuncs.com", IntranetEndpoint = "oss-cn-shanghai-internal.aliyuncs.com", Location = "oss-cn-shanghai", Name = "app-base-oss", StorageClass = "Standard"
});
buckets.bucket.Add(new Bucket {
CreationDate = "2014-12-25T11:21:04.000Z", ExtranetEndpoint = "oss-cn-hangzhou.aliyuncs.com", IntranetEndpoint = "oss-cn-hangzhou-internal.aliyuncs.com", Location = "oss-cn-hangzhou", Name = "atestleo23", StorageClass = "IA"
});
buckets.bucket.Add(null);
result.buckets = buckets;
Owner owner = new Owner {
ID = 512, DisplayName = "51264"
};
result.owner = owner;
model.listAllMyBucketsResult = result;
model.listAllMyBucketsResult.testStrList = new List <string> {
"1", "2"
};
model.listAllMyBucketsResult.owners = new List <Owner>();
model.listAllMyBucketsResult.owners.Add(owner);
model.listAllMyBucketsResult.TestDouble = 1;
model.listAllMyBucketsResult.TestFloat = 2;
model.listAllMyBucketsResult.TestLong = 3;
model.listAllMyBucketsResult.TestShort = 4;
model.listAllMyBucketsResult.TestUInt = 5;
model.listAllMyBucketsResult.TestULong = 6;
model.listAllMyBucketsResult.TestUShort = 7;
model.listAllMyBucketsResult.TestBool = true;
model.listAllMyBucketsResult.TestNull = null;
model.listAllMyBucketsResult.TestListNull = null;
string xmlStr = (string)TestHelper.RunInstanceMethod(typeof(BaseClient), "_toXML", baseClient, new object[] { model });
Assert.NotNull(xmlStr);
Mock <HttpWebResponse> mockHttpWebResponse = new Mock <HttpWebResponse>();
mockHttpWebResponse.Setup(p => p.StatusCode).Returns(HttpStatusCode.OK);
mockHttpWebResponse.Setup(p => p.StatusDescription).Returns("StatusDescription");
mockHttpWebResponse.Setup(p => p.Headers).Returns(new WebHeaderCollection());
byte[] array = Encoding.UTF8.GetBytes(xmlStr);
MemoryStream stream = new MemoryStream(array);
mockHttpWebResponse.Setup(p => p.GetResponseStream()).Returns(stream);
TeaResponse teaResponse = new TeaResponse(mockHttpWebResponse.Object);
Dictionary <string, object> xmlBody = (Dictionary <string, object>)TestHelper.RunInstanceMethod(typeof(BaseClient), "_parseXml", baseClient, new object[] { xmlStr, typeof(ToBodyModel) });
ToBodyModel teaModel = TeaModel.ToObject <ToBodyModel>(xmlBody);
Assert.NotNull(teaModel);
Assert.Equal(1, teaModel.listAllMyBucketsResult.TestDouble);
}
public async Task <List <BucketInfo> > ListBucketAsync(ListBucketParam param)
{
try
{
ListAllMyBucketsResult allMyBuckets = await _minio.ListBucketsAsync();
List <BucketInfo> bucketInfos = new List <BucketInfo>();
foreach (var bucket in allMyBuckets.Buckets)
{
if (!string.IsNullOrEmpty(param.Keyword) && !bucket.Name.Contains(param.Keyword))
{
continue;
}
bucketInfos.Add(new BucketInfo()
{
BucketName = bucket.Name,
CreationDateTime = bucket.CreationDateDateTime
});
}
return(bucketInfos);
}
catch (Exception exception)
{
//SentrySdk.CaptureException(exception);
throw;
}
}
public override async Task <IEnumerable <Bucket> > Deserialize(HttpResponseMessage response)
{
ListAllMyBucketsResult model = base.ContentDeserializer.Deserialize(await response.Content.ReadAsStreamAsync());
return(from e in model.Buckets select new Bucket(e.Name)
{
Owner = new Owner(model.Owner.Id, model.Owner.DisplayName), CreationDate = e.CreationDate
});
}
internal ListBucketsResponse(HttpStatusCode statusCode, string responseContent)
: base(statusCode, responseContent)
{
if (string.IsNullOrEmpty(responseContent) ||
!HttpStatusCode.OK.Equals(statusCode))
{
return;
}
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(responseContent)))
{
this.BucketsResult = (ListAllMyBucketsResult) new XmlSerializer(typeof(ListAllMyBucketsResult)).Deserialize(stream);
}
}
public void Test_ToBody()
{
TeaModel modelNull = new TeaModel();
Assert.Empty(Client.ToXML(modelNull.ToMap()));
ToBodyModel model = new ToBodyModel();
ListAllMyBucketsResult result = new ListAllMyBucketsResult();
Buckets buckets = new Buckets();
buckets.bucket = new List <Bucket>();
buckets.bucket.Add(new Bucket {
CreationDate = "2015-12-17T18:12:43.000Z", ExtranetEndpoint = "oss-cn-shanghai.aliyuncs.com", IntranetEndpoint = "oss-cn-shanghai-internal.aliyuncs.com", Location = "oss-cn-shanghai", Name = "app-base-oss", StorageClass = "Standard"
});
buckets.bucket.Add(new Bucket {
CreationDate = "2014-12-25T11:21:04.000Z", ExtranetEndpoint = "oss-cn-hangzhou.aliyuncs.com", IntranetEndpoint = "oss-cn-hangzhou-internal.aliyuncs.com", Location = "oss-cn-hangzhou", Name = "atestleo23", StorageClass = "IA"
});
buckets.bucket.Add(null);
result.buckets = buckets;
Owner owner = new Owner {
ID = 512, DisplayName = "51264"
};
result.owner = owner;
model.listAllMyBucketsResult = result;
model.listAllMyBucketsResult.testStrList = new List <string> {
"1", "2"
};
model.listAllMyBucketsResult.owners = new List <Owner>();
model.listAllMyBucketsResult.owners.Add(owner);
model.listAllMyBucketsResult.TestDouble = 1;
model.listAllMyBucketsResult.TestFloat = 2;
model.listAllMyBucketsResult.TestLong = 3;
model.listAllMyBucketsResult.TestShort = 4;
model.listAllMyBucketsResult.TestUInt = 5;
model.listAllMyBucketsResult.TestULong = 6;
model.listAllMyBucketsResult.TestUShort = 7;
model.listAllMyBucketsResult.TestBool = true;
model.listAllMyBucketsResult.TestNull = null;
model.listAllMyBucketsResult.TestListNull = null;
string xmlStr = Client.ToXML(model.ToMap());
Assert.NotNull(xmlStr);
Dictionary <string, object> xmlBody = (Dictionary <string, object>)Client.ParseXml(xmlStr, typeof(ToBodyModel));
ToBodyModel teaModel = TeaModel.ToObject <ToBodyModel>(xmlBody);
Assert.NotNull(teaModel);
Assert.Equal(1, teaModel.listAllMyBucketsResult.TestDouble);
}
internal async Task ListBuckets(S3Context ctx)
{
string header = "[" + ctx.Http.Request.Source.IpAddress + ":" + ctx.Http.Request.Source.Port + " " + ctx.Request.RequestType.ToString() + "] ";
RequestMetadata md = ApiHelper.GetRequestMetadata(ctx);
if (md == null)
{
_Logging.Warn(header + "unable to retrieve metadata");
await ctx.Response.Send(ErrorCode.InternalError);
return;
}
if (md.Authentication != AuthenticationResult.Authenticated)
{
_Logging.Warn(header + "requestor not authenticated");
await ctx.Response.Send(ErrorCode.AccessDenied);
return;
}
else
{
md.Authorization = AuthorizationResult.PermitService;
}
List <Classes.Bucket> buckets = _Buckets.GetUserBuckets(md.User.GUID);
ListAllMyBucketsResult listBucketsResult = new ListAllMyBucketsResult();
listBucketsResult.Owner = new S3ServerInterface.S3Objects.Owner();
listBucketsResult.Owner.DisplayName = md.User.Name;
listBucketsResult.Owner.ID = md.User.Name;
listBucketsResult.Buckets = new Buckets();
listBucketsResult.Buckets.Bucket = new List <S3ServerInterface.S3Objects.Bucket>();
foreach (Classes.Bucket curr in buckets)
{
S3ServerInterface.S3Objects.Bucket b = new S3ServerInterface.S3Objects.Bucket();
b.Name = curr.Name;
b.CreationDate = curr.CreatedUtc;
listBucketsResult.Buckets.Bucket.Add(b);
}
await ApiHelper.SendSerializedResponse <ListAllMyBucketsResult>(ctx, listBucketsResult);
return;
}
/// <summary>
/// Lists all buckets owned by the user
/// </summary>
/// <returns>A list of all buckets owned by the user.</returns>
public List <Bucket> ListBuckets()
{
var request = new RestRequest("/", Method.GET);
var response = client.Execute(request);
if (HttpStatusCode.OK.Equals(response.StatusCode))
{
var contentBytes = System.Text.Encoding.UTF8.GetBytes(response.Content);
var stream = new MemoryStream(contentBytes);
ListAllMyBucketsResult bucketList = (ListAllMyBucketsResult)(new XmlSerializer(typeof(ListAllMyBucketsResult)).Deserialize(stream));
return(bucketList.Buckets);
}
throw ParseError(response);
}
/// <summary>
/// List all objects in a bucket
/// </summary>
/// <param name="cancellationToken">Optional cancellation token to cancel the operation</param>
/// <returns>Task with an iterator lazily populated with objects</returns>
public async Task <ListAllMyBucketsResult> ListBucketsAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var request = await this.CreateRequest(Method.GET, resourcePath : "/").ConfigureAwait(false);
var response = await this.ExecuteTaskAsync(this.NoErrorHandlers, request, cancellationToken).ConfigureAwait(false);
ListAllMyBucketsResult bucketList = new ListAllMyBucketsResult();
if (HttpStatusCode.OK.Equals(response.StatusCode))
{
var contentBytes = System.Text.Encoding.UTF8.GetBytes(response.Content);
using (var stream = new MemoryStream(contentBytes))
bucketList = (ListAllMyBucketsResult) new XmlSerializer(typeof(ListAllMyBucketsResult)).Deserialize(stream);
return(bucketList);
}
return(bucketList);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <ListAllMyBucketsResult> ListBuckets(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ListBuckets");
ListAllMyBucketsResult result = new ListAllMyBucketsResult();
result.Owner = new Owner("admin", "Administrator");
List <Bucket> buckets = new List <Bucket>()
{
new Bucket("default", DateTime.Now)
};
result.Buckets = new Buckets(buckets);
return(result);
}
public XmlUtilTest()
{
model = new ToBodyModel();
ListAllMyBucketsResult result = new ListAllMyBucketsResult();
Buckets buckets = new Buckets();
buckets.bucket = new List <Bucket>();
buckets.bucket.Add(new Bucket {
CreationDate = "2015-12-17T18:12:43.000Z", ExtranetEndpoint = "oss-cn-shanghai.aliyuncs.com", IntranetEndpoint = "oss-cn-shanghai-internal.aliyuncs.com", Location = "oss-cn-shanghai", Name = "app-base-oss", StorageClass = "Standard"
});
buckets.bucket.Add(new Bucket {
CreationDate = "2014-12-25T11:21:04.000Z", ExtranetEndpoint = "oss-cn-hangzhou.aliyuncs.com", IntranetEndpoint = "oss-cn-hangzhou-internal.aliyuncs.com", Location = "oss-cn-hangzhou", Name = "atestleo23", StorageClass = "IA"
});
buckets.bucket.Add(null);
result.buckets = buckets;
Owner owner = new Owner {
ID = 512, DisplayName = "51264"
};
result.owner = owner;
model.listAllMyBucketsResult = result;
model.listAllMyBucketsResult.testStrList = new List <string> {
"1", "2"
};
model.listAllMyBucketsResult.owners = new List <Owner>();
model.listAllMyBucketsResult.owners.Add(owner);
model.listAllMyBucketsResult.TestDouble = 1;
model.listAllMyBucketsResult.TestFloat = 2;
model.listAllMyBucketsResult.TestLong = 3;
model.listAllMyBucketsResult.TestShort = 4;
model.listAllMyBucketsResult.TestUInt = 5;
model.listAllMyBucketsResult.TestULong = 6;
model.listAllMyBucketsResult.TestUShort = 7;
model.listAllMyBucketsResult.TestBool = true;
model.listAllMyBucketsResult.TestNull = null;
model.listAllMyBucketsResult.TestListNull = null;
model.listAllMyBucketsResult.dict = new Dictionary <string, string> {
{ "key", "value" }
};
}
/// <summary>
/// List all objects in a bucket
/// </summary>
/// <param name="bucketName">Bucket to list objects from</param>
/// <param name="cancellationToken">Optional cancellation token to cancel the operation</param>
/// <returns>Task with an iterator lazily populated with objects</returns>
public async Task <ListAllMyBucketsResult> ListBucketsAsync(CancellationToken cancellationToken = default(CancellationToken))
{
// Set Target URL
Uri requestUrl = RequestUtil.MakeTargetURL(this.BaseUrl, this.Secure);
SetTargetURL(requestUrl);
// Initialize a new client
//PrepareClient();
var request = new RestRequest("/", Method.GET);
var response = await this.ExecuteTaskAsync(this.NoErrorHandlers, request, cancellationToken).ConfigureAwait(false);
ListAllMyBucketsResult bucketList = new ListAllMyBucketsResult();
if (HttpStatusCode.OK.Equals(response.StatusCode))
{
var contentBytes = System.Text.Encoding.UTF8.GetBytes(response.Content);
using (var stream = new MemoryStream(contentBytes))
bucketList = (ListAllMyBucketsResult)(new XmlSerializer(typeof(ListAllMyBucketsResult)).Deserialize(stream));
return(bucketList);
}
return(bucketList);
}
public void MarshalResponse(IConfig config, ListBucketsRequest request, ListBucketsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
XmlSerializer s = new XmlSerializer(typeof(ListAllMyBucketsResult));
using (XmlTextReader r = new XmlTextReader(responseStream))
{
r.Namespaces = false;
ListAllMyBucketsResult listResult = (ListAllMyBucketsResult)s.Deserialize(r);
if (listResult.Owner != null)
{
response.Owner = new S3Identity();
response.Owner.Id = listResult.Owner.Id;
response.Owner.Name = listResult.Owner.DisplayName;
}
if (listResult.Buckets != null)
{
response.Buckets = new List <S3Bucket>(listResult.Buckets.Count);
foreach (Network.Responses.XmlTypes.Bucket lb in listResult.Buckets)
{
S3Bucket b = new S3Bucket();
b.Name = lb.Name;
b.CreatedOn = lb.CreationDate;
response.Buckets.Add(b);
}
}
else
{
response.Buckets = Array.Empty <S3Bucket>();
}
}
}
private async Task RequestHandler(HttpContext ctx)
{
if (ctx == null)
{
throw new ArgumentNullException(nameof(ctx));
}
DateTime startTime = DateTime.Now;
S3Context s3ctx = null;
try
{
s3ctx = new S3Context(ctx, _BaseDomains, null, (Logging.S3Requests ? Logger : null));
s3ctx.Response.Headers.Add("x-amz-request-id", s3ctx.Request.RequestId);
s3ctx.Response.Headers.Add("x-amz-id-2", s3ctx.Request.RequestId);
}
catch (Exception e)
{
if (Logging.Exceptions)
{
Logger?.Invoke(_Header + "Exception:" + Environment.NewLine + Common.SerializeJson(e, true));
}
return;
}
bool success = false;
bool exists = false;
S3Object s3obj = null;
ObjectMetadata md = null;
AccessControlPolicy acp = null;
LegalHold legalHold = null;
Retention retention = null;
Tagging tagging = null;
ListAllMyBucketsResult buckets = null;
ListBucketResult listBucketResult = null;
ListVersionsResult listVersionResult = null;
LocationConstraint location = null;
BucketLoggingStatus bucketLogging = null;
VersioningConfiguration versionConfig = null;
WebsiteConfiguration wc = null;
DeleteMultiple delMultiple = null;
DeleteResult delResult = null;
try
{
if (Logging.HttpRequests)
{
Logger?.Invoke(_Header + "HTTP request: " + Environment.NewLine + s3ctx.Http.ToJson(true));
}
if (Logging.S3Requests)
{
Logger?.Invoke(_Header + "S3 request: " + Environment.NewLine + s3ctx.Request.ToJson(true));
}
if (PreRequestHandler != null)
{
success = await PreRequestHandler(s3ctx).ConfigureAwait(false);
if (success)
{
await s3ctx.Response.Send().ConfigureAwait(false);
return;
}
}
switch (s3ctx.Request.RequestType)
{
#region Service
case S3RequestType.ListBuckets:
if (Service.ListBuckets != null)
{
buckets = await Service.ListBuckets(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(buckets)).ConfigureAwait(false);
return;
}
break;
#endregion
#region Bucket
case S3RequestType.BucketDelete:
if (Bucket.Delete != null)
{
await Bucket.Delete(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketDeleteTags:
if (Bucket.DeleteTagging != null)
{
await Bucket.DeleteTagging(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketDeleteWebsite:
if (Bucket.DeleteWebsite != null)
{
await Bucket.DeleteWebsite(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketExists:
if (Bucket.Exists != null)
{
exists = await Bucket.Exists(s3ctx).ConfigureAwait(false);
if (exists)
{
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
}
else
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
}
return;
}
break;
case S3RequestType.BucketRead:
if (Bucket.Read != null)
{
listBucketResult = await Bucket.Read(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(listBucketResult)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadAcl:
if (Bucket.ReadAcl != null)
{
acp = await Bucket.ReadAcl(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(acp)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadLocation:
if (Bucket.ReadLocation != null)
{
location = await Bucket.ReadLocation(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(location)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadLogging:
if (Bucket.ReadLogging != null)
{
bucketLogging = await Bucket.ReadLogging(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(bucketLogging)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadTags:
if (Bucket.ReadTagging != null)
{
tagging = await Bucket.ReadTagging(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(tagging)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadVersioning:
if (Bucket.ReadVersioning != null)
{
versionConfig = await Bucket.ReadVersioning(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(versionConfig)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadVersions:
if (Bucket.ReadVersions != null)
{
listVersionResult = await Bucket.ReadVersions(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(listVersionResult)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketReadWebsite:
if (Bucket.ReadWebsite != null)
{
wc = await Bucket.ReadWebsite(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(wc)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketWrite:
if (Bucket.Write != null)
{
await Bucket.Write(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketWriteAcl:
if (Bucket.WriteAcl != null)
{
try
{
acp = Common.DeserializeXml <AccessControlPolicy>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Bucket.WriteAcl(s3ctx, acp).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketWriteLogging:
if (Bucket.WriteLogging != null)
{
try
{
bucketLogging = Common.DeserializeXml <BucketLoggingStatus>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Bucket.WriteLogging(s3ctx, bucketLogging).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketWriteTags:
if (Bucket.WriteTagging != null)
{
try
{
tagging = Common.DeserializeXml <Tagging>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Bucket.WriteTagging(s3ctx, tagging).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketWriteVersioning:
if (Bucket.WriteVersioning != null)
{
try
{
versionConfig = Common.DeserializeXml <VersioningConfiguration>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Bucket.WriteVersioning(s3ctx, versionConfig).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.BucketWriteWebsite:
if (Bucket.WriteWebsite != null)
{
try
{
wc = Common.DeserializeXml <WebsiteConfiguration>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Bucket.WriteWebsite(s3ctx, wc).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
#endregion
#region Object
case S3RequestType.ObjectDelete:
if (Object.Delete != null)
{
await Object.Delete(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectDeleteMultiple:
if (Object.DeleteMultiple != null)
{
try
{
delMultiple = Common.DeserializeXml <DeleteMultiple>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
delResult = await Object.DeleteMultiple(s3ctx, delMultiple).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(delResult)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectDeleteTags:
if (Object.DeleteTagging != null)
{
await Object.DeleteTagging(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectExists:
if (Object.Exists != null)
{
md = await Object.Exists(s3ctx).ConfigureAwait(false);
if (md != null)
{
if (!String.IsNullOrEmpty(md.ETag))
{
ctx.Response.Headers.Add("ETag", md.ETag);
}
ctx.Response.Headers.Add("Last-Modified", md.LastModified.ToString());
ctx.Response.Headers.Add("x-amz-storage-class", md.StorageClass);
ctx.Response.StatusCode = 200;
ctx.Response.ContentLength = md.Size;
ctx.Response.ContentType = md.ContentType;
await ctx.Response.Send(md.Size).ConfigureAwait(false);
}
else
{
ctx.Response.StatusCode = 404;
await ctx.Response.Send().ConfigureAwait(false);
}
return;
}
break;
case S3RequestType.ObjectRead:
if (Object.Read != null)
{
s3obj = await Object.Read(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = s3obj.ContentType;
ctx.Response.ContentLength = s3obj.Size;
await ctx.Response.Send(s3obj.Size, s3obj.Data).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectReadAcl:
if (Object.ReadAcl != null)
{
acp = await Object.ReadAcl(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(acp)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectReadLegalHold:
if (Object.ReadLegalHold != null)
{
legalHold = await Object.ReadLegalHold(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(legalHold)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectReadRange:
if (Object.ReadRange != null)
{
s3obj = await Object.ReadRange(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = s3obj.ContentType;
ctx.Response.ContentLength = s3obj.Size;
await ctx.Response.Send(s3obj.Size, s3obj.Data).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectReadRetention:
if (Object.ReadRetention != null)
{
retention = await Object.ReadRetention(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(retention)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectReadTags:
if (Object.ReadTagging != null)
{
tagging = await Object.ReadTagging(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/xml";
await ctx.Response.Send(Common.SerializeXml(tagging)).ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectWrite:
if (Object.Write != null)
{
await Object.Write(s3ctx).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectWriteAcl:
if (Object.WriteAcl != null)
{
try
{
acp = Common.DeserializeXml <AccessControlPolicy>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Object.WriteAcl(s3ctx, acp).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectWriteLegalHold:
if (Object.WriteLegalHold != null)
{
try
{
legalHold = Common.DeserializeXml <LegalHold>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Object.WriteLegalHold(s3ctx, legalHold).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectWriteRetention:
if (Object.WriteRetention != null)
{
try
{
retention = Common.DeserializeXml <Retention>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Object.WriteRetention(s3ctx, retention).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
case S3RequestType.ObjectWriteTags:
if (Object.WriteTagging != null)
{
try
{
tagging = Common.DeserializeXml <Tagging>(s3ctx.Request.DataAsString);
}
catch (InvalidOperationException ioe)
{
ioe.Data.Add("Context", s3ctx);
ioe.Data.Add("RequestBody", s3ctx.Request.DataAsString);
Logger?.Invoke(_Header + "XML exception: " + Environment.NewLine + Common.SerializeJson(ioe, true));
await s3ctx.Response.Send(S3Objects.ErrorCode.MalformedXML).ConfigureAwait(false);
return;
}
await Object.WriteTagging(s3ctx, tagging).ConfigureAwait(false);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send().ConfigureAwait(false);
return;
}
break;
#endregion
}
if (DefaultRequestHandler != null)
{
await DefaultRequestHandler(s3ctx).ConfigureAwait(false);
return;
}
await s3ctx.Response.Send(S3Objects.ErrorCode.InvalidRequest).ConfigureAwait(false);
return;
}
catch (S3Exception s3e)
{
if (Logging.Exceptions)
{
Logger?.Invoke(_Header + "S3 exception:" + Environment.NewLine + Common.SerializeJson(s3e, true));
}
await s3ctx.Response.Send(s3e.Error).ConfigureAwait(false);
return;
}
catch (Exception e)
{
if (Logging.Exceptions)
{
Logger?.Invoke(_Header + "exception:" + Environment.NewLine + Common.SerializeJson(e, true));
}
await s3ctx.Response.Send(S3Objects.ErrorCode.InternalError).ConfigureAwait(false);
return;
}
finally
{
if (Logging.HttpRequests)
{
Logger?.Invoke(
_Header +
"[" +
ctx.Request.Source.IpAddress + ":" +
ctx.Request.Source.Port +
"] " +
ctx.Request.Method.ToString() + " " +
ctx.Request.Url.RawWithoutQuery + " " +
s3ctx.Response.StatusCode +
" [" + Common.TotalMsFrom(startTime) + "ms]");
}
if (PostRequestHandler != null)
{
await PostRequestHandler(s3ctx).ConfigureAwait(false);
}
}
}
