protected override async Task <JToken> ExecuteController(JToken data)
{
var modelName = data.ParseField <string>("ModelName");
if (modelName == null)
{
return(JStatus.RequestArgumentNotFound("ModelName"));
}
var modelType = Type.GetType($"SagaNetwork.Models.{modelName}");
if (modelType == null)
{
return(JStatus.MetaNotFound);
}
dynamic model = Activator.CreateInstance(modelType);
var metas = await model.RetrieveAllAsync();
var response = JStatus.Ok.ToObject <JObject>();
response.Add("Metas", JToken.FromObject(metas));
return(response);
}
protected override async Task <JToken> ExecuteController(JToken data)
{
var jsonBlobId = data.ParseField <string>("Id");
if (jsonBlobId == null)
{
return(JStatus.RequestArgumentNotFound("Id"));
}
var jsonBlob = await new JsonBlob(jsonBlobId).LoadAsync();
if (jsonBlob == null)
{
return(JStatus.NotFound);
}
var blockBlob = CloudStorage.BlobContainer.GetBlockBlobReference(jsonBlob.BlobPath);
if (!await blockBlob.ExistsAsync())
{
return(JStatus.NotFound);
}
var jsonText = await blockBlob.DownloadTextAsync();
var response = JStatus.Ok.ToObject <JObject>();
response.Add("JsonText", jsonText);
return(response);
}
public Tuple <JStatus, Request.ResponseInfo> GetStatus()
{
var uri = new Uri(URL.base_url + URL.status);
HttpStatusCode status;
int requestsRemaining;
var raw_match = Request.DoRequest(uri, "", true, false, false);
return(new Tuple <JStatus, Request.ResponseInfo>(JStatus.FromJson(raw_match.response), raw_match));
}
/// <summary>
/// Default handler to serve WebSocket pipeline.
/// </summary>
/// <param name="httpContext">HTTP context of the request.</param>
/// <param name="next"></param>
public static async Task HandleWebSoсketRequestAsync(HttpContext httpContext, Func <Task> next)
{
if (httpContext.WebSockets.IsWebSocketRequest)
{
var webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
var isAuthed = false;
var buffer = new ArraySegment <byte>(new byte[4096]);
var requestString = string.Empty;
if (webSocket != null && webSocket.State == WebSocketState.Open)
{
while (webSocket.State == WebSocketState.Open)
{
var received = await webSocket.ReceiveAsync(buffer, CancellationToken.None);
requestString += Encoding.UTF8.GetString(buffer.Array, buffer.Offset, received.Count);
if (!received.EndOfMessage)
{
continue;
}
var requestToken = JParser.TryParse(requestString);
requestString = string.Empty;
if (requestToken == null)
{
continue;
}
JToken responseToken;
// Check auth only once per socket connection.
if (!isAuthed)
{
isAuthed = Authorization.CheckAuth(requestToken);
}
if (isAuthed)
{
var controllerName = requestToken.ParseField <string>("Controller");
if (controllerName == null)
{
responseToken = JStatus.RequestArgumentNotFound("Controller");
}
else
{
var controllerType = Type.GetType($"SagaNetwork.Controllers.{controllerName}Controller");
if (controllerType == null)
{
responseToken = JStatus.ControllerNotFound;
}
else
{
var controller = Activator.CreateInstance(controllerType) as BaseController;
if (controller != null)
{
responseToken = await controller.HandleRequestAsync(requestToken, skipClientAuthCheck : true);
}
else
{
responseToken = JStatus.ControllerNotFound;
}
}
}
}
else
{
responseToken = JStatus.AuthFail;
}
// Inject request ID.
var requestId = requestToken.ParseField <string>("RequestId");
if (requestId == null)
{
responseToken = JStatus.RequestArgumentNotFound("RequestId");
}
else
{
responseToken["RequestId"] = requestId;
}
var responseData = Encoding.UTF8.GetBytes(responseToken.ToString());
buffer = new ArraySegment <byte>(responseData);
await webSocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}
else
{
await next(); // not a websocket request — pass downstream
}
}
/// <summary>
/// Validates and parses request/response data, executes derived controller and handles OCC.
/// </summary>
private async Task <JToken> HandleRequestAsync(JToken data, bool skipClientAuthCheck = false)
{
if (data == null || !data.HasValues)
{
return(JStatus.WrongQuery);
}
var derivedType = this.GetType();
// Handle server auth.
if (derivedType.GetCustomAttributes <RequireServerAuthAttribute>(true).Any() &&
!Authorization.CheckAuth(data, requireServerAuth: true))
{
return(JStatus.ServerAuthFail);
}
// Handle client auth.
if (!skipClientAuthCheck && derivedType.GetCustomAttributes <RequireAuthAttribute>(true).Any() &&
!Authorization.CheckAuth(data))
{
return(JStatus.AuthFail);
}
// Inject request arguments.
var fields = derivedType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
foreach (var field in fields.Where(p => p.GetCustomAttributes <ApiRequestDataAttribute>(true).Any()))
{
var parsedField = data.ParseField(field.Name, field.FieldType);
if (parsedField == null)
{
return(JStatus.RequestArgumentNotFound(field.Name));
}
field.SetValue(this, Convert.ChangeType(parsedField, field.FieldType));
}
// Execute the derived controller logic.
responseToken = await ExecuteController(data);
// Handle OCC violations.
if (OccFailFlag)
{
OccFailFlag = false;
curOccRetry++;
if (curOccRetry > OCC_RETRY_COUNT)
{
return(JStatus.OccFail);
}
await HandleRequestAsync(data);
}
if (responseToken == null)
{
responseToken = JStatus.ControllerFail;
}
// Inject response data.
foreach (var field in fields.Where(p => p.GetCustomAttributes <ApiResponseDataAttribute>(true).Any()))
{
if (field.GetValue(this) != null)
{
responseToken[field.Name] = JToken.FromObject(field.GetValue(this));
}
}
return(responseToken);
}
