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);
}
}