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