public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType) { if (stream == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream")); } if (WcfEventSource.Instance.TextMessageDecodingStartIsEnabled()) { WcfEventSource.Instance.TextMessageDecodingStart(); } XmlReader reader = TakeStreamedReader(stream, GetEncodingFromContentType(contentType, _contentEncodingMap)); Message message = Message.CreateMessage(reader, maxSizeOfHeaders, _version); message.Properties.Encoder = this; if (WcfEventSource.Instance.StreamedMessageReadByEncoderIsEnabled()) { WcfEventSource.Instance.StreamedMessageReadByEncoder(EventTraceActivityHelper.TryExtractActivity(message, true)); } if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive); } return(message); }
public override bool Match(Message message) { if (message == null) { throw FxTrace.Exception.ArgumentNull("message"); } if (InnerFilter.Match(message)) { bool isMatch = ((message.Headers.ReplyTo == null) || (message.Headers.ReplyTo.IsAnonymous)); if (!isMatch && TD.DiscoveryMessageWithInvalidReplyToIsEnabled()) { EventTraceActivity eventTraceActivity = null; if (Fx.Trace.IsEtwProviderEnabled) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); } TD.DiscoveryMessageWithInvalidReplyTo(eventTraceActivity, message.Headers.MessageId.ToString()); } return(isMatch); } return(false); }
RoutingService() { this.SessionMessages = new List <MessageRpc>(1); //We only need to call this here if we trace in this method. BeginXXX methods call it again. //FxTrace.Trace.SetAndTraceTransfer(this.ActivityID, true); this.operationContext = OperationContext.Current; if (Fx.Trace.IsEtwProviderEnabled) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(this.operationContext.IncomingMessage); } IContextChannel channel = this.operationContext.Channel; ServiceHostBase host = this.operationContext.Host; this.ChannelExtension = channel.Extensions.Find <RoutingChannelExtension>(); if (this.ChannelExtension == null) { throw FxTrace.Exception.AsError(new ConfigurationErrorsException(SR2.RoutingExtensionNotFound)); } this.RoutingConfig = host.Extensions.Find <RoutingExtension>().RoutingConfiguration; this.RoutingConfig.VerifyConfigured(); this.ChannelExtension.AttachService(this); }
protected virtual void PrepareMessage(Message message) { message.Properties.Via = _localVia; ApplyChannelBinding(message); if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled) { EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); Guid relatedActivityId = EventTraceActivity.GetActivityIdFromThread(); if (eventTraceActivity == null) { eventTraceActivity = EventTraceActivity.GetFromThreadOrCreate(); EventTraceActivityHelper.TryAttachActivity(message, eventTraceActivity); } if (WcfEventSource.Instance.MessageReceivedByTransportIsEnabled()) { WcfEventSource.Instance.MessageReceivedByTransport( eventTraceActivity, LocalAddress != null && LocalAddress.Uri != null ? LocalAddress.Uri.AbsoluteUri : string.Empty, relatedActivityId); } } }
public WriteMessageAsyncResult(Message message, Stream stream, TextMessageEncoder textEncoder, AsyncCallback callback, object state) : base(callback, state) { this.message = message; this.textEncoder = textEncoder; this.xmlWriter = textEncoder.TakeStreamedWriter(stream); this.eventTraceActivity = null; if (TD.TextMessageEncodingStartIsEnabled()) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.TextMessageEncodingStart(this.eventTraceActivity); } if (!textEncoder.optimizeWriteForUTF8) { xmlWriter.WriteStartDocument(); } IAsyncResult result = message.BeginWriteMessage(this.xmlWriter, PrepareAsyncCompletion(onWriteMessage), this); if (SyncContinue(result)) { this.Complete(true); } }
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType) { if (stream == null) { throw FxTrace.Exception.ArgumentNull("stream"); } if (TD.ByteStreamMessageDecodingStartIsEnabled()) { TD.ByteStreamMessageDecodingStart(); } Message message = ByteStreamMessage.CreateMessage(stream, this.quotas, this.moveBodyReaderToContent); message.Properties.Encoder = this; if (SMTD.StreamedMessageReadByEncoderIsEnabled()) { SMTD.StreamedMessageReadByEncoder(EventTraceActivityHelper.TryExtractActivity(message, true)); } if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive); } return(message); }
// negotiation failure methods Message HandleNegotiationException(Message request, Exception e) { SecurityTraceRecordHelper.TraceServiceSecurityNegotiationFailure <T>( EventTraceActivityHelper.TryExtractActivity(request), this, e); return(CreateFault(request, e)); }
private void SetActivityIdOnThread(ref MessageRpc rpc) { if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled && rpc.EventTraceActivity != null) { // Propogate the ActivityId to the service operation EventTraceActivityHelper.SetOnThread(rpc.EventTraceActivity); } }
public override Task <ArraySegment <byte> > WriteMessageAsync(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message))); } if (bufferManager == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(bufferManager)), message); } if (maxMessageSize < 0) { throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(maxMessageSize), maxMessageSize, SR.ValueMustBeNonNegative), message); } if (messageOffset < 0 || messageOffset > maxMessageSize) { throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(messageOffset), messageOffset, SR.Format(SR.ValueMustBeInRange, 0, maxMessageSize)), message); } ThrowIfMismatchedMessageVersion(message); EventTraceActivity eventTraceActivity = null; if (WcfEventSource.Instance.TextMessageEncodingStartIsEnabled()) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); WcfEventSource.Instance.TextMessageEncodingStart(eventTraceActivity); } message.Properties.Encoder = this; TextBufferedMessageWriter messageWriter = TakeBufferedWriter(); ArraySegment <byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize); ReturnMessageWriter(messageWriter); if (WcfEventSource.Instance.MessageWrittenByEncoderIsEnabled()) { WcfEventSource.Instance.MessageWrittenByEncoder( eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message), messageData.Count, this); } if (MessageLogger.LogMessagesAtTransportLevel) { XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateTextReader(messageData.Array, messageData.Offset, messageData.Count, XmlDictionaryReaderQuotas.Max); MessageLogger.LogMessage(ref message, xmlDictionaryReader, MessageLoggingSource.TransportSend); } return(Task.FromResult(messageData)); }
// returns false if the max pending messages total size was hit. internal bool EnqueueMessage(Message message, int messageBufferSize, Action messageDequeuedCallback) { Action onMessageDequeuedCallback = () => { lock (this.ThisLock) { this.pendingMessagesTotalSize -= messageBufferSize; Fx.Assert(this.pendingMessagesTotalSize >= 0, "pendingMessagesTotalSize should not be negative."); } messageDequeuedCallback(); }; bool success = false; lock (this.ThisLock) { if (this.pendingMessagesTotalSize + messageBufferSize <= this.maxPendingMessagesTotalSize) { message.Properties.Via = this.Via; this.pendingMessagesTotalSize += messageBufferSize; try { this.FinishEnqueueMessage(message, onMessageDequeuedCallback, false); success = true; } finally { if (!success) { this.pendingMessagesTotalSize -= messageBufferSize; } } } else { if (TD.MaxPendingMessagesTotalSizeReachedIsEnabled()) { string messageIdString = string.Empty; if (message.Headers.MessageId != null) { messageIdString = string.Format(CultureInfo.CurrentCulture, "'{0}' ", message.Headers.MessageId.ToString()); } EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.MaxPendingMessagesTotalSizeReached(eventTraceActivity, messageIdString, this.maxPendingMessagesTotalSize, typeof(TransportBindingElement).FullName); } } } return(success); }
public override async Task WriteMessageAsync(Message message, Stream stream) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message))); } if (stream == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message); } ThrowIfMismatchedMessageVersion(message); EventTraceActivity eventTraceActivity = null; if (WcfEventSource.Instance.TextMessageEncodingStartIsEnabled()) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); WcfEventSource.Instance.TextMessageEncodingStart(eventTraceActivity); } message.Properties.Encoder = this; XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream); if (_optimizeWriteForUTF8) { await message.WriteMessageAsync(xmlWriter); } else { xmlWriter.WriteStartDocument(); await message.WriteMessageAsync(xmlWriter); xmlWriter.WriteEndDocument(); } await xmlWriter.FlushAsync(); ReturnStreamedWriter(xmlWriter); if (WcfEventSource.Instance.StreamedMessageWrittenByEncoderIsEnabled()) { WcfEventSource.Instance.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message)); } if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend); } }
void TraceHttpMessageReceived(Message message) { if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled) { bool attached = false; Guid relatedId = this.eventTraceActivity != null ? this.eventTraceActivity.ActivityId : Guid.Empty; HttpRequestMessageProperty httpProperty; // Encoder will always add an activity. We need to remove this and read it // from the web headers for http since correlation might be propogated. if (message.Headers.MessageId == null && message.Properties.TryGetValue <HttpRequestMessageProperty>(HttpRequestMessageProperty.Name, out httpProperty)) { try { string e2eId = httpProperty.Headers[EventTraceActivity.Name]; if (!String.IsNullOrEmpty(e2eId)) { byte[] data = Convert.FromBase64String(e2eId); if (data != null && data.Length == 16) { Guid id = new Guid(data); this.eventTraceActivity = new EventTraceActivity(id, true); message.Properties[EventTraceActivity.Name] = this.eventTraceActivity; attached = true; } } } catch (Exception ex) { if (Fx.IsFatal(ex)) { throw; } } } if (!attached) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message, true); } if (TD.MessageReceivedByTransportIsEnabled()) { TD.MessageReceivedByTransport( this.eventTraceActivity, this.listener != null && this.listener.Uri != null ? this.listener.Uri.AbsoluteUri : string.Empty, relatedId); } } }
public MessageRpc(Message message, OperationContext operationContext, bool impersonationRequired) { Fx.Assert(message != null, "message cannot be null"); Fx.Assert(operationContext != null, "operationContext cannot be null"); this.originalMessage = message; this.OperationContext = operationContext; if (Fx.Trace.IsEtwProviderEnabled) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); } //passing in true causes this to return null if the thread is not impersonating. this.windowsIdentity = WindowsIdentity.GetCurrent(true); if (impersonationRequired && !AspNetEnvironment.Current.AspNetCompatibilityEnabled) { if (this.windowsIdentity == null || this.windowsIdentity.ImpersonationLevel != TokenImpersonationLevel.Impersonation) { //Temporarily revert impersonation to process token to throw an exception IDisposable autoRevert = null; try { try { } finally { autoRevert = WindowsIdentity.Impersonate(IntPtr.Zero); } Win32Exception errorDetail = new Win32Exception(ERROR_BAD_IMPERSONATION_LEVEL); throw FxTrace.Exception.AsError(new SecurityNegotiationException(errorDetail.Message)); } finally { if (autoRevert != null) { autoRevert.Dispose(); } } } } ReceiveContext.TryGet(message, out this.receiveContext); this.transaction = Transaction.Current; if (this.transaction == null) { this.transaction = TransactionMessageProperty.TryGetTransaction(message); } }
private EventTraceActivity TraceDispatchMessageStart(Message message) { if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled && message != null) { EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); if (WcfEventSource.Instance.DispatchMessageStartIsEnabled()) { WcfEventSource.Instance.DispatchMessageStart(eventTraceActivity); } return(eventTraceActivity); } return(null); }
private async Task WriteMessageInternalAsync(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message))); } if (stream == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message); } ThrowIfMismatchedMessageVersion(message); EventTraceActivity eventTraceActivity = null; if (WcfEventSource.Instance.MtomMessageEncodingStartIsEnabled()) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); WcfEventSource.Instance.MtomMessageEncodingStart(eventTraceActivity); } message.Properties.Encoder = this; if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend); } XmlDictionaryWriter xmlWriter = _factory.TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders); if (_writeEncoding.WebName == "utf-8") { await message.WriteMessageAsync(xmlWriter); } else { await xmlWriter.WriteStartDocumentAsync(); await message.WriteMessageAsync(xmlWriter); await xmlWriter.WriteEndDocumentAsync(); } await xmlWriter.FlushAsync(); _factory.ReturnStreamedWriter(xmlWriter); if (WcfEventSource.Instance.StreamedMessageWrittenByEncoderIsEnabled()) { WcfEventSource.Instance.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message)); } }
protected override void OnSend(Message message, TimeSpan timeout) { ThrowIfDisposedOrNotOpen(); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); // If timeout == TimeSpan.MaxValue, then we want to pass Timeout.Infinite as // SemaphoreSlim doesn't accept timeouts > Int32.MaxValue. // Using TimeoutHelper.RemainingTime() would yield a value less than TimeSpan.MaxValue // and would result in the value Int32.MaxValue so we must use the original timeout specified. if (!SendLock.Wait(TimeoutHelper.ToMilliseconds(timeout))) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException( SR.Format(SR.SendToViaTimedOut, Via, timeout), TimeoutHelper.CreateEnterTimedOutException(timeout))); } try { // check again in case the previous send faulted while we were waiting for the lock ThrowIfDisposedOrNotOpen(); ThrowIfOutputSessionClosed(); bool success = false; try { ApplyChannelBinding(message); OnSendCore(message, timeoutHelper.RemainingTime()); success = true; if (WcfEventSource.Instance.MessageSentByTransportIsEnabled()) { EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); WcfEventSource.Instance.MessageSentByTransport(eventTraceActivity, RemoteAddress.Uri.AbsoluteUri); } } finally { if (!success) { Fault(); } } } finally { SendLock.Release(); } }
bool WriteCore() { // check again in case the previous send faulted while we were waiting for the lock this.channel.ThrowIfDisposedOrNotOpen(); this.channel.ThrowIfOutputSessionClosed(); this.channel.ApplyChannelBinding(this.message); Message message = this.message; this.message = null; // Because we nullify the message, we need to save its trace activity, for logging events later on. if (TD.MessageSentByTransportIsEnabled()) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); } AsyncCompletionResult completionResult; if (this.streamedOutput) { completionResult = this.channel.StartWritingStreamedMessage(message, this.timeoutHelper.RemainingTime(), onWriteComplete, this); } else { bool allowOutputBatching; ArraySegment <byte> messageData; allowOutputBatching = message.Properties.AllowOutputBatching; messageData = this.channel.EncodeMessage(message); this.buffer = messageData.Array; completionResult = this.channel.StartWritingBufferedMessage( message, messageData, allowOutputBatching, this.timeoutHelper.RemainingTime(), onWriteComplete, this); } if (completionResult == AsyncCompletionResult.Queued) { return(false); } this.channel.FinishWritingMessage(); return(true); }
public DiscoveryOperationContext(OperationContext operationContext) { Fx.Assert(operationContext != null, "The operationContext must be non null."); if (Fx.Trace.IsEtwProviderEnabled) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(operationContext.IncomingMessage); } this.operationContext = operationContext; this.operationContextExtension = DiscoveryOperationContext.GetDiscoveryOperationContextExtension(this.operationContext); this.messageProperty = DiscoveryOperationContext.GetDiscoveryMessageProperty(this.operationContext); this.thisLock = new object(); }
static bool HandleWriteMessage(IAsyncResult result) { WriteMessageAsyncResult thisPtr = (WriteMessageAsyncResult)result.AsyncState; thisPtr.message.EndWriteMessage(result); thisPtr.writer.Flush(); if (SMTD.MessageWrittenAsynchronouslyByEncoderIsEnabled()) { SMTD.MessageWrittenAsynchronouslyByEncoder( thisPtr.eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(thisPtr.message)); } return(true); }
public static bool TryGet(Message message, out ReceiveContext property) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message"); } bool result = TryGet(message.Properties, out property); if (result && FxTrace.Trace.IsEnd2EndActivityTracingEnabled && property.eventTraceActivity == null) { property.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); } return(result); }
internal static bool EnsureReplyTo() { OperationContext context = OperationContext.Current; if (context.IncomingMessageHeaders.ReplyTo == null) { if (TD.DiscoveryMessageWithNullReplyToIsEnabled()) { EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(context.IncomingMessage); TD.DiscoveryMessageWithNullReplyTo(eventTraceActivity, context.IncomingMessageHeaders.MessageId.ToString()); } return(false); } return(true); }
protected override void OnSend(Message message, TimeSpan timeout) { this.ThrowIfDisposedOrNotOpen(); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); if (!this.sendLock.TryEnter(timeoutHelper.RemainingTime())) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException( SR.GetString(SR.SendToViaTimedOut, Via, timeout), ThreadNeutralSemaphore.CreateEnterTimedOutException(timeout))); } try { // check again in case the previous send faulted while we were waiting for the lock this.ThrowIfDisposedOrNotOpen(); this.ThrowIfOutputSessionClosed(); bool success = false; try { this.ApplyChannelBinding(message); this.OnSendCore(message, timeoutHelper.RemainingTime()); success = true; if (TD.MessageSentByTransportIsEnabled()) { EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.MessageSentByTransport(eventTraceActivity, this.RemoteAddress.Uri.AbsoluteUri); } } finally { if (!success) { this.Fault(); } } } finally { this.sendLock.Exit(); } }
void WriteMessage(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message")); } if (stream == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException("stream"), message); } ThrowIfMismatchedMessageVersion(message); EventTraceActivity eventTraceActivity = null; if (TD.MtomMessageEncodingStartIsEnabled()) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.MtomMessageEncodingStart(eventTraceActivity); } message.Properties.Encoder = this; if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend); } XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders); if (this.writeEncoding.WebName == "utf-8") { message.WriteMessage(xmlWriter); } else { xmlWriter.WriteStartDocument(); message.WriteMessage(xmlWriter); xmlWriter.WriteEndDocument(); } xmlWriter.Flush(); ReturnStreamedWriter(xmlWriter); if (TD.StreamedMessageWrittenByEncoderIsEnabled()) { TD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message)); } }
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType) { if (bufferManager == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bufferManager"); } if (contentType == this.ContentType) { contentType = null; } if (TD.MtomMessageDecodingStartIsEnabled()) { TD.MtomMessageDecodingStart(); } MtomBufferedMessageData messageData = TakeBufferedReader(); messageData.ContentType = contentType; messageData.Open(buffer, bufferManager); RecycledMessageState messageState = messageData.TakeMessageState(); if (messageState == null) { messageState = new RecycledMessageState(); } Message message = new BufferedMessage(messageData, messageState); message.Properties.Encoder = this; if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive); } if (TD.MessageReadByEncoderIsEnabled() && buffer != null) { TD.MessageReadByEncoder( EventTraceActivityHelper.TryExtractActivity(message, true), buffer.Count, this); } return(message); }
bool IsInvalid(TMessage message) { UniqueId messageId = OperationContext.Current.IncomingMessageHeaders.MessageId; if (messageId == null) { if (TD.DiscoveryMessageWithNullMessageIdIsEnabled()) { TD.DiscoveryMessageWithNullMessageId(null, ProtocolStrings.TracingStrings.Bye); } return(true); } EventTraceActivity eventTraceActivity = null; if (Fx.Trace.IsEtwProviderEnabled) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(OperationContext.Current.IncomingMessage); } if (this.announcementServiceImpl.IsDuplicate(messageId)) { if (TD.DuplicateDiscoveryMessageIsEnabled()) { TD.DuplicateDiscoveryMessage(eventTraceActivity, ProtocolStrings.TracingStrings.Bye, messageId.ToString()); } return(true); } else if (this.ValidateContent(message)) { return(false); } else { if (TD.DiscoveryMessageWithInvalidContentIsEnabled()) { TD.DiscoveryMessageWithInvalidContent(eventTraceActivity, ProtocolStrings.TracingStrings.Bye, messageId.ToString()); } return(true); } }
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType) { if (bufferManager == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(bufferManager))); } if (WcfEventSource.Instance.TextMessageDecodingStartIsEnabled()) { WcfEventSource.Instance.TextMessageDecodingStart(); } Message message; UTF8BufferedMessageData messageData = TakeBufferedReader(); messageData.Encoding = GetEncodingFromContentType(contentType, _contentEncodingMap); messageData.Open(buffer, bufferManager); RecycledMessageState messageState = messageData.TakeMessageState(); if (messageState == null) { messageState = new RecycledMessageState(); } message = new BufferedMessage(messageData, messageState); message.Properties.Encoder = this; if (WcfEventSource.Instance.MessageReadByEncoderIsEnabled()) { WcfEventSource.Instance.MessageReadByEncoder( EventTraceActivityHelper.TryExtractActivity(message, true), buffer.Count, this); } if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive); } return(message); }
internal static void StartOperationInvokeTrace(string methodName) { if (TD.OperationInvokedIsEnabled()) { OperationContext context = OperationContext.Current; EventTraceActivity eventTraceActivity = null; if (context != null && context.IncomingMessage != null) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(context.IncomingMessage); } if (TD.OperationInvokedIsEnabled()) { TD.OperationInvoked(eventTraceActivity, methodName, TraceUtility.GetCallerInfo(OperationContext.Current)); } if (TD.OperationCompletedIsEnabled() || TD.OperationFaultedIsEnabled() || TD.OperationFailedIsEnabled()) { TraceUtility.UpdateAsyncOperationContextWithStartTime(eventTraceActivity, DateTime.UtcNow.Ticks); } } }
public WriteMessageAsyncResult(Message message, Stream stream, AsyncCallback callback, object state) : base(callback, state) { this.message = message; this.stream = stream; this.writer = new XmlByteStreamWriter(stream, false); if (onCleanup == null) { onCleanup = new Action <IAsyncResult, Exception>(Cleanup); } this.OnCompleting += onCleanup; Exception completionException = null; bool completeSelf = false; this.eventTraceActivity = null; if (TD.ByteStreamMessageEncodingStartIsEnabled()) { this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.ByteStreamMessageEncodingStart(this.eventTraceActivity); } try { IAsyncResult result = message.BeginWriteMessage(writer, PrepareAsyncCompletion(HandleWriteMessage), this); completeSelf = SyncContinue(result); } catch (Exception ex) { if (Fx.IsFatal(ex)) { throw; } completeSelf = true; completionException = ex; } if (completeSelf) { this.Complete(true, completionException); } }
public override void WriteMessage(Message message, Stream stream) { if (message == null) { throw FxTrace.Exception.ArgumentNull("message"); } if (stream == null) { throw FxTrace.Exception.ArgumentNull("stream"); } ThrowIfMismatchedMessageVersion(message); EventTraceActivity eventTraceActivity = null; if (TD.ByteStreamMessageEncodingStartIsEnabled()) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.ByteStreamMessageEncodingStart(eventTraceActivity); } message.Properties.Encoder = this; if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend); } using (XmlWriter writer = new XmlByteStreamWriter(stream, false)) { message.WriteMessage(writer); writer.Flush(); } if (SMTD.StreamedMessageWrittenByEncoderIsEnabled()) { SMTD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message)); } }
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType) { if (buffer.Array == null) { throw FxTrace.Exception.ArgumentNull("buffer.Array"); } if (bufferManager == null) { throw FxTrace.Exception.ArgumentNull("bufferManager"); } if (TD.ByteStreamMessageDecodingStartIsEnabled()) { TD.ByteStreamMessageDecodingStart(); } ByteStreamBufferedMessageData messageData = new ByteStreamBufferedMessageData(buffer, bufferManager); Message message = ByteStreamMessage.CreateMessage(messageData, this.bufferedReadReaderQuotas, this.moveBodyReaderToContent); message.Properties.Encoder = this; if (SMTD.MessageReadByEncoderIsEnabled()) { SMTD.MessageReadByEncoder( EventTraceActivityHelper.TryExtractActivity(message, true), buffer.Count, this); } if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive); } return(message); }