public virtual Task SendAsync(ArraySegment<byte> message, WebSocketMessageType messageType, bool endOfMessage = true)
{
if (WebSocket.State != WebSocketState.Open)
{
return TaskAsyncHelper.Empty;
}
var sendContext = new SendContext(this, message, messageType, endOfMessage);
return _sendQueue.Enqueue(async state =>
{
var context = (SendContext)state;
if (context.Handler.WebSocket.State != WebSocketState.Open)
{
return;
}
try
{
await context.Handler.WebSocket.SendAsync(context.Message, context.MessageType, context.EndOfMessage, CancellationToken.None);
}
catch (Exception ex)
{
// Swallow exceptions on send
Trace.TraceError("Error while sending: " + ex);
}
},
sendContext);
}
public override Task Send(PersistentResponse response)
{
OnSendingResponse(response);
var context = new SendContext(this, response);
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
return EnqueueOperation(state => PerformSend(state), context);
}
/// <summary>
/// Returns a stream with the encryption bits in place to ensure proper message encryption
/// </summary>
/// <param name="provider">The crypto stream provider</param>
/// <param name="stream">The original stream to which the encrypted message content is written</param>
/// <param name="context">The second context of the message</param>
/// <returns>A stream for serializing the message which will be encrypted</returns>
public static Stream GetEncryptStream(this ICryptoStreamProvider provider, Stream stream, SendContext context)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
object keyIdObj;
string keyId = context.Headers.TryGetHeader(EncryptedMessageSerializer.EncryptionKeyHeader, out keyIdObj)
? keyIdObj.ToString()
: default(string);
return provider.GetEncryptStream(stream, keyId, CryptoStreamMode.Write);
}
Task IFilter <SendContext <T> > .Send(SendContext <T> context, IPipe <SendContext <T> > next)
{
var transformContext = new SendTransformContext <T>(context);
TransformResult <T> result = _transform.ApplyTo(transformContext);
if (result.IsNewValue)
{
var transformedContext = context.CreateProxy(result.Value);
return(next.Send(transformedContext));
}
return(next.Send(context));
}
static Header[] GetHeaders <T>(SendContext context)
{
var headers = new List <Header>();
headers.Add(MessageTypeKey, new MessageUrn(typeof(T)));
headers.Add(new Header(PolymorphicMessageTypesKey, string.Join(";", TypeMetadataCache <T> .MessageTypeNames)));
if (context.CorrelationId.HasValue)
{
headers.Add(RequestIdKey, context.CorrelationId.Value.ToString());
}
if (context.RequestId.HasValue)
{
headers.Add(RequestIdKey, context.RequestId.Value.ToString());
}
if (context.ConversationId.HasValue)
{
headers.Add(ConversationIdKey, context.ConversationId.Value.ToString());
}
if (context.InitiatorId.HasValue)
{
headers.Add(InitiatorIdKey, context.InitiatorId.Value.ToString());
}
headers.Add(SourceAddressKey, context.SourceAddress);
headers.Add(DestinationAddressKey, context.DestinationAddress);
if (context.ResponseAddress != null)
{
headers.Add(ResponseAddressKey, context.ResponseAddress);
}
if (context.FaultAddress != null)
{
headers.Add(FaultAddressKey, context.FaultAddress);
}
if (context.TimeToLive.HasValue)
{
headers.Add(ExpirationTimeKey, DateTime.UtcNow + context.TimeToLive.Value);
}
headers.Add(SentTimeKey, DateTime.UtcNow);
headers.Add(new Header(HostInfoKey, HostMetadataCache.Host));
return(headers.ToArray());
}
public JsonMessageEnvelope CreateJsonMessageEnvelope <T>(SendContext <T> context) where T : class
{
var container = context.Message as MessageContainer;
if (container == null)
{
throw new ArgumentException("Message must be MessageContainer type");
}
var separatorIndex = container.MessageType.LastIndexOf('.');
var classNamespace = container.MessageType.Substring(0, separatorIndex);
var className = container.MessageType.Substring(separatorIndex + 1);
var messageType = $"urn:message:{classNamespace}:{className}";
return(new JsonMessageEnvelope(context, container.Message, new[] { messageType }));
}
public static Error ProcessOnSend(
ILayerStack layerStack, MessageType messageType, SendContext sendContext, out IBonded layerData, Logger logger)
{
Error error = null;
layerData = null;
if (layerStack != null)
{
error = layerStack.OnSend(messageType, sendContext, out layerData);
if (error != null)
{
logger.Site().Warning("Layer error occurred sending message of type {0} (Code: {1} Message: {2}).",
messageType, error.error_code, error.message);
}
}
return error;
}
public JsonMessageEnvelope(SendContext context, object message, string[] messageTypeNames)
{
if (context.MessageId.HasValue)
MessageId = context.MessageId.Value.ToString();
if (context.RequestId.HasValue)
RequestId = context.RequestId.Value.ToString();
if (context.CorrelationId.HasValue)
CorrelationId = context.CorrelationId.Value.ToString();
if (context.ConversationId.HasValue)
ConversationId = context.ConversationId.Value.ToString();
if (context.InitiatorId.HasValue)
InitiatorId = context.InitiatorId.Value.ToString();
if (context.SourceAddress != null)
SourceAddress = context.SourceAddress.ToString();
if (context.DestinationAddress != null)
DestinationAddress = context.DestinationAddress.ToString();
if (context.ResponseAddress != null)
ResponseAddress = context.ResponseAddress.ToString();
if (context.FaultAddress != null)
FaultAddress = context.FaultAddress.ToString();
MessageType = messageTypeNames;
Message = message;
if (context.TimeToLive.HasValue)
ExpirationTime = DateTime.UtcNow + context.TimeToLive;
Headers = new Dictionary<string, object>();
foreach (var header in context.Headers.GetAll())
Headers[header.Key] = header.Value;
Host = HostMetadataCache.Host;
}
static void SetRawJsonMessageHeaders <T>(SendContext context)
where T : class
{
if (context.MessageId.HasValue)
{
context.Headers.Set(MessageHeaders.MessageId, context.MessageId.Value.ToString());
}
if (context.CorrelationId.HasValue)
{
context.Headers.Set(MessageHeaders.CorrelationId, context.CorrelationId.Value.ToString());
}
if (context.ConversationId.HasValue)
{
context.Headers.Set(MessageHeaders.ConversationId, context.ConversationId.Value.ToString());
}
context.Headers.Set(MessageHeaders.MessageType, string.Join(";", TypeMetadataCache <T> .MessageTypeNames));
if (context.ResponseAddress != null)
{
context.Headers.Set(MessageHeaders.ResponseAddress, context.ResponseAddress);
}
if (context.FaultAddress != null)
{
context.Headers.Set(MessageHeaders.FaultAddress, context.FaultAddress);
}
if (context.InitiatorId.HasValue)
{
context.Headers.Set(MessageHeaders.InitiatorId, context.InitiatorId.Value.ToString());
}
if (context.SourceAddress != null)
{
context.Headers.Set(MessageHeaders.SourceAddress, context.SourceAddress);
}
context.Headers.Set(MessageHeaders.ContentType, ContentTypeHeaderValue);
context.Headers.Set(MessageHeaders.Host.Info, JsonConvert.SerializeObject(HostMetadataCache.Host, Formatting.None));
}
public void The_endpoint_consumer_should_be_returned()
{
var endpoint = MockRepository.GenerateMock<IEndpoint>();
endpoint.Stub(x => x.Address.Uri).Return(new Uri("msmq://localhost/queue_name"));
_pipeline.ConnectEndpoint<PingMessage>(endpoint);
PipelineViewer.Trace(_pipeline);
var message = new PingMessage();
var context = new SendContext<PingMessage>(message);
endpoint.Expect(x => x.Send(context)).IgnoreArguments();
_pipeline.Dispatch(message);
endpoint.VerifyAllExpectations();
}
internal Task SendAsync(ArraySegment<byte> message, WebSocketMessageType messageType, bool endOfMessage = true)
{
if (_isClosed)
{
return TaskAsyncHelper.Empty;
}
var sendContext = new SendContext(this, message, messageType, endOfMessage);
return _sendQueue.Enqueue(state =>
{
var context = (SendContext)state;
if (context.Handler._isClosed)
{
return TaskAsyncHelper.Empty;
}
return context.Handler.WebSocket.SendAsync(context.Message, context.MessageType, context.EndOfMessage, CancellationToken.None);
},
sendContext);
}
protected override Task Send(int streamIndex, IList<Message> messages)
{
var context = new SendContext(_key, messages, _connection);
// Increment the channel number
return _connection.Strings.Increment(_db, _key)
.Then((id, ctx) =>
{
byte[] data = RedisMessage.ToBytes(id, ctx.Messages);
return ctx.Connection.Publish(ctx.Key, data);
},
context);
}
public Task Send(Func<object, Task> send, object state)
{
lock (_lockObj)
{
if (_error != null)
{
throw _error;
}
// If the queue is closed then stop sending
if (_state == StreamState.Closed)
{
throw new InvalidOperationException(Resources.Error_StreamClosed);
}
var context = new SendContext(this, send, state);
if (_initializeDrainTask != null && !_initializeDrainTask.IsCompleted)
{
// Wait on the draining of the queue before proceeding with the send
// NOTE: Calling .Wait() here is safe because the task wasn't created on an ASP.NET request thread
// and thus has no captured sync context
_initializeDrainTask.Wait();
}
if (UsingTaskQueue)
{
Task task = _queue.Enqueue(Send, context);
if (task == null)
{
// The task is null if the queue is full
throw new InvalidOperationException(Resources.Error_TaskQueueFull);
}
// Always observe the task in case the user doesn't handle it
return task.Catch(_logger);
}
return Send(context);
}
}
public void Send(EndPoint endPoint, byte[] buffer, int offset, int count)
{
_logger.Debug("Sending " + count + " bytes to " + endPoint + ":\r\n" +
Encoding.ASCII.GetString(buffer, 0, count));
var context = new SendContext(endPoint, buffer);
_socket.BeginSendTo(buffer, 0, count, SocketFlags.None, endPoint, OnSendComplete,
context);
}
public Task Send(int streamIndex, IList<Message> messages)
{
var context = new SendContext(this, streamIndex, messages);
return _streams[streamIndex].Send(state => Send(state), context);
}
void Data (FormatOptions options, MimeMessage message, CancellationToken cancellationToken, ITransferProgress progress)
{
var response = SendCommand ("DATA", cancellationToken);
if (response.StatusCode != SmtpStatusCode.StartMailInput)
throw new SmtpCommandException (SmtpErrorCode.UnexpectedStatusCode, response.StatusCode, response.Response);
if (progress != null) {
var ctx = new SendContext (progress, null);
using (var stream = new ProgressStream (Stream, ctx.Update)) {
using (var filtered = new FilteredStream (stream)) {
filtered.Add (new SmtpDataFilter ());
message.WriteTo (options, filtered, cancellationToken);
filtered.Flush ();
}
}
} else {
using (var filtered = new FilteredStream (Stream)) {
filtered.Add (new SmtpDataFilter ());
message.WriteTo (options, filtered, cancellationToken);
filtered.Flush ();
}
}
Stream.Write (EndData, 0, EndData.Length, cancellationToken);
Stream.Flush (cancellationToken);
response = Stream.ReadResponse (cancellationToken);
switch (response.StatusCode) {
default:
throw new SmtpCommandException (SmtpErrorCode.MessageNotAccepted, response.StatusCode, response.Response);
case SmtpStatusCode.AuthenticationRequired:
throw new ServiceNotAuthenticatedException (response.Response);
case SmtpStatusCode.Ok:
OnMessageSent (new MessageSentEventArgs (message, response.Response));
break;
}
}
void Bdat (FormatOptions options, MimeMessage message, CancellationToken cancellationToken, ITransferProgress progress)
{
long size;
using (var measure = new MeasuringStream ()) {
message.WriteTo (options, measure, cancellationToken);
size = measure.Length;
}
var bytes = Encoding.UTF8.GetBytes (string.Format ("BDAT {0} LAST\r\n", size));
Stream.Write (bytes, 0, bytes.Length, cancellationToken);
if (progress != null) {
var ctx = new SendContext (progress, size);
using (var stream = new ProgressStream (Stream, ctx.Update)) {
message.WriteTo (options, stream, cancellationToken);
stream.Flush (cancellationToken);
}
} else {
message.WriteTo (options, Stream, cancellationToken);
Stream.Flush (cancellationToken);
}
var response = Stream.ReadResponse (cancellationToken);
switch (response.StatusCode) {
default:
throw new SmtpCommandException (SmtpErrorCode.MessageNotAccepted, response.StatusCode, response.Response);
case SmtpStatusCode.AuthenticationRequired:
throw new ServiceNotAuthenticatedException (response.Response);
case SmtpStatusCode.Ok:
OnMessageSent (new MessageSentEventArgs (message, response.Response));
break;
}
}
public void TransportSendAndReceive()
{
using (var management = new RabbitMqEndpointManagement(_queue))
{
management.BindQueue(_queue.Name, _exchange.Name, ExchangeType.Fanout, "", null);
}
IOutboundTransport t = _factory.BuildOutbound(new TransportSettings(_exchange));
var context = new SendContext<string>("dru");
context.SetBodyWriter(stream =>
{
byte[] buffer = Encoding.UTF8.GetBytes(context.Message);
stream.Write(buffer, 0, buffer.Length);
});
t.Send(context);
IInboundTransport i = _factory.BuildInbound(new TransportSettings(_queue));
i.Receive(s =>
{
return ss =>
{
string name;
using (var stream = new MemoryStream())
{
ss.CopyBodyTo(stream);
name = Encoding.UTF8.GetString(stream.ToArray());
}
Assert.AreEqual("dru", name);
Console.WriteLine(name);
};
}, 1.Minutes());
}
public Task Send(Func<object, Task> send, object state)
{
lock (_lockObj)
{
if (_error != null)
{
throw _error;
}
// If the queue is closed then stop sending
if (_state == StreamState.Closed)
{
throw new InvalidOperationException(Resources.Error_StreamClosed);
}
if (_state == StreamState.Initial)
{
throw new InvalidOperationException(Resources.Error_StreamNotOpen);
}
var context = new SendContext(this, send, state);
if (UsingTaskQueue)
{
Task task = _queue.Enqueue(Send, context);
if (task == null)
{
// The task is null if the queue is full
throw new InvalidOperationException(Resources.Error_TaskQueueFull);
}
// Always observe the task in case the user doesn't handle it
return task.Catch();
}
_perfCounters.ScaleoutSendQueueLength.Increment();
return Send(context).Finally(counter =>
{
((IPerformanceCounter)counter).Decrement();
},
_perfCounters.ScaleoutSendQueueLength);
}
}
