protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
Console.WriteLine(exceptionContext.Error);
//exceptionContext.Result = "Change the return value, nulls error";
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
#if DEBUG
Debug.WriteLine("=> Invoking " + context.MethodDescriptor.Name + " on hub " + context.MethodDescriptor.Hub.Name);
#endif
return base.OnBeforeIncoming(context);
}
protected override object OnAfterIncoming(object result, IHubIncomingInvokerContext context)
{
var startedOn = (DateTime)context.StateTracker["ProfilingHubPipelineModule-Invocation-StartedOn"];
var invocation = new InvocationModel
{
ConnectionId = context.Hub.Context.ConnectionId,
Hub = context.MethodDescriptor.Hub.Name,
Method = context.MethodDescriptor.Name,
StartedOn = startedOn,
EndedOn = DateTime.Now,
Result = new InvocationResultModel
{
Value = result,
Type = context.MethodDescriptor.ReturnType
},
Arguments = context.Args.Count > 0 ? context.Args
.Select((t, i) => new InvocationArgumentModel
{
Value = t,
Name = context.MethodDescriptor.Parameters[i].Name,
Type = context.MethodDescriptor.Parameters[i].ParameterType
})
.ToList() : null
};
PluginSettings.StoreInvocation(invocation);
return base.OnAfterIncoming(result, context);
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
if (string.IsNullOrWhiteSpace(AuthToken))
return false;
return hubIncomingInvokerContext.Hub.Context.Headers[AuthTokenProvider.AuthTokenKey] == AuthToken;
}
/// <summary>
/// 数据传到Hub之前进行数据解密
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
//_canCrypto = CanCrypto(context.Hub.Context);
//if (!_canCrypto)
//{
// return base.OnBeforeIncoming(context);
//}
//数据解密
string facePublicKey = context.Hub.Context.Headers.Get(HttpHeaderNames.OSharpClientPublicKey);
if (string.IsNullOrEmpty(facePublicKey))
{
return false;
}
_cryptor = new CommunicationCryptor(_ownPrivateKey, facePublicKey, _hashType);
if (context.Args.Count == 1)
{
string encrypt = (string)context.Args[0];
string json = _cryptor.DecryptAndVerifyData(encrypt);
IList<object> args = JsonConvert.DeserializeObject<IList<object>>(json);
context.Args.Clear();
IList<object> values = context.MethodDescriptor.Parameters.Zip(args, (desc, arg) => ResolveParameter(desc, arg)).ToList();
foreach (object arg in values)
{
context.Args.Add(arg);
}
}
return base.OnBeforeIncoming(context);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
if (log.IsDebugEnabled)
{
log.DebugFormat(string.Format("Invoking {0} on hub {1}", context.MethodDescriptor.Name, context.MethodDescriptor.Hub.Name));
}
return base.OnBeforeIncoming(context);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext context)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("Exception while invoking {0} on hub {1}: {2}", context.MethodDescriptor.Name, context.MethodDescriptor.Hub.Name, exceptionContext.Error.Message);
}
base.OnIncomingError(exceptionContext, context);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
if (Log.IsDebugEnabled)
{
Log.DebugFormat("=> Invoking " + context.MethodDescriptor.Name + " on hub " + context.MethodDescriptor.Hub.Name);
}
return base.OnBeforeIncoming(context);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
if (string.IsNullOrWhiteSpace(context.MethodDescriptor.Name))
{
Console.WriteLine("Error");
}
Console.WriteLine("=> Invoking " + context.MethodDescriptor.Name + " on hub " + context.MethodDescriptor.Hub.Name);
return(base.OnBeforeIncoming(context));
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
ChatLog.Debug("=> Exception " + exceptionContext.Error.Message + " " + exceptionContext.Error.StackTrace);
if (exceptionContext.Error.InnerException != null)
{
ChatLog.Debug("=> Inner Exception " + exceptionContext.Error.InnerException.Message + " " + exceptionContext.Error.InnerException.StackTrace);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext ex, IHubIncomingInvokerContext context)
{
_slabLogger.Log(HubType.HubServerVerbose, "=> Exception " + ex.Error + " " + ex.Result);
if (ex.Error.InnerException != null)
{
_slabLogger.Log(HubType.HubServerVerbose, "=> Inner Exception " + ex.Error.InnerException.Message);
}
base.OnIncomingError(ex, context);
}
public new bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
lock (_locker)
{
Events.Add(new Tuple <string, object>("OnBeforeIncoming", context));
}
return(base.OnBeforeIncoming(context));
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
if (string.IsNullOrWhiteSpace(AuthToken))
{
return(false);
}
return(hubIncomingInvokerContext.Hub.Context.Headers[AuthTokenProvider.AuthTokenKey] == AuthToken);
}
public new void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
lock (_locker)
{
Events.Add(new Tuple <string, object>("OnIncomingError", exceptionContext));
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
Debug.WriteLine("=> Exception " + exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
Debug.WriteLine("=> Inner Exception " + exceptionContext.Error.InnerException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext ex, IHubIncomingInvokerContext context)
{
_slabLogger.Error("ErrorHandlingPipelineModule.OnIncomingError", "=> Exception " + ex.Error + " " + ex.Result);
if (ex.Error.InnerException != null)
{
_slabLogger.Error("ErrorHandlingPipelineModule.OnIncomingError", "=> Inner Exception " + ex.Error.InnerException.Message);
}
base.OnIncomingError(ex, context);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
File.WriteAllText("D:\\signalr.txt", "=> Exception " + exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
File.WriteAllText("D:\\signalr.txt", "=> Inner Exception " + exceptionContext.Error.InnerException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
public new object OnAfterIncoming(object result, IHubIncomingInvokerContext context)
{
lock (_locker)
{
Events.Add(new Tuple <string, object>("OnAfterIncoming", context));
}
return(base.OnAfterIncoming(result, context));
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
Debug.WriteLine("=> Exception " + exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
Debug.WriteLine("=> Inner Exception " + exceptionContext.Error.InnerException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
ChatLog.Debug("=> Exception " + exceptionContext.Error.Message + " " + exceptionContext.Error.StackTrace);
if (exceptionContext.Error.InnerException != null)
{
ChatLog.Debug("=> Inner Exception " + exceptionContext.Error.InnerException.Message + " " + exceptionContext.Error.InnerException.StackTrace);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
public override bool AuthorizeHubMethodInvocation(
IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
if (hubIncomingInvokerContext.Hub.Context.User is ClaimsPrincipal user &&
_allowedAuthenticationTypes.Any(type => user.HasClaim("AuthorizationType", type)))
{
return(base.AuthorizeHubMethodInvocation(hubIncomingInvokerContext, appliesToMethod));
}
return(false);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
var id = HttpContext.Current.User.Identity.IsAuthenticated
? "fred"
: string.Empty;
context.Hub.Groups.Add(context.Hub.Context.ConnectionId, id);
return base.OnBeforeIncoming(context);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
var id = HttpContext.Current.User.Identity.IsAuthenticated
? "fred"
: string.Empty;
context.Hub.Groups.Add(context.Hub.Context.ConnectionId, id);
return(base.OnBeforeIncoming(context));
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
base.OnIncomingError(exceptionContext, invokerContext);
//todo:记录到Log4Net或分布式日志服务器中
dynamic caller = invokerContext.Hub.Clients.Caller;
caller.onServerError(exceptionContext.Error.Message);
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
string token = hubIncomingInvokerContext.Hub.Context.Headers["authtoken"];
if (token == AuthToken)
{
return(true);
}
return(false);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
//异常信息
//exceptionContext.Error;
dynamic caller = invokerContext.Hub.Clients.Caller;
caller.onException("发送错误");
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext) {
_logger.Error()
.Exception(exceptionContext.Error)
.MarkUnhandled("ErrorHandlingPipelineModule")
.Message("Unhandled: {0}", exceptionContext.Error.Message)
.Tag("SignalR")
.Write();
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// HARD-CODED constant
Tracer.Instance.TraceEvent(TraceEventType.Verbose, 0, "=> Invoking [" + context.MethodDescriptor.Name + "] on hub [" + context.MethodDescriptor.Hub.Name + "]");
return(base.OnBeforeIncoming(context));
}
public static void SignalRError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
try {
var context = invokerContext.Hub.Context;
var method = $"/{invokerContext.MethodDescriptor.Hub.Name}/{invokerContext.MethodDescriptor.Name}";
var logHead = new NetHelper.HttpInfo(context.Request.GetHttpContext().Request, context.RequestCookies).LogHeadNoPath;
var msg = $"ERROR = {JsonConvert.SerializeObject(new {ErrorMessage = exceptionContext.Error.Message})}";
SignalRServerLog.Error($"{logHead}{method} {msg}", exceptionContext.Error);
} catch (Exception e) { Error(LogTag.LoggingError, e, new { source = "SignalRError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)" }); }
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
MethodDescriptor method = invokerContext.MethodDescriptor;
Debug.WriteLine("{0}.{1}({2}) threw the following uncaught exception: {3}",
method.Hub.Name,
method.Name,
String.Join(", ", invokerContext.Args),
exceptionContext.Error);
}
/// <summary>
/// This is called when an uncaught exception is thrown by a server-side hub method or the incoming component of a
/// module added later to the <see cref="T:Microsoft.AspNet.SignalR.Hubs.IHubPipeline" />. Observing the exception using this method will not prevent
/// it from bubbling up to other modules.
/// </summary>
/// <param name="exceptionContext">Represents the exception that was thrown during the server-side invocation.
/// It is possible to change the error or set a result using this context.</param>
/// <param name="invokerContext">A description of the server-side hub method invocation.</param>
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
var logEntry = new LogEntry(exceptionContext.Error.ToString(), DateTime.UtcNow, LogServerity.Error);
Task.Factory.StartNew(async() => {
await Logger.WriteLogEntry(logEntry);
}).Wait();
base.OnIncomingError(exceptionContext, invokerContext);
}
/// <summary>
/// This method is called after the incoming components of any modules added later to the <see cref="IHubPipeline"/>
/// and the server-side hub method have completed execution.
/// </summary>
/// <param name="result">The return value of the server-side hub method</param>
/// <param name="context">A description of the server-side hub method invocation.</param>
/// <returns>The possibly new or updated return value of the server-side hub method</returns>
protected override object OnAfterIncoming(object result, IHubIncomingInvokerContext context)
{
var attributes = context.MethodDescriptor.Attributes.OfType <ActionFilterAttribute>();
foreach (var attribute in attributes)
{
attribute.OnAfterIncoming(result, context);
}
return(base.OnAfterIncoming(result, context));
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
var connectionId = hubIncomingInvokerContext.Hub.Context.ConnectionId;
var environment = hubIncomingInvokerContext.Hub.Context.Request.Environment;
var principal = hubIncomingInvokerContext.Hub.Context.Request.Environment["server.User"] as IPrincipal;
if (principal == null || !principal.Identity.IsAuthenticated) return false;
hubIncomingInvokerContext.Hub.Context = new HubCallerContext(new ServerRequest(environment), connectionId);
return true;
}
/// <summary>
/// This is called when an uncaught exception is thrown by a server-side hub method or the incoming component of a
/// module added later to the <see cref="IHubPipeline"/>. Observing the exception using this method will not prevent
/// it from bubbling up to other modules.
/// </summary>
/// <param name="ex">The exception that was thrown during the server-side invocation.</param>
/// <param name="context">A description of the server-side hub method invocation.</param>
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
var attributes = invokerContext.MethodDescriptor.Attributes.OfType <ActionFilterAttribute>();
foreach (var attribute in attributes)
{
attribute.OnIncomingError(exceptionContext, invokerContext);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
_logger.Error(exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
_logger.Error(exceptionContext.Error.InnerException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
var connectionId = invokerContext.Hub.Context.ConnectionId;
DataClassesManager.InsertLog("=> Exception " + exceptionContext.Error.Message, "SignalR", "OnIncomingError", connectionId);
if (exceptionContext.Error.InnerException != null)
{
DataClassesManager.InsertLog("=> Inner Exception " + exceptionContext.Error.InnerException.Message, "SignalR", "OnIncomingError", connectionId);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
Logger.Error()
.Exception(exceptionContext.Error)
.MarkUnhandled("ErrorHandlingPipelineModule")
.Message("Unhandled: {0}", exceptionContext.Error.Message)
.Tag("SignalR")
.Write();
base.OnIncomingError(exceptionContext, invokerContext);
}
/// <summary>
/// This is called when an uncaught exception is thrown by a server-side hub method or the incoming component of a
/// module added later to the <see cref="IHubPipeline"/>. Observing the exception using this method will not prevent
/// it from bubbling up to other modules.
/// </summary>
/// <param name="ex">The exception that was thrown during the server-side invocation.</param>
/// <param name="context">A description of the server-side hub method invocation.</param>
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
if (this.onIncomingError == null)
{
base.OnIncomingError(exceptionContext, invokerContext);
}
else
{
this.onIncomingError(exceptionContext, invokerContext);
}
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
// if TableGamesException, convert to HubException to be exposed in clients
var tableGamesException = getTableGamesException(exceptionContext.Error);
if (tableGamesException != null)
{
exceptionContext.Error = new HubException(tableGamesException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
try
{
Log.Error(exceptionContext.Error, "Exception invoking {Method} on {Hub} with {Args}", invokerContext.MethodDescriptor.Name, invokerContext.Hub.GetType().Name, invokerContext.Args);
}
// ReSharper disable once UnusedVariable
catch (Exception e)
{
if (Debugger.IsAttached) Debugger.Break();
}
}
public bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext)
{
switch (Mode)
{
case AuthorizeMode.Both:
case AuthorizeMode.Incoming:
return UserAuthorized(hubIncomingInvokerContext.Hub.Context.User);
default:
Debug.Assert(Mode == AuthorizeMode.Outgoing); // Guard in case new values are added to the enum
return true;
}
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
bool isConnect = hubIncomingInvokerContext.Hub.Context.Request.LocalPath == "/signalr/connect";
return
(IsLocalRequest(hubIncomingInvokerContext.Hub.Context) ||
isConnect ||
!appliesToMethod ||
((HttpListener)hubIncomingInvokerContext.Hub.Context.Request.Environment["System.Net.HttpListener"]).AuthenticationSchemes == AuthenticationSchemes.Anonymous ||
hubIncomingInvokerContext.Hub.Context.User?.IsInRole("Traders") == true
);//OnAuthorization(hubIncomingInvokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
var logger = new NLogLogger("SignalR");
logger.Log(Logger.LoggerLevels.Error, "=> Exception " + exceptionContext.Error.Message);
logger.Log(Logger.LoggerLevels.Error, exceptionContext.Error.ToString());
if (exceptionContext.Error.InnerException != null)
{
logger.Log(Logger.LoggerLevels.Error, "=> Inner Exception " + exceptionContext.Error.InnerException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
string message = string.Format("=> Exception {0}", exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
message += "\n\t=> Inner Exception " + exceptionContext.Error.InnerException.Message;
}
WindowsEventLog.WriteErrorLog(message);
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
string message = string.Format("=> Exception {0}", exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
message += "\n\t=> Inner Exception " + exceptionContext.Error.InnerException.Message;
}
WindowsEventLog.WriteErrorLog(message);
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext)
{
if (exceptionContext == null)
{
throw new ArgumentNullException(nameof(exceptionContext));
}
Tracer.Instance.TraceEvent(TraceEventType.Error, 0, "=> Exception " + exceptionContext.Error.Message);
if (exceptionContext.Error.InnerException != null)
{
Tracer.Instance.TraceEvent(TraceEventType.Error, 0, "=> Inner Exception " + exceptionContext.Error.InnerException.Message);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
public bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext)
{
switch (Mode)
{
case AuthorizeMode.Both:
case AuthorizeMode.Incoming:
return(UserAuthorized(hubIncomingInvokerContext.Hub.Context.User));
default:
Debug.Assert(Mode == AuthorizeMode.Outgoing); // Guard in case new values are added to the enum
return(true);
}
}
protected override void OnIncomingError(ExceptionContext exceptionContext,
IHubIncomingInvokerContext invokerContext)
{
Log.Error("Error accessing hub " + exceptionContext.Error.Message, this);
if (exceptionContext.Error.InnerException != null)
{
Log.Error("=> Inner Exception " + exceptionContext.Error.InnerException.Message, this);
}
base.OnIncomingError(exceptionContext, invokerContext);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
var onlyAttr = context.MethodDescriptor.Attributes.OfType<OnlyOnAttribute>().FirstOrDefault();
if (onlyAttr != null)
{
var today = DateTime.Today.DayOfWeek;
var todayIsValidDay = onlyAttr.Weekdays & (Weekday)(1 << (int)today);
var canContinue = todayIsValidDay != 0;
if (!canContinue)
{
Debug.WriteLine("Called " + context.MethodDescriptor.Name + "() on server, but today is not allowed");
}
return canContinue;
}
return true;
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext invoker, bool appliesToMethod)
{
string connectionId = invoker.Hub.Context.ConnectionId;
var environment = invoker.Hub.Context.Request.Environment;
var principal = environment["server.User"] as ClaimsPrincipal;
if(principal?.Identity != null &&
principal.Identity.IsAuthenticated)
{
// create a new HubCallerContext instance with the principal generated from token
// and replace the current context so that in hubs we can retrieve current user identity
invoker.Hub.Context = new HubCallerContext(new ServerRequest(environment), connectionId);
return true;
}
return false;
}
public virtual bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
if (hubIncomingInvokerContext == null)
{
throw new ArgumentNullException("hubIncomingInvokerContext");
}
// It is impossible to require outgoing auth at the method level with SignalR's current design.
// Even though this isn't the stage at which outgoing auth would be applied, we want to throw a runtime error
// to indicate when the attribute is being used with obviously incorrect expectations.
// We must explicitly check if _requireOutgoing is true since it is a Nullable type.
if (appliesToMethod && (_requireOutgoing == true))
{
throw new ArgumentException(Resources.Error_MethodLevelOutgoingAuthorization);
}
return UserAuthorized(hubIncomingInvokerContext.Hub.Context.User);
}
public IEnumerable<ValidationError> ValidateHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext)
{
var errors = new List<ValidationError>();
for (int i = 0; i < hubIncomingInvokerContext.Args.Count; ++i)
{
var arg = hubIncomingInvokerContext.Args[i];
var ctx = new ValidationContext(arg, null, null);
var results = new List<ValidationResult>();
bool valid = Validator.TryValidateObject(arg, ctx, results, true);
if (!valid)
{
ValidationError ve = ValidationErrorsFactory.Buildup(hubIncomingInvokerContext.MethodDescriptor.Parameters[i].Name, arg, results);
errors.Add(ve);
}
}
return errors;
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
try
{
var connectionId = hubIncomingInvokerContext.Hub.Context.ConnectionId;
var environment = hubIncomingInvokerContext.Hub.Context.Request.Environment;
var principal = environment["server.User"] as GenericPrincipal;
if (principal != null && principal.Identity.IsAuthenticated)
{
hubIncomingInvokerContext.Hub.Context = new HubCallerContext(new ServerRequest(environment), connectionId);
return true;
}
}
catch (Exception e)
{
log.ErrorFormat("AuthorizeHubMethodInvocation error: {0}, {1}, {2}", e, e.StackTrace, e.InnerException != null ? e.InnerException.Message : string.Empty);
return false;
}
return false;
}
//static readonly ILog logger = LogManager.GetLogger(typeof(HubErrorLoggingPipelineModule));
protected override void OnIncomingError(ExceptionContext exceptionContext,
IHubIncomingInvokerContext invokerContext) {
// Don't log user exceptions...
var hubEx = exceptionContext.Error as HubException;
if (hubEx != null) {
var data = hubEx.ErrorData as UserException;
if (data != null) {
MainLog.Logger.FormattedWarnException(data, "UserException catched in Hub Pipeline");
return;
}
var ex = hubEx.ErrorData as Exception;
if (ex != null) {
MainLog.Logger.FormattedErrorException(ex,
"An error occurred on signalr hub: " + GetInvocationInfo(invokerContext));
}
return;
}
if (exceptionContext.Error is UserException || exceptionContext.Error.InnerException is UserException)
return;
MainLog.Logger.FormattedErrorException(exceptionContext.Error,
"An error occurred on signalr hub: " + GetInvocationInfo(invokerContext));
}
protected override void OnIncomingError(Exception ex, IHubIncomingInvokerContext context)
{
_logger.LogError("{0}: Failure while invoking '{1}'.", context.Hub.Context.Request.User.GetUserId(), context.MethodDescriptor.Name);
_logger.Log(ex);
}
protected override void OnIncomingError(Exception ex, IHubIncomingInvokerContext context)
{
Debug.WriteLine("Invoking method " + context.MethodDescriptor.Name + " on " + context.MethodDescriptor.Name + " gave error " + ex.GetBaseException());
base.OnIncomingError(ex, context);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
Debug.WriteLine("Before method " + context.MethodDescriptor.Name + " on " + context.MethodDescriptor.Hub.Name);
return base.OnBeforeIncoming(context);
}
protected override bool OnBeforeIncoming(IHubIncomingInvokerContext context)
{
Debug.WriteLine("Loggin OnBeforeIncoming: {0}, {1}", context.Hub.Context.ConnectionId, context.MethodDescriptor.Name);
return true;
}
public override bool AuthorizeHubMethodInvocation(IHubIncomingInvokerContext hubIncomingInvokerContext, bool appliesToMethod)
{
return true;
}
protected override object OnAfterIncoming(object result, IHubIncomingInvokerContext context)
{
Debug.WriteLine("After method " + context.MethodDescriptor.Name + " on " + context.MethodDescriptor.Hub.Name);
return base.OnAfterIncoming(result, context);
}
