private async Task <object> Interceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain target, IGrainMethodInvoker invoker) { if (targetMethod == null) { throw new ArgumentNullException(nameof(targetMethod)); } var declaringNameSpace = targetMethod.DeclaringType?.Namespace; // Do not intercept Orleans grains or other grains which should not be included in statistics. if (targetMethod.DeclaringType.GetCustomAttribute <ExcludeGrainFromStatisticsAttribute>() != null || declaringNameSpace?.StartsWith("Orleans") == true) { return(await invoker.Invoke(target, request)); } RequestTimings.GetOrCreate(); // Ensure request timings is created here and not in the grain call. RequestTimings.Current.Request.Start(); Exception ex = null; try { return(await invoker.Invoke(target, request)); } catch (Exception e) { ex = e; throw; } finally { RequestTimings.Current.Request.Stop(); var grainEvent = EventPublisher.CreateEvent(); grainEvent.TargetType = targetMethod.DeclaringType?.FullName; grainEvent.TargetMethod = targetMethod.Name; grainEvent.Exception = ex; grainEvent.ErrCode = ex != null ? null : (int?)0; try { EventPublisher.TryPublish(grainEvent); } catch (Exception) { EventsDiscarded.Increment(); } } }
public async Task <object> Invoke(MethodInfo methodInfo, InvokeMethodRequest request, IGrainMethodInvoker invoker) { if (methodInfo.Name == nameof(One) && methodInfo.GetParameters().Length == 0) { if (request.MethodId != 14142) { throw new Exception($"Method id of 'One' must be 14142, not {request.MethodId}."); } return("intercepted one with no args"); } var result = await invoker.Invoke(this, request); // To prove that the MethodInfo is from the implementation and not the interface, // we check for this attribute which is only present on the implementation. This could be // done in a simpler fashion, but this demonstrates a potential usage scenario. var shouldMessWithResult = methodInfo.GetCustomAttribute <MessWithResultAttribute>(); var resultString = result as string; if (shouldMessWithResult != null && resultString != null) { result = string.Concat(resultString.Reverse()); } return(result); }
private Task <object> InvokeWithInterceptors(IAddressable target, InvokeMethodRequest request, IGrainMethodInvoker invoker) { // If the target has a grain-level interceptor or there is a silo-level interceptor, intercept the // call. var siloWideInterceptor = this.CurrentStreamProviderRuntime.GetInvokeInterceptor(); var grainWithInterceptor = target as IGrainInvokeInterceptor; // Silo-wide interceptors do not operate on system targets. var hasSiloWideInterceptor = siloWideInterceptor != null && target is IGrain; var hasGrainLevelInterceptor = grainWithInterceptor != null; if (!hasGrainLevelInterceptor && !hasSiloWideInterceptor) { // The call is not intercepted at either the silo or the grain level, so call the invoker // directly. return(invoker.Invoke(target, request)); } // If the request is intended for an extension object, use that as the implementation type, otherwise use // the target object. Type implementationType; var extensionMap = invoker as IGrainExtensionMap; IGrainExtension extension; if (extensionMap != null && extensionMap.TryGetExtension(request.InterfaceId, out extension)) { implementationType = extension.GetType(); } else { implementationType = target.GetType(); } // Get an invoker which delegates to the grain's IGrainInvocationInterceptor implementation. // If the grain does not implement IGrainInvocationInterceptor, then the invoker simply delegates // calls to the provided invoker. var interceptedMethodInvoker = interceptedMethodInvokerCache.GetOrCreate( implementationType, request.InterfaceId, invoker); var methodInfo = interceptedMethodInvoker.GetMethodInfo(request.MethodId); if (hasSiloWideInterceptor) { // There is a silo-level interceptor and possibly a grain-level interceptor. // As a minor optimization, only pass the intercepted invoker if there is a grain-level // interceptor. return(siloWideInterceptor( methodInfo, request, (IGrain)target, hasGrainLevelInterceptor ? interceptedMethodInvoker : invoker)); } // The grain has an invoke method, but there is no silo-wide interceptor. return(grainWithInterceptor.Invoke(methodInfo, request, invoker)); }
public Task <object> Invoke(MethodInfo methodInfo, InvokeMethodRequest request, IGrainMethodInvoker invoker) { if (methodInfo.Name == nameof(GetInputAsString)) { return(Task.FromResult <object>($"Hah! You wanted {request.Arguments[0]}, but you got me!")); } return(invoker.Invoke(this, request)); }
public async Task <object> Invoke(MethodInfo method, InvokeMethodRequest request, IGrainMethodInvoker invoker) { try { return(await invoker.Invoke(this, request)); } catch (Exception e) { PrettyConsole.Line("Exception in interceptor"); DeactivateOnIdle(); throw; } }
public async Task <object> Invoke(MethodInfo methodInfo, InvokeMethodRequest request, IGrainMethodInvoker invoker) { var initialLastStreamValue = this.lastStreamValue; var result = await invoker.Invoke(this, request); // If the last stream value changed after the invoke, then the stream must have produced a value, double // it for testing purposes. if (this.lastStreamValue != initialLastStreamValue) { this.lastStreamValue *= 2; } return(result); }
public async Task<object> Invoke(MethodInfo methodInfo, InvokeMethodRequest request, IGrainMethodInvoker invoker) { var initialLastStreamValue = this.lastStreamValue; var result = await invoker.Invoke(this, request); // If the last stream value changed after the invoke, then the stream must have produced a value, double // it for testing purposes. if (this.lastStreamValue != initialLastStreamValue) { this.lastStreamValue *= 2; } return result; }
private async Task <object> IncomingCallInterceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain target, IGrainMethodInvoker invoker) { if (targetMethod == null) { throw new ArgumentNullException(nameof(targetMethod)); } var declaringNameSpace = targetMethod.DeclaringType?.Namespace; // Do not intercept Orleans grains or other grains which should not be included in statistics. if (targetMethod.DeclaringType.GetCustomAttribute <ExcludeGrainFromStatisticsAttribute>() != null || declaringNameSpace?.StartsWith("Orleans") == true) { return(await invoker.Invoke(target, request)); } RequestTimings.GetOrCreate(); // Ensure request timings is created here and not in the grain call. RequestTimings.Current.Request.Start(); Exception ex = null; try { RejectRequestIfLateOrOverloaded(); return(await invoker.Invoke(target, request)); } catch (Exception e) { ex = e; throw; } finally { RequestTimings.Current.Request.Stop(); PublishEvent(targetMethod, target, ex); } }
/// <inheritdoc /> public async Task Invoke() { try { // Execute each stage in the pipeline. Each successive call to this method will invoke the next stage. // Stages which are not implemented (eg, because the user has not specified an interceptor) are skipped. var numFilters = filters.Count; if (stage < numFilters) { // Call each of the specified interceptors. var systemWideFilter = this.filters[stage]; stage++; await systemWideFilter.Invoke(this); return; } if (stage == numFilters) { stage++; // Grain-level invoker, if present. if (this.Grain is IIncomingGrainCallFilter grainClassLevelFilter) { await grainClassLevelFilter.Invoke(this); return; } } if (stage == numFilters + 1) { // Finally call the root-level invoker. stage++; this.Result = await rootInvoker.Invoke(this.grainContext, this.request); return; } } finally { stage--; } // If this method has been called more than the expected number of times, that is invalid. ThrowInvalidCall(); }
// capture stats async Task <object> InvokeInterceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain grain, IGrainMethodInvoker invoker) { // round down to nearest 10 seconds to group results var grainName = grain.GetType().FullName; var stopwatch = Stopwatch.StartNew(); // invoke grain object result = null; if (this.innerInterceptor != null) { result = await this.innerInterceptor(targetMethod, request, grain, invoker); } else { result = await invoker.Invoke(grain, request); } stopwatch.Stop(); var elapsedMs = (double)stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond; var key = $"{grainName}.{targetMethod?.Name ?? "Unknown"}"; grainTrace.AddOrUpdate(key, _ => { return(new GrainTraceEntry { Count = 1, SiloAddress = siloAddress, ElapsedTime = elapsedMs, Grain = grainName, Method = targetMethod?.Name ?? "Unknown", Period = DateTime.UtcNow }); }, (_, last) => { last.Count += 1; last.ElapsedTime += elapsedMs; return(last); }); return(result); }
// capture stats async Task<object> InvokeInterceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain grain, IGrainMethodInvoker invoker) { // round down to nearest 10 seconds to group results var grainName = grain.GetType().FullName; var stopwatch = Stopwatch.StartNew(); // invoke grain object result = null; if (this.innerInterceptor != null) { result = await this.innerInterceptor(targetMethod, request, grain, invoker); } else { result = await invoker.Invoke(grain, request); } stopwatch.Stop(); var elapsedMs = (double)stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond; var key = $"{grainName}.{targetMethod?.Name ?? "Unknown"}"; grainTrace.AddOrUpdate(key, _ => { return new GrainTraceEntry { Count = 1, SiloAddress = siloAddress, ElapsedTime = elapsedMs, Grain = grainName, Method = targetMethod?.Name ?? "Unknown", Period = DateTime.UtcNow }; }, (_, last) => { last.Count += 1; last.ElapsedTime += elapsedMs; return last; }); return result; }
public async Task<object> Invoke(MethodInfo methodInfo, InvokeMethodRequest request, IGrainMethodInvoker invoker) { if (methodInfo.Name == "One" && methodInfo.GetParameters().Length == 0) { return "intercepted one with no args"; } var result = await invoker.Invoke(this, request); // To prove that the MethodInfo is from the implementation and not the interface, // we check for this attribute which is only present on the implementation. This could be // done in a simpler fashion, but this demonstrates a potential usage scenario. var shouldMessWithResult = methodInfo.GetCustomAttribute<MessWithResultAttribute>(); var resultString = result as string; if (shouldMessWithResult != null && resultString !=null) { result = string.Concat(resultString.Reverse()); } return result; }
public async Task Invoke(HttpContext context) { try { var route = this.ResplveRouteData(context); var grain = this._grainBuilder.GetGrain(route); var result = await _grainInvoker.Invoke(grain, route); context.Response.StatusCode = 200; context.Response.ContentType = "application/json"; using (var writer = new StreamWriter(context.Response.Body)) { _serializer.Serialize(writer, result); await writer.FlushAsync(); } } catch (Exception ex) { this._logger.LogError(ex, "Request url " + context.Request.Host.ToString()); throw ex; } }
public async Task <object> Invoke(MethodInfo method, InvokeMethodRequest request, IGrainMethodInvoker invoker) { var value = RequestContext.Get(Key) as string; if (value != null) { RequestContext.Set(Key, value + '5'); } if (string.Equals(method?.Name, nameof(CallWithBadInterceptors)) && (bool)request.Arguments[0]) { await context.Invoke(); } var result = await invoker.Invoke(this, request); if (string.Equals(method?.Name, nameof(CallWithBadInterceptors)) && (bool)request.Arguments[1]) { await context.Invoke(); } return(result); }
/// <summary> /// Handles the an InvokeMethodRequest message on given target. /// </summary> /// <remarks> /// Options when we receive a InvokeMethodRequest /// ---------------------------------------------- /// 1) Intercepted RPC /// 2) Request to start a reactive computation for this method invocation /// 3) KeepAlive request of the reactive computation for this method invocation /// 4) Normal Application RPC /// 5) System RPC /// </remarks> /// <returns></returns> internal async Task Invoke(IAddressable target, IInvokable invokable, Message message) { try { // Don't process messages that have already timed out if (message.IsExpired) { message.DropExpiredMessage(MessagingStatisticsGroup.Phase.Invoke); return; } RequestContext.Import(message.RequestContextData); if (Config.Globals.PerformDeadlockDetection && !message.TargetGrain.IsSystemTarget) { UpdateDeadlockInfoInRequestContext(new RequestInvocationHistory(message)); // RequestContext is automatically saved in the msg upon send and propagated to the next hop // in RuntimeClient.CreateMessage -> RequestContext.ExportToMessage(message); } object resultObject; try { var request = (InvokeMethodRequest)message.BodyObject; if (request.Arguments != null) { CancellationSourcesExtension.RegisterCancellationTokens(target, request, logger); } // Get the invoker for this invocation IGrainMethodInvoker invoker = GetGrainMethodInvoker(target, invokable, message, request); // Check whether this call should be intercepted var siloWideInterceptor = SiloProviderRuntime.Instance.GetInvokeInterceptor(); var grainWithInterceptor = target as IGrainInvokeInterceptor; // Silo-wide interceptors do not operate on system targets. var hasSiloWideInterceptor = siloWideInterceptor != null && target is IGrain; var hasGrainLevelInterceptor = grainWithInterceptor != null; // Normal Application Call = an application call made from grain to grain or from client to grain. // Some system-related calls such as the IReminderTable are encoded as Application messages, therefore we needed this check. var NormalApplicationCall = message.Category == Message.Categories.Application && message.TargetGrain.IsGrain && (message.SendingGrain.IsGrain || message.SendingGrain.IsClient); // 1) If the target has a grain-level interceptor or there is a silo-level interceptor, intercept the // call. if (hasGrainLevelInterceptor || hasSiloWideInterceptor) { resultObject = await InvokeWithInterceptors(target, request, invoker, hasSiloWideInterceptor, siloWideInterceptor, hasGrainLevelInterceptor, grainWithInterceptor); } else if (NormalApplicationCall) { // 2) Request to start a reactive computation for this method invocation if (message.IsRcExecute()) { HandleReactiveComputationExecute(target, request, message, invoker); return; // Does not expect a return (OneWay Message) } // 3) Refresh Reactive Computation Subscription else if (message.IsRcKeepAlive()) { HandleReactiveComputationExecute(target, request, message, invoker, true); return; // Does not expect a return (OneWay Message) } // 4) Normal application RPC call else { // Invoke the method resultObject = await invoker.Invoke(target, request); // Check if there are any active reactive computations in this grain that require recomputation after this call InsideRcManager.RecomputeSummaries(); } } // 5) System RPC call else { resultObject = await invoker.Invoke(target, request); } } catch (Exception exc1) { if (invokeExceptionLogger.IsVerbose || message.Direction == Message.Directions.OneWay) { invokeExceptionLogger.Warn(ErrorCode.GrainInvokeException, "Exception during Grain method call of message: " + message, exc1); } if (message.Direction != Message.Directions.OneWay) { SafeSendExceptionResponse(message, exc1); } return; } if (message.Direction == Message.Directions.OneWay) { return; } SafeSendResponse(message, resultObject); } catch (Exception exc2) { logger.Warn(ErrorCode.Runtime_Error_100329, "Exception during Invoke of message: " + message, exc2); if (message.Direction != Message.Directions.OneWay) { SafeSendExceptionResponse(message, exc2); } } }
// capture stats async Task <object> InvokeInterceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain grain, IGrainMethodInvoker invoker) { var grainName = grain.GetType().FullName; var stopwatch = Stopwatch.StartNew(); // invoke grain object result = null; var isException = false; try { if (this.innerInterceptor != null) { result = await this.innerInterceptor(targetMethod, request, grain, invoker).ConfigureAwait(false); } else { result = await invoker.Invoke(grain, request).ConfigureAwait(false); } } catch (Exception) { isException = true; throw; } finally { try { stopwatch.Stop(); var elapsedMs = (double)stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond; var key = string.Format("{0}.{1}", grainName, formatMethodName(targetMethod, request, grain)); grainTrace.AddOrUpdate(key, _ => { return(new GrainTraceEntry { Count = 1, ExceptionCount = (isException ? 1 : 0), SiloAddress = siloAddress, ElapsedTime = elapsedMs, Grain = grainName, Method = formatMethodName(targetMethod, request, grain), Period = DateTime.UtcNow }); }, (_, last) => { last.Count += 1; last.ElapsedTime += elapsedMs; if (isException) { last.ExceptionCount += 1; } return(last); }); } catch (Exception ex) { this.Logger.Error(100002, "error recording results for grain", ex); } } return(result); }
private async Task <object> Interceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain target, IGrainMethodInvoker invoker) { if (targetMethod == null) { throw new ArgumentNullException(nameof(targetMethod)); } var declaringNameSpace = targetMethod.DeclaringType?.Namespace; // Do not intercept Orleans grains or other grains which should not be included in statistics. if (targetMethod.DeclaringType.GetCustomAttribute <ExcludeGrainFromStatisticsAttribute>() != null || declaringNameSpace?.StartsWith("Orleans") == true) { return(await invoker.Invoke(target, request)); } RequestTimings.GetOrCreate(); // Ensure request timings is created here and not in the grain call. RequestTimings.Current.Request.Start(); Exception ex = null; try { return(await invoker.Invoke(target, request)); } catch (Exception e) { ex = e; throw; } finally { RequestTimings.Current.Request.Stop(); var grainEvent = EventPublisher.CreateEvent(); if (target.GetPrimaryKeyString() != null) { grainEvent.GrainKeyString = target.GetPrimaryKeyString(); } else if (target.IsPrimaryKeyBasedOnLong()) { grainEvent.GrainKeyLong = target.GetPrimaryKeyLong(out var keyExt); grainEvent.GrainKeyExtention = keyExt; } else { grainEvent.GrainKeyGuid = target.GetPrimaryKey(out var keyExt); grainEvent.GrainKeyExtention = keyExt; } if (target is Grain grainTarget) { grainEvent.SiloAddress = grainTarget.RuntimeIdentity; } grainEvent.SiloDeploymentId = ConfigBuilder.ClusterConfiguration.Globals.DeploymentId; grainEvent.TargetType = targetMethod.DeclaringType?.FullName; grainEvent.TargetMethod = targetMethod.Name; grainEvent.Exception = ex; grainEvent.ErrCode = ex != null ? null : (int?)0; try { EventPublisher.TryPublish(grainEvent); } catch (Exception) { EventsDiscarded.Increment(); } } }
private Task<object> InvokeWithInterceptors(IAddressable target, InvokeMethodRequest request, IGrainMethodInvoker invoker) { // If the target has a grain-level interceptor or there is a silo-level interceptor, intercept the // call. var siloWideInterceptor = SiloProviderRuntime.Instance.GetInvokeInterceptor(); var grainWithInterceptor = target as IGrainInvokeInterceptor; // Silo-wide interceptors do not operate on system targets. var hasSiloWideInterceptor = siloWideInterceptor != null && target is IGrain; var hasGrainLevelInterceptor = grainWithInterceptor != null; if (!hasGrainLevelInterceptor && !hasSiloWideInterceptor) { // The call is not intercepted at either the silo or the grain level, so call the invoker // directly. return invoker.Invoke(target, request); } // Get an invoker which delegates to the grain's IGrainInvocationInterceptor implementation. // If the grain does not implement IGrainInvocationInterceptor, then the invoker simply delegates // calls to the provided invoker. var interceptedMethodInvoker = interceptedMethodInvokerCache.GetOrCreate( target.GetType(), request.InterfaceId, invoker); var methodInfo = interceptedMethodInvoker.GetMethodInfo(request.MethodId); if (hasSiloWideInterceptor) { // There is a silo-level interceptor and possibly a grain-level interceptor. // As a minor optimization, only pass the intercepted invoker if there is a grain-level // interceptor. return siloWideInterceptor( methodInfo, request, (IGrain)target, hasGrainLevelInterceptor ? interceptedMethodInvoker : invoker); } // The grain has an invoke method, but there is no silo-wide interceptor. return grainWithInterceptor.Invoke(methodInfo, request, invoker); }
async Task <object> SiloInterceptor(MethodInfo method, InvokeMethodRequest request, IGrain grain, IGrainMethodInvoker invoker) { try { object result = PreviousInterceptor != null ? await PreviousInterceptor(method, request, grain, invoker) : await invoker.Invoke(grain, request); //if (PreviousInterceptor != null) // result = await PreviousInterceptor(method, request, grain, invoker); //// Invoke the request and return the result back to the caller. //var result = await invoker.Invoke(grain, request); if (Configuration.TrackMethodGrainCalls) { // Would be nice if we could figure out if this is a local or remote call, // and perhaps caller / calling silo... Unless I've got something backwards logger.IncrementMetric($"GrainMethodCall:{grain.GetType().Name}:{method.Name}"); } return(result); } catch (TimeoutException ex) // Not sure if this is going to be an innerException here or if everything gets unrolled... Fingers crossed for now! { if (Configuration.TrackExceptionCounters) { logger.IncrementMetric($"GrainInvokeTimeout:{grain.GetType().Name}:{method.Name}"); } if (Configuration.LogExceptions) { logger.TrackException(ex, new Dictionary <string, string> { { "GrainType", grain.GetType().Name }, { "MethodName", method.Name }, }); } throw; } catch (Exception ex) { if (Configuration.TrackExceptionCounters) { logger.IncrementMetric($"GrainException:{grain.GetType().Name}:{method.Name}"); } if (Configuration.LogExceptions) { logger.TrackException(ex, new Dictionary <string, string> { { "GrainType", grain.GetType().Name }, { "MethodName", method.Name }, }); } throw; } }
// capture stats async Task<object> InvokeInterceptor(MethodInfo targetMethod, InvokeMethodRequest request, IGrain grain, IGrainMethodInvoker invoker) { var grainName = grain.GetType().FullName; var stopwatch = Stopwatch.StartNew(); // invoke grain object result = null; var isException = false; try { if (this.innerInterceptor != null) { result = await this.innerInterceptor(targetMethod, request, grain, invoker); } else { result = await invoker.Invoke(grain, request); } } catch (Exception ex) { isException = true; throw; } finally { try { stopwatch.Stop(); var elapsedMs = (double)stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond; var key = string.Format("{0}.{1}", grainName, targetMethod?.Name ?? "Unknown"); grainTrace.AddOrUpdate(key, _ => { return new GrainTraceEntry { Count = 1, ExceptionCount = (isException ? 1 : 0), SiloAddress = siloAddress, ElapsedTime = elapsedMs, Grain = grainName , Method = targetMethod?.Name ?? "Unknown", Period = DateTime.UtcNow }; }, (_, last) => { last.Count += 1; last.ElapsedTime += elapsedMs; if (isException) last.ExceptionCount += 1; return last; }); } catch (Exception ex) { this.Logger.Error(100002, "error recording results for grain", ex); } } return result; }
public async Task Invoke(DownstreamContext context) { var routeResponse = this._routeValuesBuilder.Build(context); if (routeResponse.IsError) { Logger.LogDebug("IRouteValuesBuilder Parsing Route Values errors"); SetPipelineError(context, routeResponse.Errors); return; } //Olreans interface authorization verification var authorised = this._authorisation.Authorise(context.HttpContext.User, routeResponse.Data); if (authorised.IsError) { _logger.LogWarning("error orleas authorising user scopes"); SetPipelineError(context, authorised.Errors); return; } var clientBuilderResponse = _clusterClientBuilder.Build(routeResponse.Data, context); if (clientBuilderResponse.IsError) { Logger.LogDebug("IClusterClientBuilder Building Cluster Client and connecting Orleans error"); SetPipelineError(context, routeResponse.Errors); return; } //Get a Grain instance var grainResponse = this._grainReference.GetGrainReference(routeResponse.Data); if (grainResponse.IsError) { Logger.LogDebug("IGrainReference Get a Orleas Grain instance error"); SetPipelineError(context, routeResponse.Errors); return; } try { //Orleans injects the DownstreamContext into the RequestContext when requested this._config.RequestContextInjection?.Invoke(context); } catch (Exception ex) { Logger.LogError("Orleans injects the DownstreamContext into the RequestContext when requested error", ex); SetPipelineError(context, new UnknownError("Orleans injects the DownstreamContext into the RequestContext when requested error")); return; } //Grain Dynamic request try { var resultResponse = await _grainInvoker.Invoke(grainResponse.Data, routeResponse.Data); if (resultResponse.IsError) { Logger.LogDebug("IGrainMethodInvoker Grain Dynamic request error"); SetPipelineError(context, resultResponse.Errors); return; } Logger.LogDebug("setting http response message"); context.HttpContext.Response.ContentType = resultResponse.Data.Content.ContentType; context.DownstreamResponse = new DownstreamResponse(resultResponse.Data.Content, resultResponse.Data.StatusCode, resultResponse.Data.Headers, ""); } catch (Exception ex) { Logger.LogError($"Request Orleans Silo exception;Uri:{context.DownstreamRequest.ToUri()}", ex); throw new OrleansRequestException("Request Orleans Silo exception "); } }
/// <inheritdoc /> public async Task Invoke() { // Execute each stage in the pipeline. Each successive call to this method will invoke the next stage. // Stages which are not implemented (eg, because the user has not specified an interceptor) are skipped. var numFilters = filters.Count; if (stage < numFilters) { // Call each of the specified interceptors. var systemWideFilter = this.filters[stage]; stage++; await systemWideFilter.Invoke(this); return; } if (stage == numFilters) { stage++; // Deprecated silo-level invoker, if present. var grain = this.Grain as IGrain; if (grain != null && deprecatedInvokeInterceptor != null) { this.Result = await deprecatedInvokeInterceptor.Invoke(this.Method, this.request, grain, this); return; } } if (stage == numFilters + 1) { stage++; // Grain-level invoker, if present. var grainClassLevelFilter = this.Grain as IGrainCallFilter; if (grainClassLevelFilter != null) { await grainClassLevelFilter.Invoke(this); return; } } #pragma warning disable 618 if (stage == numFilters + 2) { stage++; // Deprecated grain-level invoker, if present. var intercepted = this.Grain as IGrainInvokeInterceptor; if (intercepted != null) { this.Result = await intercepted.Invoke(this.Method, this.request, this); return; } } #pragma warning restore 618 if (stage == numFilters + 3) { // Finally call the root-level invoker. stage++; this.Result = await rootInvoker.Invoke(this.Grain, this.request); return; } // If this method has been called more than the expected number of times, that is invalid. ThrowInvalidCall(); }