static AuthorizationBehavior CreateAuthorizationBehavior(DispatchRuntime dispatch) { AuthorizationBehavior behavior = new AuthorizationBehavior(); behavior.externalAuthorizationPolicies = dispatch.ExternalAuthorizationPolicies; behavior.serviceAuthorizationManager = dispatch.ServiceAuthorizationManager; return(behavior); }
internal ImmutableDispatchRuntime(DispatchRuntime dispatch) { _authenticationBehavior = AuthenticationBehavior.TryCreate(dispatch); _authorizationBehavior = AuthorizationBehavior.TryCreate(dispatch); _concurrency = new ConcurrencyBehavior(dispatch); _error = new ErrorBehavior(dispatch.ChannelDispatcher); _enableFaults = dispatch.EnableFaults; _inputSessionShutdownHandlers = EmptyArray <IInputSessionShutdown> .ToArray(dispatch.InputSessionShutdownHandlers); InstanceBehavior = new InstanceBehavior(dispatch, this); _isOnServer = dispatch.IsOnServer; _manualAddressing = dispatch.ManualAddressing; _messageInspectors = EmptyArray <IDispatchMessageInspector> .ToArray(dispatch.MessageInspectors); _securityImpersonation = SecurityImpersonationBehavior.CreateIfNecessary(dispatch); RequireClaimsPrincipalOnOperationContext = dispatch.RequireClaimsPrincipalOnOperationContext; _impersonateOnSerializingReply = dispatch.ImpersonateOnSerializingReply; _terminate = TerminatingOperationBehavior.CreateIfNecessary(dispatch); _thread = new ThreadBehavior(dispatch); ValidateMustUnderstand = dispatch.ValidateMustUnderstand; ParameterInspectorCorrelationOffset = (dispatch.MessageInspectors.Count + dispatch.MaxCallContextInitializers); _correlationCount = ParameterInspectorCorrelationOffset + dispatch.MaxParameterInspectors; DispatchOperationRuntime unhandled = new DispatchOperationRuntime(dispatch.UnhandledDispatchOperation, this); if (dispatch.OperationSelector == null) { ActionDemuxer demuxer = new ActionDemuxer(); for (int i = 0; i < dispatch.Operations.Count; i++) { DispatchOperation operation = dispatch.Operations[i]; DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this); demuxer.Add(operation.Action, operationRuntime); } demuxer.SetUnhandled(unhandled); _demuxer = demuxer; } else { CustomDemuxer demuxer = new CustomDemuxer(dispatch.OperationSelector); for (int i = 0; i < dispatch.Operations.Count; i++) { DispatchOperation operation = dispatch.Operations[i]; DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this); demuxer.Add(operation.Name, operationRuntime); } demuxer.SetUnhandled(unhandled); _demuxer = demuxer; } _processMessageNonCleanupError = new MessageRpcErrorHandler(ProcessMessageNonCleanupError); _processMessageCleanupError = new MessageRpcErrorHandler(ProcessMessageCleanupError); }
private static AuthorizationBehavior CreateAuthorizationBehavior(DispatchRuntime dispatch) { AuthorizationBehavior behavior = new AuthorizationBehavior { _externalAuthorizationPolicies = dispatch.ExternalAuthorizationPolicies, _serviceAuthorizationManager = dispatch.ServiceAuthorizationManager }; return(behavior); }
private Exception ConvertExceptionForFaultedTask(Task task) { var exception = task.Exception.InnerException; //bool callFaulted; if (exception is SecurityException) { DiagnosticUtility.TraceHandledException(exception, TraceEventType.Warning); exception = DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException()); } else if (exception is FaultException) { //callFaulted = true; } else { TraceUtility.TraceUserCodeException(exception, TaskMethod); } //AsyncMethodInvoker.StopOperationInvokeTrace(true, callFaulted, TaskMethod.Name); //AsyncMethodInvoker.StopOperationInvokePerformanceCounters(true, callFaulted, TaskMethod.Name); return(exception); }
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result) { if (instance == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoServiceObject)); } object returnVal = null; //bool callFailed = true; //bool callFaulted = false; //ServiceModelActivity activity = null; //Activity boundOperation = null; try { //AsyncMethodInvoker.GetActivityInfo(ref activity, ref boundOperation); Task <Tuple <object, object[]> > invokeTask = result as Task <Tuple <object, object[]> >; if (invokeTask == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.SFxInvalidCallbackIAsyncResult); } AggregateException ae = null; Tuple <object, object[]> tuple = null; Task task = null; if (invokeTask.IsFaulted) { Fx.Assert(invokeTask.Exception != null, "Task.IsFaulted guarantees non-null exception."); ae = invokeTask.Exception; } else { Fx.Assert(invokeTask.IsCompleted, "Task.Result is expected to be completed"); tuple = invokeTask.Result; task = tuple.Item1 as Task; if (task == null) { outputs = tuple.Item2; return(null); } if (task.IsFaulted) { Fx.Assert(task.Exception != null, "Task.IsFaulted guarantees non-null exception."); ae = task.Exception; } } if (ae != null && ae.InnerException != null) { if (ae.InnerException is FaultException) { // If invokeTask.IsFaulted we produce the 'callFaulted' behavior below. // Any other exception will retain 'callFailed' behavior. //callFaulted = true; //callFailed = false; } if (ae.InnerException is SecurityException) { DiagnosticUtility.TraceHandledException(ae.InnerException, TraceEventType.Warning); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException()); } invokeTask.GetAwaiter().GetResult(); } // Task cancellation without an exception indicates failure but we have no // additional information to provide. Accessing Task.Result will throw a // TaskCanceledException. For consistency between void Tasks and Task<T>, // we detect and throw here. if (task.IsCanceled) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TaskCanceledException(task)); } outputs = tuple.Item2; returnVal = isGenericTask ? taskTResultGetMethod.Invoke(task, Type.EmptyTypes) : null; //callFailed = false; return(returnVal); } finally { //if (boundOperation != null) //{ // ((IDisposable)boundOperation).Dispose(); //} //ServiceModelActivity.Stop(activity); //AsyncMethodInvoker.StopOperationInvokeTrace(callFailed, callFaulted, TaskMethod.Name); //AsyncMethodInvoker.StopOperationInvokePerformanceCounters(callFailed, callFaulted, TaskMethod.Name); } }
private async Task <Tuple <object, object[]> > InvokeAsync(object instance, object[] inputs) { EnsureIsInitialized(); if (instance == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoServiceObject)); } if (inputs == null) { if (inputParameterCount > 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceNull, inputParameterCount))); } } else if (inputs.Length != inputParameterCount) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceInvalid, inputParameterCount, inputs.Length))); } object[] outputs = EmptyArray <object> .Allocate(outputParameterCount); //AsyncMethodInvoker.StartOperationInvokePerformanceCounters(taskMethod.Name); object returnValue; bool callFailed = true; bool callFaulted = false; //ServiceModelActivity activity = null; //Activity boundActivity = null; try { //AsyncMethodInvoker.CreateActivityInfo(ref activity, ref boundActivity); //AsyncMethodInvoker.StartOperationInvokeTrace(taskMethod.Name); //if (DiagnosticUtility.ShouldUseActivity) //{ // string activityName = SR.Format(SR.ActivityExecuteMethod, taskMethod.DeclaringType.FullName, taskMethod.Name); // ServiceModelActivity.Start(activity, activityName, ActivityType.ExecuteUserCode); //} returnValue = invokeDelegate(instance, inputs, outputs); if (returnValue == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("Task"); } var returnValueTask = returnValue as Task; if (returnValueTask != null) { // Only return once the task has completed await returnValueTask; } callFailed = false; return(Tuple.Create(returnValue, outputs)); } catch (SecurityException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException()); } catch (FaultException) { callFaulted = true; throw; } catch (Exception e) { TraceUtility.TraceUserCodeException(e, taskMethod); throw; } finally { //if (boundActivity != null) //{ // ((IDisposable)boundActivity).Dispose(); //} //ServiceModelActivity.Stop(activity); // Any exception above means InvokeEnd will not be called, so complete it here. if (callFailed || callFaulted) { //AsyncMethodInvoker.StopOperationInvokeTrace(callFailed, callFaulted, TaskMethod.Name); //AsyncMethodInvoker.StopOperationInvokePerformanceCounters(callFailed, callFaulted, TaskMethod.Name); } } }
public async ValueTask <(object returnValue, object[] outputs)> InvokeAsync(object instance, object[] inputs) { if (instance == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoServiceObject)); } object returnVal = null; object[] outputs = null; //bool callFailed = true; //bool callFaulted = false; //ServiceModelActivity activity = null; //Activity boundOperation = null; try { //AsyncMethodInvoker.GetActivityInfo(ref activity, ref boundOperation); // This code would benefith from a rewrite to call TaskHelpers.ToApmEnd<Tuple<object, object[]>> // When doing so make sure there is enought test coverage se PR comment at link below for a good starting point // https://github.com/CoreWCF/CoreWCF/pull/54/files/8db6ff9ad6940a1056363defd1f6449adee56e1a#r333826132 var tupleResult = await InvokeAsyncCore(instance, inputs); AggregateException ae = null; Task task = null; task = tupleResult.returnValue as Task; if (task == null) { outputs = tupleResult.outputs; return(null, outputs); } if (task.IsFaulted) { Fx.Assert(task.Exception != null, "Task.IsFaulted guarantees non-null exception."); ae = task.Exception; } if (ae != null && ae.InnerException != null) { if (ae.InnerException is FaultException) { // If invokeTask.IsFaulted we produce the 'callFaulted' behavior below. // Any other exception will retain 'callFailed' behavior. //callFaulted = true; //callFailed = false; } if (ae.InnerException is SecurityException) { DiagnosticUtility.TraceHandledException(ae.InnerException, TraceEventType.Warning); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException()); } // Rethrow inner exception as is ExceptionDispatchInfo.Capture(ae.InnerException).Throw(); } // Task cancellation without an exception indicates failure but we have no // additional information to provide. Accessing Task.Result will throw a // TaskCanceledException. For consistency between void Tasks and Task<T>, // we detect and throw here. if (task.IsCanceled) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TaskCanceledException(task)); } outputs = tupleResult.outputs; returnVal = _isGenericTask ? _taskTResultGetMethod.Invoke(task, Type.EmptyTypes) : null; //callFailed = false; return(returnVal, outputs); } finally { //if (boundOperation != null) //{ // ((IDisposable)boundOperation).Dispose(); //} //ServiceModelActivity.Stop(activity); //AsyncMethodInvoker.StopOperationInvokeTrace(callFailed, callFaulted, TaskMethod.Name); //AsyncMethodInvoker.StopOperationInvokePerformanceCounters(callFailed, callFaulted, TaskMethod.Name); } }