public void GotReply(Message reply)
{
bool flag;
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? TraceUtility.ExtractActivity(reply) : null;
using (ServiceModelActivity.BoundOperation(activity))
{
lock (this.parent.ThisLock)
{
bool isDone = this.IsDone;
this.reply = reply;
this.gotReply = true;
flag = !isDone && this.IsDone;
}
if ((activity != null) && DiagnosticUtility.ShouldUseActivity)
{
TraceUtility.SetActivity(reply, this.activity);
if ((DiagnosticUtility.ShouldUseActivity && (this.activity != null)) && (FxTrace.Trace != null))
{
FxTrace.Trace.TraceTransfer(this.activity.Id);
}
}
}
if (DiagnosticUtility.ShouldUseActivity && (activity != null))
{
activity.Stop();
}
if (flag)
{
this.Done(false);
}
}
internal static void GetActivityInfo(ref ServiceModelActivity activity, ref Activity boundOperation)
{
if (TraceUtility.MessageFlowTracingOnly)
{
if (null != OperationContext.Current)
{
Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
if (activityId != Guid.Empty)
{
DiagnosticTraceBase.ActivityId = activityId;
}
}
}
else if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
{
object activityInfo = TraceUtility.ExtractAsyncOperationContextActivity();
if (activityInfo != null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
activity = activityInfo as ServiceModelActivity;
boundOperation = ServiceModelActivity.BoundOperation(activity, true);
}
else if (TraceUtility.ShouldPropagateActivity)
{
if (activityInfo is Guid)
{
Guid activityId = (Guid)activityInfo;
boundOperation = Activity.CreateActivity(activityId);
}
}
}
}
}
internal void HttpContextReceived(HostedHttpRequestAsyncResult result)
{
using (DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.BoundOperation(base.Activity) : null)
{
using (this.CreateReceiveBytesActivity(result))
{
HttpChannelListener listener;
this.TraceConnectionInformation(result);
if (base.TryLookupUri(result.RequestUri, result.GetHttpMethod(), base.HostNameComparisonMode, out listener))
{
HostedHttpContext context = new HostedHttpContext(listener, result);
listener.HttpContextReceived(context, null);
}
else
{
if (DiagnosticUtility.ShouldTraceError)
{
TraceUtility.TraceEvent(TraceEventType.Error, 0x4000b, System.ServiceModel.Activation.SR.TraceCodeHttpChannelMessageReceiveFailed, new StringTraceRecord("IsRecycling", ServiceHostingEnvironment.IsRecycling.ToString(CultureInfo.CurrentCulture)), this, null);
}
if (ServiceHostingEnvironment.IsRecycling)
{
throw FxTrace.Exception.AsError(new EndpointNotFoundException(System.ServiceModel.Activation.SR.Hosting_ListenerNotFoundForActivationInRecycling(result.RequestUri.ToString())));
}
throw FxTrace.Exception.AsError(new EndpointNotFoundException(System.ServiceModel.Activation.SR.Hosting_ListenerNotFoundForActivation(result.RequestUri.ToString())));
}
}
}
}
// TChannel provides ContractDescription, attr/config|Config object [TChannel,name] provides Binding, provide Address explicitly
public ConfigurationDuplexChannelFactory(object callbackObject, string endpointConfigurationName, EndpointAddress remoteAddress, Configuration configuration)
: base(typeof(TChannel))
{
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct);
}
if (callbackObject == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackObject");
}
if (endpointConfigurationName == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
}
if (configuration == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("configuration");
}
this.CheckAndAssignCallbackInstance(callbackObject);
this.InitializeEndpoint(endpointConfigurationName, remoteAddress, configuration);
}
}
public IAsyncResult BeginAccept(AsyncCallback callback, object state)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
return(this.listener.BeginAccept(callback, state));
}
}
private bool ContinueReading(int bytesRead)
{
while (true)
{
if (bytesRead == 0)
{
break;
}
this.offset += bytesRead;
this.count -= bytesRead;
if (this.count <= 0)
{
break;
}
IAsyncResult asyncResult = this.inputStream.BeginRead(this.buffer.Array, this.offset, this.count, onRead, this);
if (!asyncResult.CompletedSynchronously)
{
return(false);
}
bytesRead = this.inputStream.EndRead(asyncResult);
}
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity(true) : null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity, System.ServiceModel.SR.GetString("ActivityProcessingMessage", new object[] { TraceUtility.RetrieveMessageNumber() }), ActivityType.ProcessMessage);
}
this.message = this.httpInput.DecodeBufferedMessage(new ArraySegment <byte>(this.buffer.Array, 0, this.offset), this.inputStream);
this.requestException = this.httpInput.ProcessHttpAddressing(this.message);
}
return(true);
}
private void GetActivityInfo(ref ServiceModelActivity activity, ref Activity boundOperation)
{
if (TraceUtility.MessageFlowTracingOnly)
{
if (OperationContext.Current != null)
{
Guid receivedActivityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
if (receivedActivityId != Guid.Empty)
{
DiagnosticTrace.ActivityId = receivedActivityId;
}
}
}
else if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
{
object obj2 = TraceUtility.ExtractAsyncOperationContextActivity();
if (obj2 != null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
activity = obj2 as ServiceModelActivity;
boundOperation = ServiceModelActivity.BoundOperation(activity, true);
}
else if (TraceUtility.ShouldPropagateActivity && (obj2 is Guid))
{
Guid activityId = (Guid)obj2;
boundOperation = Activity.CreateActivity(activityId);
}
}
}
}
public IConnection EndAccept(IAsyncResult result)
{
IConnection connection3;
using (ServiceModelActivity.BoundOperation(this.activity))
{
ServiceModelActivity activity = ServiceModelActivity.CreateActivity();
if ((activity != null) && (FxTrace.Trace != null))
{
FxTrace.Trace.TraceTransfer(activity.Id);
}
using (ServiceModelActivity.BoundOperation(activity))
{
ServiceModelActivity.Start(activity, System.ServiceModel.SR.GetString("ActivityReceiveBytes", new object[] { this.activity.Name }), ActivityType.ReceiveBytes);
IConnection connection = this.listener.EndAccept(result);
if (connection == null)
{
return(null);
}
TracingConnection connection2 = new TracingConnection(connection, activity);
connection3 = connection2;
}
}
return(connection3);
}
internal void ActivityStart(Uri uri)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
ServiceModelActivity.Start(this.activity, SR.GetString(SR.ActivityReceiveBytes, uri.ToString()), ActivityType.ReceiveBytes);
}
}
public override void EndWrite(IAsyncResult result)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
base.EndWrite(result);
}
}
internal void ActivityStart(Uri uri)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
ServiceModelActivity.Start(this.activity, System.ServiceModel.SR.GetString("ActivityReceiveBytes", new object[] { uri.ToString() }), ActivityType.ReceiveBytes);
}
}
internal void Close(TimeSpan timeout, Microsoft.ServiceBus.Channels.TransportChannelListener channelListener)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
using (Microsoft.ServiceBus.Diagnostics.Activity activity = ServiceModelActivity.BoundOperation(this.Activity))
{
this.Unregister(timeoutHelper.RemainingTime(), channelListener);
}
lock (this.ThisLock)
{
if (this.openCount <= 0)
{
throw Fx.AssertAndThrow("Invalid Open/Close state machine.");
}
Microsoft.ServiceBus.Channels.TransportManager transportManager = this;
transportManager.openCount = transportManager.openCount - 1;
if (this.openCount == 0)
{
using (Microsoft.ServiceBus.Diagnostics.Activity activity1 = ServiceModelActivity.BoundOperation(this.Activity, true))
{
this.OnClose(timeoutHelper.RemainingTime());
}
if (this.Activity != null)
{
this.Activity.Dispose();
}
}
}
}
public virtual TChannel CreateChannel(EndpointAddress address, Uri via)
{
TChannel local;
bool traceOpenAndClose = base.TraceOpenAndClose;
try
{
using (ServiceModelActivity activity = (DiagnosticUtility.ShouldUseActivity && base.TraceOpenAndClose) ? ServiceModelActivity.CreateBoundedActivity() : null)
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity, this.OpenActivityName, this.OpenActivityType);
base.TraceOpenAndClose = false;
}
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
if (base.HasDuplexOperations())
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxCreateNonDuplexChannel1", new object[] { base.Endpoint.Contract.Name })));
}
base.EnsureOpened();
local = (TChannel)this.ServiceChannelFactory.CreateChannel(typeof(TChannel), address, via);
}
}
finally
{
base.TraceOpenAndClose = traceOpenAndClose;
}
return(local);
}
private static void OnCloseComplete(IAsyncResult result)
{
if (result.CompletedSynchronously)
{
return;
}
RefcountedCommunicationObject.CloseAsyncResult asyncState = (RefcountedCommunicationObject.CloseAsyncResult)result.AsyncState;
using (Activity activity = ServiceModelActivity.BoundOperation(null))
{
Exception exception = null;
try
{
asyncState.HandleCloseComplete(result);
}
catch (Exception exception2)
{
Exception exception1 = exception2;
if (Fx.IsFatal(exception1))
{
throw;
}
exception = exception1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceWarning)
{
DiagnosticTrace diagnosticTrace = Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.DiagnosticTrace;
string traceCodeCommunicationObjectCloseFailed = Resources.TraceCodeCommunicationObjectCloseFailed;
object[] str = new object[] { asyncState.communicationObject.GetCommunicationObjectType().ToString() };
diagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.CommunicationObjectCloseFailed, Microsoft.ServiceBus.SR.GetString(traceCodeCommunicationObjectCloseFailed, str), null, null, asyncState);
}
asyncState.communicationObject.Abort();
}
asyncState.Complete(false, exception);
}
}
internal void ActivityStart(string name)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
ServiceModelActivity.Start(this.activity, SR.GetString(SR.ActivityReceiveBytes, name), ActivityType.ReceiveBytes);
}
}
public override AsyncCompletionResult BeginWrite(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, WaitCallback callback, object state)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
return(base.BeginWrite(buffer, offset, size, immediate, timeout, callback, state));
}
}
private void Cleanup(TransportChannelListener channelListener, TimeSpan timeout, bool aborting)
{
using (ServiceModelActivity.BoundOperation(this.Activity))
{
this.Unregister(channelListener);
}
lock (this.ThisLock)
{
if (this.openCount <= 0)
{
throw Fx.AssertAndThrow("Invalid Open/Close state machine.");
}
this.openCount--;
if (this.openCount == 0)
{
using (ServiceModelActivity.BoundOperation(this.Activity, true))
{
if (aborting)
{
this.OnAbort();
}
else
{
this.OnClose(timeout);
}
}
if (this.Activity != null)
{
this.Activity.Dispose();
}
}
}
}
public override void EndWrite()
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
base.EndWrite();
}
}
private void CreateActivityInfo(ref ServiceModelActivity activity, ref Activity boundActivity)
{
if (DiagnosticUtility.ShouldUseActivity)
{
activity = ServiceModelActivity.CreateAsyncActivity();
TraceUtility.UpdateAsyncOperationContextWithActivity(activity);
boundActivity = ServiceModelActivity.BoundOperation(activity, true);
}
else if (TraceUtility.MessageFlowTracingOnly)
{
Guid receivedActivityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
if (receivedActivityId != Guid.Empty)
{
DiagnosticTrace.ActivityId = receivedActivityId;
}
}
else if (TraceUtility.ShouldPropagateActivity)
{
Guid activityId = ActivityIdHeader.ExtractActivityId(OperationContext.Current.IncomingMessage);
if (activityId != Guid.Empty)
{
boundActivity = Activity.CreateActivity(activityId);
}
TraceUtility.UpdateAsyncOperationContextWithActivity(activityId);
}
}
public override void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
base.Write(buffer, offset, size, immediate, timeout, bufferManager);
}
}
IMethodReturnMessage InvokeChannel(IMethodCallMessage methodCall)
{
string activityName = null;
ActivityType activityType = ActivityType.Unknown;
if (DiagnosticUtility.ShouldUseActivity)
{
if (ServiceModelActivity.Current == null ||
ServiceModelActivity.Current.ActivityType != ActivityType.Close)
{
MethodData methodData = this.GetMethodData(methodCall);
if (methodData.MethodBase.DeclaringType == typeof(System.ServiceModel.ICommunicationObject) &&
methodData.MethodBase.Name.Equals("Close", StringComparison.Ordinal))
{
activityName = SR.GetString(SR.ActivityClose, this.serviceChannel.GetType().FullName);
activityType = ActivityType.Close;
}
}
}
using (ServiceModelActivity activity = string.IsNullOrEmpty(activityName) ? null : ServiceModelActivity.CreateBoundedActivity())
{
if (DiagnosticUtility.ShouldUseActivity)
{
ServiceModelActivity.Start(activity, activityName, activityType);
}
return(ExecuteMessage(this.serviceChannel, methodCall));
}
}
public override int Read(byte[] buffer, int offset, int size, TimeSpan timeout)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
return(base.Read(buffer, offset, size, timeout));
}
}
public void Listen()
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
this.listener.Listen();
}
}
public override object DuplicateAndClose(int targetProcessId)
{
using (ServiceModelActivity.BoundOperation(this.activity, true))
{
return(base.DuplicateAndClose(targetProcessId));
}
}
public IConnection EndAccept(IAsyncResult result)
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
ServiceModelActivity activity = ServiceModelActivity.CreateActivity();
if (activity != null)
{
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(activity.Id);
}
}
using (ServiceModelActivity.BoundOperation(activity))
{
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityReceiveBytes, this.activity.Name), ActivityType.ReceiveBytes);
IConnection innerConnection = this.listener.EndAccept(result);
if (innerConnection == null)
{
return(null);
}
TracingConnection retval = new TracingConnection(innerConnection, activity);
return(retval);
}
}
}
internal void ExecuteCallback()
{
using (ServiceModelActivity.BoundOperation(this.activity))
{
this.callback(state);
}
}
internal static void CreateActivityInfo(ref ServiceModelActivity activity, ref Activity boundActivity)
{
if (DiagnosticUtility.ShouldUseActivity)
{
activity = ServiceModelActivity.CreateAsyncActivity();
TraceUtility.UpdateAsyncOperationContextWithActivity(activity);
boundActivity = ServiceModelActivity.BoundOperation(activity, true);
}
else if (TraceUtility.MessageFlowTracingOnly)
{
Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
if (activityId != Guid.Empty)
{
DiagnosticTraceBase.ActivityId = activityId;
}
}
else if (TraceUtility.ShouldPropagateActivity)
{
//Message flow tracing only scenarios use a light-weight ActivityID management logic
Guid activityId = ActivityIdHeader.ExtractActivityId(OperationContext.Current.IncomingMessage);
if (activityId != Guid.Empty)
{
boundActivity = Activity.CreateActivity(activityId);
}
TraceUtility.UpdateAsyncOperationContextWithActivity(activityId);
}
}
public override void Shutdown(TimeSpan timeout)
{
using (ServiceModelActivity.BoundOperation(this.activity, true))
{
base.Shutdown(timeout);
}
}
internal void EnsureReceive()
{
using (ServiceModelActivity.BoundOperation(this.Activity))
{
ChannelHandler.Register(this.channelHandler);
}
}
private void Done(bool completedSynchronously)
{
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? TraceUtility.ExtractActivity(this.reply) : null;
using (ServiceModelActivity.BoundOperation(activity))
{
if (this.timer != null)
{
this.timer.Cancel();
this.timer = null;
}
lock (this.parent.ThisLock)
{
this.parent.RequestCompleting(this);
}
if (this.sendException != null)
{
base.Complete(completedSynchronously, this.sendException);
}
else if (this.timedOut)
{
base.Complete(completedSynchronously, this.parent.GetReceiveTimeoutException(this.timeout));
}
else
{
base.Complete(completedSynchronously);
}
}
}
