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