public PutBucketVersioningRequest(string bucket)
: base(bucket)
{
this.method = CosRequestMethod.PUT;
this.queryParameters.Add("versioning", null);
versioningConfiguration = new VersioningConfiguration();
}
// Check if Versioning is Enabled on a bucket
public async static Task Run(MinioClient minio,
string bucketName = "my-bucket-name")
{
var args = new GetVersioningArgs()
.WithBucket(bucketName);
try
{
Console.WriteLine("Running example for API: GetVersioning, ");
VersioningConfiguration config = await minio.GetVersioningAsync(args);
if (config == null)
{
Console.WriteLine("Versioning Configuration not available for bucket " + bucketName);
Console.WriteLine();
return;
}
Console.WriteLine("Versioning Configuration Status " + config.Status + " for bucket " + bucketName);
Console.WriteLine();
}
catch (Exception e)
{
Console.WriteLine($"[Bucket] Exception: {e}");
}
}
public void ConfigureServices(IServiceCollection services)
{
VersioningConfiguration.AddConfiguration(services, 1, 0);
DependencyInjectionConfiguration.RegisterServices(services);
ApiConfiguration.AddConfiguration(services);
SwaggerConfiguration.AddConfiguration(services);
}
public void ConfigureServices(IServiceCollection services)
{
VersioningConfiguration.AddConfiguration(services, 1, 0);
SwaggerConfiguration.AddConfiguration(services);
IdentityConfiguration.AddConfiguration(services, Configuration.GetConnectionString("IdentityConnection"));
ApiConfiguration.AddConfiguration(services);
DependencyInjectionConfiguration.RegisterServices(services);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <VersioningConfiguration> BucketReadVersioning(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("BucketReadVersioning: " + ctx.Request.Bucket);
VersioningConfiguration vc = new VersioningConfiguration("Enabled", "Enabled");
return(vc);
}
private void RemoveOldRevisions(string name, long revision, VersioningConfiguration versioningConfiguration)
{
var latestValidRevision = revision - versioningConfiguration.MaxRevisions;
if (latestValidRevision <= 0)
{
return;
}
FileSystem.StorageOperationsTask.IndicateFileToDelete(string.Format("{0}/revisions/{1}", name, latestValidRevision));
}
private void RemoveOldRevisions(string key, int revision, VersioningConfiguration versioningConfiguration, TransactionInformation transactionInformation)
{
int latestValidRevision = revision - versioningConfiguration.MaxRevisions;
if (latestValidRevision <= 0)
{
return;
}
Database.Delete(string.Format("{0}/revisions/{1}", key, latestValidRevision), null, transactionInformation);
}
private void RemoveOldRevisions(string key, long revision, VersioningConfiguration versioningConfiguration)
{
long latestValidRevision = revision - versioningConfiguration.MaxRevisions;
if (latestValidRevision <= 0)
{
return;
}
Database.Documents.Delete(string.Format("{0}/revisions/{1}", key, latestValidRevision), null);
}
private void RemoveOldRevisions(string key, int revision, VersioningConfiguration versioningConfiguration, TransactionInformation transactionInformation)
{
int latestValidRevision = revision - versioningConfiguration.MaxRevisions;
if (latestValidRevision <= 1)
{
return;
}
Database.Delete(key + "/revisions/" + (latestValidRevision - 1), null, transactionInformation);
}
internal override HttpRequestMessageBuilder BuildRequest(HttpRequestMessageBuilder requestMessageBuilder)
{
VersioningConfiguration config = new VersioningConfiguration((this.CurrentVersioningStatus == VersioningStatus.Enabled));
string body = utils.MarshalXML(config, "http://s3.amazonaws.com/doc/2006-03-01/");
requestMessageBuilder.AddXmlBody(body);
requestMessageBuilder.AddOrUpdateHeaderParameter("Content-Md5",
utils.getMD5SumStr(Encoding.UTF8.GetBytes(body)));
requestMessageBuilder.AddQueryParameter("versioning", "");
return(requestMessageBuilder);
}
public override RestRequest BuildRequest(RestRequest req)
{
VersioningConfiguration config = new VersioningConfiguration((this.CurrentVersioningStatus == VersioningStatus.Enabled));
req.XmlSerializer = new RestSharp.Serializers.DotNetXmlSerializer();
req.XmlSerializer.Namespace = "http://s3.amazonaws.com/doc/2006-03-01/";
req.XmlSerializer.ContentType = "application/xml";
string body = utils.MarshalXML(config, req.XmlSerializer.Namespace);
req.AddQueryParameter("versioning", "");
req.AddParameter("text/xml", body, ParameterType.RequestBody);
return(req);
}
internal GetVersioningResponse(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.VersioningConfig = (VersioningConfiguration) new XmlSerializer(typeof(VersioningConfiguration)).Deserialize(stream);
}
}
private VersioningConfiguration GetDocumentVersioningConfiguration(RavenJObject metadata)
{
var versioningConfiguration = new VersioningConfiguration
{
MaxRevisions = Int32.MaxValue,
Exclude = false
};
var entityName = metadata.Value <string>("Raven-Entity-Name");
if (entityName != null)
{
var doc = Database.Get("Raven/Versioning/" + entityName, null) ??
Database.Get("Raven/Versioning/DefaultConfiguration", null);
if (doc != null)
{
versioningConfiguration = doc.DataAsJson.JsonDeserialization <VersioningConfiguration>();
}
}
return(versioningConfiguration);
}
public void getBucketVersioning()
{
//.cssg-snippet-body-start:[get-bucket-versioning]
CosXmlConfig config = new CosXmlConfig.Builder()
.SetConnectionTimeoutMs(60000) //设置连接超时时间，单位毫秒，默认45000ms
.SetReadWriteTimeoutMs(40000) //设置读写超时时间，单位毫秒，默认45000ms
.IsHttps(true) //设置默认 HTTPS 请求
.SetAppid("1253653367") //设置腾讯云账户的账户标识 APPID
.SetRegion("ap-guangzhou") //设置一个默认的存储桶地域
.Build();
string secretId = Environment.GetEnvironmentVariable("COS_KEY"); //云 API 密钥 SecretId
string secretKey = Environment.GetEnvironmentVariable("COS_SECRET"); //云 API 密钥 SecretKey
long durationSecond = 600; //每次请求签名有效时长，单位为秒
QCloudCredentialProvider qCloudCredentialProvider = new DefaultQCloudCredentialProvider(secretId,
secretKey, durationSecond);
CosXml cosXml = new CosXmlServer(config, qCloudCredentialProvider);
string bucket = "bucket-cssg-test-dotnet-1253653367"; //格式：BucketName-APPID
GetBucketVersioningRequest request = new GetBucketVersioningRequest(bucket);
// 使用同步方法
try
{
GetBucketVersioningResult result = cosXml.GetBucketVersioning(request);
// 存储桶的生命周期配置
VersioningConfiguration conf = result.versioningConfiguration;
}
catch (COSXML.CosException.CosClientException clientEx)
{
Console.WriteLine("CosClientException: " + clientEx);
Assert.Null(clientEx);
}
catch (COSXML.CosException.CosServerException serverEx)
{
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
Assert.Null(serverEx);
}
//.cssg-snippet-body-end
}
private bool TryGetVersioningConfiguration(string key, RavenJObject metadata,
out VersioningConfiguration versioningConfiguration)
{
versioningConfiguration = null;
if (key.StartsWith("Raven/", StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
if (metadata.Value <string>(VersioningUtil.RavenDocumentRevisionStatus) == "Historical")
{
return(false);
}
versioningConfiguration = Database.GetDocumentVersioningConfiguration(metadata);
if (versioningConfiguration == null || versioningConfiguration.Exclude)
{
return(false);
}
return(true);
}
private bool TryGetVersioningConfiguration(string key, RavenJObject metadata,
out VersioningConfiguration versioningConfiguration)
{
versioningConfiguration = null;
if (key.StartsWith("Raven/", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (metadata.Value <string>(VersioningUtil.RavenDocumentRevisionStatus) == "Historical")
{
return(false);
}
versioningConfiguration = Database.GetDocumentVersioningConfiguration(metadata);
if (versioningConfiguration == null || versioningConfiguration.Exclude ||
(versioningConfiguration.ExcludeUnlessExplicit && !metadata.__ExternalState.ContainsKey(Constants.RavenCreateVersion)))
{
return(false);
}
return(true);
}
/// 获取存储桶多版本状态
public void GetBucketVersioning()
{
//.cssg-snippet-body-start:[get-bucket-versioning]
string bucket = "examplebucket-1250000000"; //格式：BucketName-APPID
GetBucketVersioningRequest request = new GetBucketVersioningRequest(bucket);
try
{
GetBucketVersioningResult result = cosXml.GetBucketVersioning(request);
// 存储桶的生命周期配置
VersioningConfiguration conf = result.versioningConfiguration;
}
catch (COSXML.CosException.CosClientException clientEx)
{
Console.WriteLine("CosClientException: " + clientEx);
}
catch (COSXML.CosException.CosServerException serverEx)
{
Console.WriteLine("CosServerException: " + serverEx.GetInfo());
}
//.cssg-snippet-body-end
}
public static string BuildVersioningConfiguration(VersioningConfiguration versioningConfiguration)
{
StringWriter stringWriter = new StringWriter();
XmlWriterSettings xmlWriterSetting = new XmlWriterSettings();
xmlWriterSetting.Indent = true;
XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSetting);
xmlWriter.WriteStartDocument();
//start to write element
xmlWriter.WriteStartElement("VersioningConfiguration");
xmlWriter.WriteElementString("Status", versioningConfiguration.status);
// end to element
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
return(RemoveXMLHeader(stringWriter.ToString()));
}
private static void SetBucketVersioning()
{
try
{
VersioningConfiguration versionConfig = new VersioningConfiguration()
{
Status = VersionStatusEnum.Enabled
};
SetBucketVersioningRequest request = new SetBucketVersioningRequest()
{
BucketName = bucketName,
Configuration = versionConfig
};
SetBucketVersioningResponse response = client.SetBucketVersioning(request);
Console.WriteLine("PutBucketVersioning response: {0}", response.StatusCode);
}
catch (ObsException ex)
{
Console.WriteLine(string.Format("Exception errorcode: {0}, when set bucket versioning.", ex.ErrorCode));
Console.WriteLine("Exception errormessage: {0}", ex.ErrorMessage);
}
}
protected bool Equals(VersioningConfiguration other)
{
return(string.Equals(Id, other.Id) && MaxRevisions == other.MaxRevisions && Exclude.Equals(other.Exclude));
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task BucketWriteVersioning(S3Context ctx, VersioningConfiguration ver)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("BucketWriteVersioning: " + ctx.Request.Bucket);
Console.WriteLine(ctx.Request.DataAsString + Environment.NewLine);
}
protected bool Equals(VersioningConfiguration other)
{
return string.Equals(Id, other.Id) && MaxRevisions == other.MaxRevisions && Exclude.Equals(other.Exclude);
}
private static bool TryGetVersioningConfiguration(string name, RavenJObject metadata, IStorageActionsAccessor accessor, out VersioningConfiguration versioningConfiguration)
{
versioningConfiguration = null;
if (name.StartsWith("Raven/", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (metadata.Value <string>(VersioningUtil.RavenFileRevisionStatus) == "Historical")
{
return(false);
}
versioningConfiguration = accessor.GetVersioningConfiguration();
if (versioningConfiguration == null || versioningConfiguration.Exclude ||
(versioningConfiguration.ExcludeUnlessExplicit && !metadata.__ExternalState.ContainsKey(Constants.RavenCreateVersion)))
{
return(false);
}
return(true);
}
internal override void ParseResponseBody(System.IO.Stream inputStream, string contentType, long contentLength)
{
versioningConfiguration = new VersioningConfiguration();
XmlParse.ParseVersioningConfiguration(inputStream, versioningConfiguration);
}
public VersioningConfiguration(VersioningConfiguration vc)
{
Status = vc.Status;
MfaDelete = vc.MfaDelete;
}
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);
}
}
}
