public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { ArraySegment<byte> buffer = innerEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset); bindingElement.WriteCount++; bindingElement.WriteBytes += buffer.Count; return buffer; }
// Listen sockets have been created. public UdpSocketListener(List<Socket> listenSockets, int maxBufferPoolSize, int maxMessageSize, DataReceivedCallback dataReceivedCallback) { this.listenSockets = listenSockets; this.maxMessageSize = maxMessageSize; this.bufferManager = BufferManager.CreateBufferManager(maxBufferPoolSize, maxMessageSize); this.dataReceivedCallback = dataReceivedCallback; }
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { if (message.Properties.ContainsKey(HttpRequestMessageProperty.Name)) { HttpRequestMessageProperty httpMessage = message.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty; if (httpMessage != null && httpMessage.Method == "POST") { ArraySegment<byte> innerMessage = _encoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset); byte[] encodedMessage = Encoding.UTF8.GetBytes(String.Concat("xml=", HttpUtility.UrlEncode(Encoding.UTF8.GetString(innerMessage.Array, 0, innerMessage.Count)))); bufferManager.ReturnBuffer(innerMessage.Array); byte[] buffer = bufferManager.TakeBuffer(encodedMessage.Length); Array.Copy(encodedMessage, buffer, encodedMessage.Length); bufferManager.ReturnBuffer(buffer); return new ArraySegment<byte>(buffer, messageOffset, encodedMessage.Length); } else { return _encoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset); } } else { return _encoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset); } }
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType) { ArraySegment<byte> decompressedBuffer = DecompressBuffer(buffer, bufferManager); Message returnMessage = _messageEncoder.ReadMessage(decompressedBuffer, bufferManager); returnMessage.Properties.Encoder = this; return returnMessage; }
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { if (message == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message")); } if (bufferManager == null) { throw TraceUtility.ThrowHelperError(new ArgumentNullException("bufferManager"), message); } if (maxMessageSize < 0) { throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxMessageSize", maxMessageSize, SR2.GetString(SR2.ValueMustBeNonNegative)), message); } if (messageOffset < 0 || messageOffset > maxMessageSize) { throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageOffset", messageOffset, SR2.GetString(SR2.JsonValueMustBeInRange, 0, maxMessageSize)), message); } ThrowIfMismatchedMessageVersion(message); message.Properties.Encoder = this; BufferedMessageWriter messageWriter = new WebScriptMetadataBufferedMessageWriter(this); ArraySegment<byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize); if (MessageLogger.LogMessagesAtTransportLevel) { MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend); } if (System.ServiceModel.Diagnostics.Application.TD.MessageWrittenByEncoderIsEnabled() && messageData != null) { System.ServiceModel.Diagnostics.Application.TD.MessageWrittenByEncoder(EventTraceActivityHelper.TryExtractActivity(message), messageData.Count, this); } return messageData; }
public ColdStorageProcessor( Func<string, IBlobWriter> blobWriterFactory, IColdStorageInstrumentationPublisher instrumentationPublisher, CancellationToken token, int warningLevel, int tripLevel, TimeSpan stallInterval, TimeSpan logCooldownInterval, string eventHubName, int maxBlocks = MaxBlocks, int maxBlockSize = MaxBlockSize) { Guard.ArgumentNotNull(blobWriterFactory, "blobWriterFactory"); _blobWriterFactory = blobWriterFactory; _token = token; _warningLevel = warningLevel; _tripLevel = tripLevel; _stallInterval = stallInterval; _logCooldownInterval = logCooldownInterval; _eventHubName = eventHubName; _instrumentationPublisher = instrumentationPublisher; _maxBlockSize = maxBlockSize; _buffers = BufferManager.CreateBufferManager(maxBlocks, _maxBlockSize); _eventHubBufferDataList = new List<BufferedFrameData>(); }
/// <summary> /// SerialChannel Base /// </summary> /// <param name="bufferManager"> /// Buffer manager created by factory and listener</param> /// <param name="encoderFactory"> /// Referece to encoder factory as returned by encoder element</param> /// <param name="address">Remote address</param> /// <param name="portNumber">COM port number</param> /// <param name="parent">reference to factory/listener</param> /// <param name="maxReceivedMessageSize"> /// Some settings for transport channel</param> public SerialChannelBase(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, string portNumber, ChannelManagerBase parent, long maxReceivedMessageSize) : base(parent) { this.address = address; this.bufferManager = bufferManager; this.encoder = encoderFactory.CreateSessionEncoder(); this.maxReceivedMessageSize = maxReceivedMessageSize; this.portNumber = portNumber; // Create port serialPort = new SerialPort(); // Set the appropriate properties. serialPort.PortName = this.portNumber; //TODO: Read these settings from configuration file serialPort.BaudRate = 9600; serialPort.Parity = Parity.None; serialPort.DataBits = 8; serialPort.StopBits = StopBits.One; serialPort.Handshake = Handshake.None; // Set the read/write timeouts serialPort.ReadTimeout = 500; serialPort.WriteTimeout = 500; }
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { ArraySegment<byte> messageBuffer; byte[] writeBuffer = null; int messageLength; using (MemoryStream stream = new MemoryStream()) { using (XmlWriter writer = XmlWriter.Create(stream, _writerSettings)) { message.WriteMessage(writer); } // TryGetBuffer is the preferred path but requires 4.6 //stream.TryGetBuffer(out messageBuffer); writeBuffer = stream.ToArray(); messageBuffer = new ArraySegment<byte>(writeBuffer); messageLength = (int)stream.Position; } int totalLength = messageLength + messageOffset; byte[] totalBytes = bufferManager.TakeBuffer(totalLength); Array.Copy(messageBuffer.Array, 0, totalBytes, messageOffset, messageLength); ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength); return byteArray; }
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { String bodyContent = null; lastMessage = message.Headers.Action; XmlDictionaryReader reader = message.GetReaderAtBodyContents(); while (reader.Read()) { if (reader.Name == "request") { bodyContent = reader.ReadElementContentAsString(); break; } } reader.Close(); byte[] messageBytes = System.Text.Encoding.UTF8.GetBytes(bodyContent); int totalLength = messageBytes.Length + messageOffset; byte[] totalBytes = bufferManager.TakeBuffer(totalLength); Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageBytes.Length); ArraySegment<byte> buffer = new ArraySegment<byte>( totalBytes, messageOffset, messageBytes.Length); return buffer; }
public static ArraySegment<byte> Encode(Uri uri, ArraySegment<byte> messageBuffer, BufferManager bufferManager) { byte[] uriBuffer = UnicodeEncoding.Unicode.GetBytes(uri.ToString()); byte[] uriLengthBuffer = EncodeInt(uriBuffer.Length); byte[] payloadLengthBuffer = EncodeInt(messageBuffer.Count); // Encode the following fields: // Uri length (4 bytes) // Uri (size specified by uri length) // Payload length (4 bytes) // Payload (size specified by payload length) byte[] buffer = bufferManager.TakeBuffer(uriLengthBuffer.Length + uriBuffer.Length + payloadLengthBuffer.Length + messageBuffer.Count); int destOffset = 0; Buffer.BlockCopy(uriLengthBuffer, 0, buffer, destOffset, uriLengthBuffer.Length); destOffset += uriLengthBuffer.Length; Buffer.BlockCopy(uriBuffer, 0, buffer, destOffset, uriBuffer.Length); destOffset += uriBuffer.Length; Buffer.BlockCopy(payloadLengthBuffer, 0, buffer, destOffset, payloadLengthBuffer.Length); destOffset += payloadLengthBuffer.Length; Buffer.BlockCopy(messageBuffer.Array, messageBuffer.Offset, buffer, destOffset, messageBuffer.Count); bufferManager.ReturnBuffer(messageBuffer.Array); return new ArraySegment<byte>(buffer); }
public HttpServer(int maxAccept, int maxConnections, int bufferSize) { timeoutTimer = new System.Timers.Timer(Timeout); timeoutTimer.Elapsed += timeoutTimer_Elapsed; this.maxAccept = maxAccept; this.maxConnections = maxConnections; this.bufferSize = bufferSize; this.enforceMaxClients = new Semaphore (maxConnections, maxConnections); this.bufferManager = BufferManager.CreateBufferManager (maxConnections, maxConnections * bufferSize * 2); for (int i = 0; i < maxAccept; i++) { var acceptArgs = new SocketAsyncEventArgs (); acceptArgs.Completed += HandleAcceptCompleted; this.acceptPool.Push (acceptArgs); } for (int i = 0; i < maxConnections; i++) { var readWriteArgs = new SocketAsyncEventArgs (); var client = new HttpClient (); readWriteArgs.UserToken = client; readWriteArgs.SetBuffer (this.bufferManager.TakeBuffer (bufferSize), 0, bufferSize); readWriteArgs.Completed += HandleReadWriteCompleted; this.readWritePool.Push (readWriteArgs); } timeoutTimer.Start(); }
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType) { Message message = this.innerEncoder.ReadMessage(buffer, bufferManager); bindingElement.ReadCount++; bindingElement.ReadBytes += buffer.Count; return message; }
/// <inheritdoc /> public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType) { // Treat the alternate as native if (IsAlternateContent(contentType)) { // HACK: Should see if we have a declr or some xml contentType = this.contentType; } var msgContents = new byte[buffer.Count]; Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length); bufferManager.ReturnBuffer(buffer.Array); // Most interoperable to include the xml declaration writerSettings.OmitXmlDeclaration = false; // Save the encoding for when we write the response writerSettings.Encoding = msgContents.GetEncoding(contentType); var xmlDeclEncoding = msgContents.GetXmlDeclEncoding(writerSettings.Encoding); // Check if the two encodings align if (xmlDeclEncoding != null && xmlDeclEncoding.WebName == writerSettings.Encoding.WebName) { // Need to recode msgContents = Encoding.Convert(writerSettings.Encoding, xmlDeclEncoding, msgContents); } var stream = new MemoryStream(msgContents); return ReadMessage(stream, int.MaxValue); }
public FileRequestChannel(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, FileRequestChannelFactory parent, Uri via) : base(bufferManager, encoderFactory, address, parent, parent.MaxReceivedMessageSize) { this.via = via; this.writeLock = new object(); }
public static IObservable<DisposableByteBuffer> ToFrameStreamObservable(this Stream stream, BufferManager bufferManager) { return Observable.Create<DisposableByteBuffer>(async (observer, token) => { var headerBuffer = new byte[sizeof(int)]; try { while (!token.IsCancellationRequested) { if (await stream.ReadBytesCompletelyAsync(headerBuffer, headerBuffer.Length, token) != headerBuffer.Length) break; var length = BitConverter.ToInt32(headerBuffer, 0); var buffer = bufferManager.TakeBuffer(length); if (await stream.ReadBytesCompletelyAsync(buffer, length, token) != length) break; observer.OnNext(new DisposableByteBuffer(buffer, length, Disposable.Create(() => bufferManager.ReturnBuffer(buffer)))); } observer.OnCompleted(); } catch (Exception error) { observer.OnError(error); } }); }
public SizedTcpReplyChannel(MessageEncoder encoder, BufferManager bufferManager, Uri localAddress, Socket socket, ChannelManagerBase channelManager) : base(encoder, bufferManager, channelManager) { this.localAddress = localAddress; this.socket = socket; this.InitializeSocket(socket); }
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType) { var msgContents = new byte[buffer.Count]; Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length); var message = new UTF8Encoding().GetString(msgContents); var reader = XmlReader.Create(new MemoryStream(msgContents)); var xmlDocument = new XmlDocument(); xmlDocument.Load(reader); var elementsByTagName = xmlDocument.GetElementsByTagName("Envelope", Soap11Namespace); if (elementsByTagName.Count == 0) throw new XmlException("Не найден узел Envelope"); var prefixOfNamespace = elementsByTagName[0].GetPrefixOfNamespace(Soap11Namespace); if (string.IsNullOrEmpty(prefixOfNamespace)) throw new XmlException(string.Format("Не найден префикс пространста имен {0}", Soap11Namespace)); LogMessage(xmlDocument, true); // Убираем actors из входящего сообщения message = message.Replace(prefixOfNamespace + ":mustUnderstand=\"1\"", ""); message = message.Replace(prefixOfNamespace + ":actor=\"" + SmevActor + "\"", ""); var bytes = new UTF8Encoding().GetBytes(message.Replace(prefixOfNamespace + ":actor=\"" + RecipientActor + "\"", "")); var length = bytes.Length; var array = bufferManager.TakeBuffer(length); Array.Copy(bytes, 0, array, 0, length); buffer = new ArraySegment<byte>(array, 0, length); return _innerEncoder.ReadMessage(buffer, bufferManager, contentType); }
public Acceptor(DistributorConfig config) { _bufferManager = BufferManager.CreateBufferManager(MaxBufferPoolSize, MaxBufferSize); _config = config; _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _interactors = new Dictionary<Socket, Interactor>(); }
public MessageBusInputChannel( BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent, EndpointAddress localAddress, IBus bus) : base(bufferManager, encoder, parent) { _localAddress = localAddress; _bus = bus; _aLock = new object(); _tryReceiveDelegate = (TimeSpan timeout, out Message message) => { message = null; try { var requestMessage = _bus.Receive(true, null); if (requestMessage != null) { message = GetWcfMessageFromString(requestMessage.Content); OnAfterTryReceive(requestMessage); } } catch (Exception ex) { throw new CommunicationException(ex.Message, ex); } return true; }; _receiveDelegate = (TimeSpan timeout) => { var requestMessage = _bus.Receive(false, ChannelID); return GetWcfMessageFromString(requestMessage.Content); }; }
public MessageBusReplySessionChannel( BufferManager bufferManager, MessageEncoderFactory encoderFactory, ChannelManagerBase parent, EndpointAddress localAddress, IBus bus) : base(bufferManager, encoderFactory, parent, localAddress, bus) { }
public FileReplyChannel(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, FileReplyChannelListener parent) : base(bufferManager, encoderFactory, address, parent, parent.MaxReceivedMessageSize) { this.localAddress = address; this.readLock = new object(); }
private FramingDuplexSessionChannel(ChannelManagerBase manager, Microsoft.ServiceBus.Channels.IConnectionOrientedTransportFactorySettings settings, EndpointAddress localAddress, Uri localVia, EndpointAddress remoteAddresss, Uri via, bool exposeConnectionProperty) : base(manager, remoteAddresss, via, settings.ManualAddressing, settings.MessageVersion) { this.localAddress = localAddress; this.localVia = localVia; this.exposeConnectionProperty = exposeConnectionProperty; this.bufferManager = settings.BufferManager; this.Activity = new EventTraceActivity(); }
public AzureTableReplyChannel(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, AzureTableReplyChannelListener parent, CloudTableClient cloudTableClient, string tableName, string partitionKey, TimeSpan idleSleep, TimeSpan activeSleep) : base(bufferManager, encoderFactory, address, parent, parent.MaxReceivedMessageSize, cloudTableClient, tableName, partitionKey, idleSleep, activeSleep) { this.localAddress = address; }
public LidgrenNetChannel(NetConnection connection, BufferManager bufferManager) { _connection = connection; _bufferManager = bufferManager; _buffer = _bufferManager.TakeBuffer(1024*1024); _stream = new MemoryStream(_buffer); _writer = new BinaryWriter(_stream); }
protected MessageBusChannelBase(BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent) : base(parent) { _id = Guid.NewGuid(); _bufferManager = bufferManager; _encoder = encoder.CreateSessionEncoder(); }
public ClientDuplexConnectionReader(ClientFramingDuplexSessionChannel channel, IConnection connection, ClientDuplexDecoder decoder, IConnectionOrientedTransportFactorySettings settings, MessageEncoder messageEncoder) : base(connection, null, 0, 0, null) { this.decoder = decoder; this.maxBufferSize = settings.MaxBufferSize; this.bufferManager = settings.BufferManager; this.messageEncoder = messageEncoder; this.channel = channel; }
// Not used since writing to topics is supported via MessageSender // BrokeredMessageEncoder is only used to read public override ArraySegment<byte> WriteMessage( Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { throw new NotSupportedException(); }
public MessageBusRequestSessionChannel( BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent, EndpointAddress remoteAddress, Uri via, IBus bus) : base(bufferManager, encoder, parent, remoteAddress, via, bus) { _session = new MessageBusOutputSession((new UniqueId()).ToString()); }
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType) { var msgContents = new byte[buffer.Count]; Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length); bufferManager.ReturnBuffer(buffer.Array); var stream = new MemoryStream(msgContents); return ReadMessage(stream, int.MaxValue); }
public AzureTableRequestChannel(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, AzureTableRequestChannelFactory parent, Uri via, CloudTableClient cloudTableClient, string tableName, string partitionKey, TimeSpan idleSleep, TimeSpan activeSleep) : base(bufferManager, encoderFactory, address, parent, parent.MaxReceivedMessageSize, cloudTableClient, tableName, partitionKey, idleSleep, activeSleep) { this.via = via; this.writeLock = new object(); }
//One of the two main entry points into the encoder. Called by WCF to encode a Message into a buffered byte array. public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { //The message is ServiceModel.Security.SecurityAppliedMessage //Use the inner encoder to encode a Message into a buffered byte array ArraySegment<byte> buffer = innerEncoder.WriteMessage(message, maxMessageSize, bufferManager, 0); //Compress the resulting byte array return CompressBuffer(buffer, bufferManager, messageOffset); }
public override void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager) { if (size <= 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("size", size, SR.ValueMustBePositive)); } ThrowPendingWriteException(); if (immediate || _flushTimeout == TimeSpan.Zero) { WriteNow(buffer, offset, size, timeout, bufferManager); } else { WriteLater(buffer, offset, size, timeout); bufferManager.ReturnBuffer(buffer); } }
public void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager) { Write(buffer, offset, size, immediate, timeout); bufferManager.ReturnBuffer(buffer); }
public virtual void Write(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, BufferManager bufferManager) { Connection.Write(buffer, offset, size, immediate, timeout, bufferManager); }
// used for buffered streaming internal virtual async Task <Message> ReadMessageAsync(Stream stream, BufferManager bufferManager, int maxBufferSize, string contentType) { return(ReadMessage(await BufferMessageStreamAsync(stream, bufferManager, maxBufferSize), bufferManager, contentType)); }
public ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager) { ArraySegment <byte> arraySegment = WriteMessage(message, maxMessageSize, bufferManager, 0); return(arraySegment); }
protected override void OnOpen(TimeSpan timeout) { this.bufferManager = System.ServiceModel.Channels.BufferManager.CreateBufferManager(this.MaxBufferPoolSize, this.MaxBufferSize); }
public virtual Task <ArraySegment <byte> > WriteMessageAsync(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { return(Task.FromResult(WriteMessage(message, maxMessageSize, bufferManager, messageOffset))); }
public virtual Task <Message> ReadMessageAsync(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType) { return(Task.FromResult(ReadMessage(buffer, bufferManager, contentType))); }
public Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager) { Message message = ReadMessage(buffer, bufferManager, null); return(message); }
protected override void OnOpening() { base.OnOpening(); this.bufferManager = System.ServiceModel.Channels.BufferManager.CreateBufferManager(this.MaxBufferPoolSize, this.GetMaxBufferSize()); }
static AmqpChannelListenerBase() { AmqpChannelListenerBase.GCBufferManager = System.ServiceModel.Channels.BufferManager.CreateBufferManager((long)0, 0); }
public override ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset) { if (message == null) { throw FxTrace.Exception.ArgumentNull("message"); } if (bufferManager == null) { throw FxTrace.Exception.ArgumentNull("bufferManager"); } if (maxMessageSize < 0) { throw FxTrace.Exception.ArgumentOutOfRange("maxMessageSize", maxMessageSize, SR.ArgumentOutOfMinRange(0)); } if (messageOffset < 0) { throw FxTrace.Exception.ArgumentOutOfRange("messageOffset", messageOffset, SR.ArgumentOutOfMinRange(0)); } EventTraceActivity eventTraceActivity = null; if (TD.ByteStreamMessageEncodingStartIsEnabled()) { eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message); TD.ByteStreamMessageEncodingStart(eventTraceActivity); } ThrowIfMismatchedMessageVersion(message); message.Properties.Encoder = this; ArraySegment <byte> messageBuffer; int size; using (BufferManagerOutputStream stream = new BufferManagerOutputStream(maxSentMessageSizeExceededResourceString, 0, maxMessageSize, bufferManager)) { stream.Skip(messageOffset); using (XmlWriter writer = new XmlByteStreamWriter(stream, true)) { message.WriteMessage(writer); writer.Flush(); byte[] bytes = stream.ToArray(out size); messageBuffer = new ArraySegment <byte>(bytes, messageOffset, size - messageOffset); } } if (SMTD.MessageWrittenByEncoderIsEnabled()) { SMTD.MessageWrittenByEncoder( eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message), messageBuffer.Count, this); } if (MessageLogger.LogMessagesAtTransportLevel) { // DevDiv#486728 // Don't pass in a buffer manager to avoid returning 'messageBuffer" to the bufferManager twice. ByteStreamBufferedMessageData messageData = new ByteStreamBufferedMessageData(messageBuffer, null); using (XmlReader reader = new XmlBufferedByteStreamReader(messageData, this.quotas)) { MessageLogger.LogMessage(ref message, reader, MessageLoggingSource.TransportSend); } } return(messageBuffer); }
public abstract ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset);
public ServerUdpOutputChannel(ChannelManagerBase factory, MessageEncoder encoder, BufferManager bufferManager, UdpSocket[] sendSockets, UdpRetransmissionSettings retransmissionSettings, Uri via, bool isMulticast) : base(factory, encoder, bufferManager, sendSockets, retransmissionSettings, via, isMulticast) { }
public BufferPool(long maxBufferPoolSize, int maxBufferSize) { _internalBufferManager = ssc.BufferManager.CreateBufferManager(maxBufferPoolSize, maxBufferSize); }
public WrappingInternalBufferManager(BufferManager innerBufferManager) { this.innerBufferManager = innerBufferManager; }
protected override void OnOpening() { base.OnOpening(); _bufferManager = BufferManager.CreateBufferManager(MaxBufferPoolSize, GetMaxBufferSize()); }