public bool PreHandleInterceptors(List <IHandlerInterceptor> interceptors,
SocketRequest request, Socket socket)
{
foreach (var interceptor in interceptors)
{
Stopwatch sw = new Stopwatch();
sw.Start();
var handleResult = interceptor.PreHandle(request);
sw.Stop();
if (telemetry != null)
{
telemetry.Collect(new InterceptorExecutionTime(interceptor.ControllerName,
interceptor.ActionName, sw.ElapsedMilliseconds));
}
if (handleResult.CancelActionInvoke)
{
var response = (handleResult.ResponseSuccess
? ResponseStatus.SUCCESS
: ResponseStatus.ERROR);
request.ProcessResponse(ActionResult.Json(
new OperationResult("", response, handleResult.Message), response, handleResult.Message), socket, null);
return(false);
}
}
return(true);
}
private bool HasRequestErros(ref SocketRequest request)
{
if (request.HasErrors)
{
request.ProcessResponse(ActionResult.Json("", ResponseStatus.ERROR, request.InternalErrorMessage), clientSocket, null);
return(true);
}
return(false);
}
private void ProcessErrorResponse(Exception ex, ref SocketRequest request)
{
string msg = ex.Message;
if (ex.InnerException != null)
{
msg += $" {ex.InnerException.Message}";
}
if (telemetry != null)
{
telemetry.Collect(new ActionError(controllerName, actionName, msg));
}
if (request != null)
{
ServerAction serverAction = method.GetCustomAttribute <ServerAction>();
if (serverAction == null)
{
request.ProcessResponse(ActionResult.Json("", ResponseStatus.ERROR, $"Process request error: {msg}"), clientSocket, null);
}
else
{
int errorCode = (serverAction.DefaultErrorCode == 0
? ResponseStatus.ERROR
: serverAction.DefaultErrorCode);
if (serverAction.ExceptionHandler == null)
{
request.ProcessResponse(ActionResult.Json("", errorCode, $"Process request error: {msg}"), clientSocket, null);
}
else
{
IActionExceptionHandler handler = (IActionExceptionHandler)
Activator.CreateInstance(serverAction.ExceptionHandler);
ActionResult result = ActionResult.Json(handler.Handle(ex, request), 600, "Request error, but handled by application");
request.ProcessResponse(result, clientSocket, null);
}
}
}
}
public override object DoInBackGround(int p)
{
SocketRequest request = null;
try
{
request = GetRequestSocket();
if (request == null)
{
return(null);
}
if (HasRequestErros(ref request))
{
return(null);
}
controller = request.Controller;
method = controller.GetType().GetMethod(request.Action);
ValidateActionMethod();
controllerName = controller.GetType().Name;
actionName = method.Name;
WaitActionLockPendingCompletations(ref request,
ref controller, ref actionName);
if (method.GetCustomAttribute <SingleThreaded>() != null)
{
ActionLocker.AddLock(controller, actionName);
}
ResolveActionParameters(ref request);
if (!ResolveInterceptors(ref request))
{
return(null);
}
ParameterInfo[] methodParameters = method.GetParameters();
object[] parameterValues = new object[methodParameters.Length];
int methodParameterCount = methodParameters
.Where(pr => request.Parameters.Any(rp => rp.Name.Equals(pr.Name)))
.Count();
int parameterIndex = 0;
int valueIndex = 0;
foreach (RequestParameter rp in request.Parameters)
{
ParameterInfo parameterInfo = methodParameters.FirstOrDefault(mp => mp.Name.Equals(rp.Name));
if (parameterInfo == null)
{
parameterIndex += 1;
continue;
}
parameterValues[valueIndex] = request.Parameters[parameterIndex].Value;
parameterIndex += 1;
valueIndex += 1;
}
ActionResult result = null;
Stopwatch w = new Stopwatch();
w.Start();
if (method.ReturnType == null)
{
//void action
method.Invoke(controller, parameterValues);
result = ActionResult.Json(new OperationResult(null, 600, ""));
}
else if (method.ReturnType == typeof(ActionResult)) //ActionResult action
{
result = (ActionResult)method.Invoke(controller, parameterValues);
}
else
{
//user-defined object Action
object returnObj = method.Invoke(controller, parameterValues);
result = ActionResult.Json(new OperationResult(returnObj, 600, ""));
}
w.Stop();
if (telemetry != null)
{
telemetry.Collect(new ActionExecutionTime(controllerName, actionName, w.ElapsedMilliseconds));
}
logger.WriteLog($"Request completed: {controllerName}/{actionName}; ~{w.ElapsedMilliseconds}ms");
if (w.ElapsedMilliseconds > 10000)
{
ServerAlertManager.CreateAlert(new ServerAlert(request.Controller.GetType().Name, request.Action,
$"The action it is taking considerable time to execute ({w.ElapsedMilliseconds} ms). Review your code to improve performance.'"));
}
ActionLocker.ReleaseLock(controller, method.Name);
request.ProcessResponse(result, clientSocket, requestBody.InTo);
return(result);
}
catch (LockedActionException lockedEx)
{
ProcessErrorResponse(lockedEx, ref request);
return(null);
}
catch (Exception ex)
{
if (method != null &&
controller != null)
{
ActionLocker.ReleaseLock(controller, actionName);
}
ProcessErrorResponse(ex, ref request);
return(null);
}
}