#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <LocationConstraint> BucketReadLocation(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("BucketReadLocation: " + ctx.Request.Bucket);
return(new LocationConstraint(_Location));
}
private async Task DeleteCredentials(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length != 3)
{
await ctx.Response.Send(S3ServerInterface.S3Objects.ErrorCode.InvalidRequest);
return;
}
Credential cred = _Config.GetCredentialByAccessKey(ctx.Http.Request.Url.Elements[2]);
if (cred == null)
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
_Config.DeleteCredential(cred.GUID);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
private static async Task PostRequestHandler(S3Context ctx)
{
string header = "[" + ctx.Http.Request.Source.IpAddress + ":" + ctx.Http.Request.Source.Port + " " + ctx.Http.Request.Method.ToString() + " " + ctx.Http.Request.Url.RawWithoutQuery + "] ";
_Logging.Debug(header + ctx.Http.Response.StatusCode);
// _Logging.Debug(header + ctx.Http.Response.StatusCode + Environment.NewLine + Common.SerializeJson(ctx.Response, true) + Environment.NewLine + ctx.Response.DataAsString);
}
private async Task GetCredentials(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length >= 3)
{
Credential cred = _Config.GetCredentialByAccessKey(ctx.Http.Request.Url.Elements[2]);
if (cred == null)
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
else
{
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(cred, true));
return;
}
}
else
{
List <Credential> creds = _Config.GetCredentials();
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(creds, true));
return;
}
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task ObjectWrite(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectWrite : " + ctx.Request.Bucket + "/" + ctx.Request.Key);
Console.WriteLine("Chunked transfer : " + ctx.Request.Chunked);
if (ctx.Request.Chunked)
{
while (true)
{
Chunk chunk = ctx.Request.ReadChunk().Result;
Console.WriteLine(Common.SerializeJson(chunk, true));
Console.Write(chunk.Length + ": ");
if (chunk.Length > 0)
{
Console.WriteLine(chunk.Length + "/" + chunk.IsFinalChunk + ": " + Encoding.UTF8.GetString(chunk.Data));
}
if (chunk.IsFinalChunk)
{
Console.WriteLine("Final chunk encountered");
break;
}
}
}
else
{
Console.WriteLine(ctx.Request.ContentLength + ": " + ctx.Request.DataAsString);
}
}
internal bool Authenticate(
S3Context ctx,
out User user,
out Credential cred)
{
user = null;
cred = null;
if (ctx == null)
{
throw new ArgumentNullException(nameof(ctx));
}
if (String.IsNullOrEmpty(ctx.Request.AccessKey))
{
return(false);
}
user = _Config.GetUserByAccessKey(ctx.Request.AccessKey);
if (user == null)
{
return(false);
}
cred = _Config.GetCredentialByAccessKey(ctx.Request.AccessKey);
if (cred == null)
{
return(false);
}
return(true);
}
private async Task DeleteBuckets(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length != 3)
{
await ctx.Response.Send(S3ServerInterface.S3Objects.ErrorCode.InvalidRequest);
return;
}
Bucket bucket = _Config.GetBucketByName(ctx.Http.Request.Url.Elements[2]);
if (bucket == null)
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
bool destroy = false;
if (ctx.Http.Request.Query.Elements.ContainsKey("destroy"))
{
destroy = true;
}
_Buckets.Remove(bucket, destroy);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <S3Object> ObjectRead(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectRead: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
return(_S3Object);
}
private async Task DeleteUsers(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length != 3)
{
await ctx.Response.Send(S3ServerInterface.S3Objects.ErrorCode.InvalidRequest);
return;
}
User user = _Config.GetUserByGuid(ctx.Http.Request.Url.Elements[2]);
if (user == null)
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
_Config.DeleteUser(user.GUID);
ctx.Response.StatusCode = 204;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <ObjectMetadata> ObjectExists(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectExists: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
return(_ObjectMetadata);
}
private async Task GetBuckets(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length >= 3)
{
Bucket bucket = _Buckets.Get(ctx.Http.Request.Url.Elements[2]);
if (bucket == null)
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
else
{
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(bucket, true));
return;
}
}
else
{
List <Bucket> buckets = _Config.GetBuckets();
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(buckets, true));
return;
}
}
private async Task GetUsers(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length >= 3)
{
User user = _Config.GetUserByName(ctx.Http.Request.Url.Elements[2]);
if (user == null)
{
ctx.Response.StatusCode = 404;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
else
{
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(user, true));
return;
}
}
else
{
List <User> users = _Config.GetUsers();
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "application/json";
await ctx.Response.Send(Common.SerializeJson(users, true));
return;
}
}
public void SetUp()
{
var credentialsOptions = new CredentialsOptions();
var credentialsProvider = new CredentialsProvider(credentialsOptions);
var options = new S3Options <S3ContextTests>();
_context = new S3Context <S3ContextTests>(credentialsProvider, options);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <Retention> ObjectReadRetention(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectReadRetention: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
Retention ret = new Retention("GOVERNANCE", DateTime.Now.AddDays(100));
return(ret);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <LegalHold> ObjectReadLegalHold(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectReadLegalHold: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
LegalHold legalHold = new LegalHold("OFF");
return(legalHold);
}
#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);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <BucketLoggingStatus> BucketReadLogging(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("BucketReadLogging: " + ctx.Request.Bucket);
BucketLoggingStatus status = new BucketLoggingStatus(new LoggingEnabled("default", "prefix", new TargetGrants()));
return(status);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <Tagging> ObjectReadTags(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectReadTags: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
Tagging tagging = new Tagging(new TagSet(new List <Tag> {
_Tag
}));
return(tagging);
}
static async Task ObjectWrite(S3Context ctx)
{
if (ctx.Request.Chunked)
{
await SendChunkResponse(ctx, "Object write chunked");
}
else
{
await SendResponse(ctx, "Object write");
}
}
internal static RequestMetadata GetRequestMetadata(S3Context ctx)
{
if (ctx == null)
{
return(null);
}
if (ctx.Metadata == null)
{
return(null);
}
return((RequestMetadata)(ctx.Metadata));
}
private async Task PostUsers(S3Context ctx)
{
if (ctx.Http.Request.Url.Elements.Length != 2)
{
await ctx.Response.Send(S3ServerInterface.S3Objects.ErrorCode.InvalidRequest);
return;
}
byte[] data = null;
User user = null;
try
{
data = Common.StreamToBytes(ctx.Request.Data);
user = Common.DeserializeJson <User>(data);
}
catch (Exception)
{
await ctx.Response.Send(S3ServerInterface.S3Objects.ErrorCode.InvalidRequest);
return;
}
User tempUser = _Config.GetUserByEmail(user.Email);
if (tempUser != null)
{
ctx.Response.StatusCode = 409;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
tempUser = _Config.GetUserByGuid(user.GUID);
if (tempUser != null)
{
ctx.Response.StatusCode = 409;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
return;
}
_Config.AddUser(user);
ctx.Response.StatusCode = 201;
ctx.Response.ContentType = "text/plain";
await ctx.Response.Send();
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <S3Object> ObjectReadRange(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectReadRange: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
string data = _S3Object.DataString;
data = data.Substring((int)ctx.Request.RangeStart, (int)((int)ctx.Request.RangeEnd - (int)ctx.Request.RangeStart));
int len = data.Length;
_S3Object.DataString = data;
_S3Object.Size = len;
return(_S3Object);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <ListBucketResult> BucketRead(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("BucketRead: " + ctx.Request.Bucket);
List <ObjectMetadata> contents = new List <ObjectMetadata>()
{
_ObjectMetadata
};
ListBucketResult result = new ListBucketResult("default", contents, 1, 1);
return(result);
}
static async Task SendChunkResponse(S3Context ctx, string text)
{
Console.WriteLine("[" + ctx.Http.Request.Source.IpAddress + ":" + ctx.Http.Request.Source.Port + "] " + text);
byte[] data = Encoding.UTF8.GetBytes(text);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
ctx.Response.ContentLength = data.Length;
await ctx.Response.SendFinalChunk(data);
return;
}
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;
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <DeleteResult> ObjectDeleteMultiple(S3Context ctx, DeleteMultiple del)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectDelete: " + ctx.Request.Bucket);
Console.WriteLine(ctx.Request.DataAsString + Environment.NewLine);
DeleteResult result = new DeleteResult(
new List <Deleted>()
{
new Deleted("hello.txt", "1", false)
},
null);
return(result);
}
#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);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <AccessControlPolicy> ObjectReadAcl(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("ObjectReadAcl: " + ctx.Request.Bucket + "/" + ctx.Request.Key);
AccessControlList acl = new AccessControlList(
new List <Grant>()
{
new Grant(_Grantee, "FULL_CONTROL")
});
AccessControlPolicy policy = new AccessControlPolicy(
_Owner,
acl);
return(policy);
}
static async Task SendResponse(S3Context ctx, string text)
{
Console.WriteLine("[" + ctx.Http.Request.Source.IpAddress + ":" + ctx.Http.Request.Source.Port + "] " + text);
byte[] data = Encoding.UTF8.GetBytes(text);
ctx.Response.StatusCode = 200;
ctx.Response.ContentType = "text/plain";
ctx.Response.ContentLength = data.Length;
ctx.Response.Data = new MemoryStream();
ctx.Response.Data.Write(data, 0, data.Length);
ctx.Response.Data.Seek(0, SeekOrigin.Begin);
await ctx.Response.Send();
return;
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task <WebsiteConfiguration> BucketReadWebsite(S3Context ctx)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("BucketReadWebsite: " + ctx.Request.Bucket);
WebsiteConfiguration website = new WebsiteConfiguration();
website.ErrorDocument = new ErrorDocument("error.html");
website.IndexDocument = new IndexDocument("index.html");
website.RedirectAllRequestsTo = new RedirectAllRequestsTo("localhost", "http");
website.RoutingRules = new RoutingRules(
new List <RoutingRule> {
new RoutingRule(new Condition("400", "prefix"),
new Redirect("localhost", "302", "http", null, null))
}
);
return(website);
}
