/// <summary>
/// Creates this instance.
/// </summary>
/// <returns></returns>
public IService Create()
{
MessageBuilderFactory.CreateDefaultBuilder();
var listener = ListenerFactory.Create(_input, _handlerRepository);
return(new MonitorListener(listener));
}
protected virtual IMessage <T> BuildMessage(object result)
{
if (result == null)
{
return(null);
}
IMessage message = null;
var headers = EvaluateHeaders();
if (result is AbstractMessageBuilder)
{
if (headers != null && headers.Count > 0)
{
((AbstractMessageBuilder)result).CopyHeaders(headers);
}
message = ((AbstractMessageBuilder)result).Build();
}
else if (result is IMessage)
{
message = (IMessage)result;
if (headers != null && headers.Count > 0)
{
// create a new Message from this one in order to apply headers
message = MessageBuilderFactory.FromMessage(message).CopyHeaders(headers).Build();
}
}
else
{
message = MessageBuilderFactory.WithPayload(result).CopyHeaders(headers).Build();
}
return((IMessage <T>)message);
}
protected override object DoReceive()
{
var connection = ConnectionFactory.CreateConnection();
var channel = connection.CreateChannel(Transacted);
try
{
var resp = channel.BasicGet(QueueName, false);
if (resp == null)
{
RabbitUtils.CloseChannel(channel);
RabbitUtils.CloseConnection(connection);
return(null);
}
var callback = AckCallbackFactory.CreateCallback(new RabbitAckInfo(connection, channel, Transacted, resp));
var envelope = new Envelope(resp.DeliveryTag, resp.Redelivered, resp.Exchange, resp.RoutingKey);
var messageProperties = MessageHeaderConverter.ToMessageHeaders(resp.BasicProperties, envelope, EncodingUtils.Utf8);
var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
accessor.ConsumerQueue = this.QueueName;
// Map<String, Object> headers = this.headerMapper.toHeadersFromRequest(messageProperties);
var message = Message.Create <byte[]>(resp.Body, accessor.MessageHeaders);
object payload;
if (BatchingStrategy.CanDebatch(message.Headers))
{
var payloads = new List <object>();
BatchingStrategy.DeBatch(message, fragment => payloads.Add(MessageConverter.FromMessage(fragment, null)));
payload = payloads;
}
else
{
payload = MessageConverter.FromMessage(message, null);
}
var builder = MessageBuilderFactory.WithPayload(payload)
.CopyHeaders(accessor.MessageHeaders)
.SetHeader(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK, callback);
if (RawMessageHeader)
{
builder.SetHeader(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, message);
builder.SetHeader(IntegrationMessageHeaderAccessor.SOURCE_DATA, message);
}
return(builder);
}
catch (Exception e)
{
RabbitUtils.CloseChannel(channel);
RabbitUtils.CloseConnection(connection);
throw RabbitExceptionTranslator.ConvertRabbitAccessException(e);
}
}
public void CreateBuilderForKnownEvent()
{
// arrange //
IEvent e = new AddDataEvent();
IMessageBuilderFactory builderFactory = new MessageBuilderFactory();
// act //
var builder = builderFactory.GetMessageBuilder(e);
// assert // Сравниваем по типу
Assert.Equal(typeof(AddDataMessageBuilder), builder.GetType());
}
public void CreateBuilderForUnknownEvent()
{
// arrange //
IEvent e = new FakeEvent();
IMessageBuilderFactory builderFactory = new MessageBuilderFactory();
// act //
var builder = builderFactory.GetMessageBuilder(e);
// assert // Проверрка на null
Assert.Null(builder);
// Assert.NotNull(builder);
}
/// <summary>
/// Creates the router control processor.
/// </summary>
/// <param name="identification">The identification.</param>
/// <param name="inputGateway">The input gateway.</param>
/// <param name="handlerRepository">The handler repository.</param>
/// <param name="subscriptorsHelper">The subscriptors helper.</param>
/// <returns></returns>
public static IController CreateRouterControlProcessor(Identification identification,
IInputGateway <IControlMessage, MessageHeader> inputGateway,
IHandlerRepository handlerRepository,
ISubscriptorsHelper subscriptorsHelper)
{
IMessageBuilder defaultObjectBuilder = MessageBuilderFactory.CreateDefaultBuilder();
return(new RouterControlProcessor(identification, inputGateway, handlerRepository, subscriptorsHelper,
defaultObjectBuilder)
{
Logger = LoggerManager.Instance
});
}
/// <summary>
/// Creates the control processor.
/// </summary>
/// <param name="identification">The identification.</param>
/// <param name="inputGateway">The input gateway.</param>
/// <param name="outputGateway">The output gateway.</param>
/// <param name="handlerRepository">The handler repository.</param>
/// <returns></returns>
public static IController CreateControlProcessor(Identification identification,
IInputGateway <IControlMessage, MessageHeader> inputGateway,
IOutputGateway <IControlMessage> outputGateway,
IHandlerRepository handlerRepository)
{
return(new ControlProcessor(identification,
inputGateway,
outputGateway,
handlerRepository,
MessageBuilderFactory.CreateDefaultBuilder(),
ReinjectionEngineFactory.CreateDefaultEngine(inputGateway))
{
Logger = LoggerManager.Instance
});
}
protected override object DoTransform(IMessage message)
{
var headers = message.Headers;
var removeHeaders = false;
var targetClass = ObtainResolvableTypeFromHeadersIfAny(headers);
if (targetClass == null)
{
targetClass = TargetType;
}
else
{
removeHeaders = true;
}
var payload = message.Payload;
object result = null;
if (payload is string)
{
result = JsonConvert.DeserializeObject((string)payload, targetClass, Settings);
}
else if (payload is byte[])
{
var contentAsString = DefaultCharset.GetString((byte[])payload);
result = JsonConvert.DeserializeObject(contentAsString, targetClass, Settings);
}
else
{
throw new MessageConversionException("Failed to convert Message content, message missing byte[] or string: " + payload.GetType());
}
if (removeHeaders)
{
return(MessageBuilderFactory
.WithPayload(result)
.CopyHeaders(headers)
.RemoveHeaders(MessageHeaders.TYPE_ID, MessageHeaders.CONTENT_TYPE_ID, MessageHeaders.KEY_TYPE_ID)
.Build());
}
return(result);
}
protected virtual IMessage <T> BuildMessage(object result)
{
if (result == null)
{
return(null);
}
var headers = EvaluateHeaders();
IMessage message;
switch (result)
{
case AbstractMessageBuilder amBuilder:
if (headers != null && headers.Count > 0)
{
amBuilder.CopyHeaders(headers);
}
message = amBuilder.Build();
break;
case IMessage mResult:
message = mResult;
if (headers != null && headers.Count > 0)
{
// create a new Message from this one in order to apply headers
message = MessageBuilderFactory.FromMessage(message).CopyHeaders(headers).Build();
}
break;
default:
message = MessageBuilderFactory.WithPayload(result).CopyHeaders(headers).Build();
break;
}
return((IMessage <T>)message);
}
protected override object DoTransform(IMessage message)
{
var payload = BuildJsonPayload(message.Payload);
var accessor = MessageHeaderAccessor.GetMutableAccessor(message);
var contentType = accessor.ContentType;
if (string.IsNullOrEmpty(contentType))
{
accessor.ContentType = ContentType;
}
var headers = accessor.MessageHeaders;
_defaultTypeMapper.FromType(message.Payload.GetType(), headers);
if (ResultType == typeof(string))
{
return(MessageBuilderFactory.WithPayload <string>((string)payload).CopyHeaders(headers).Build());
}
else
{
return(MessageBuilderFactory.WithPayload <byte[]>((byte[])payload).CopyHeaders(headers).Build());
}
}
static ConfigurationMessageBuilder()
{
MessageBuilder = MessageBuilderFactory.CreateDefaultBuilder(ObjectBuilderFactory.DefaultObjectBuilder());
}
public void Setup()
{
_receiverEndPoint = new Mock <IReceiverEndPoint>();
MessageBuilderFactory.CreateDefaultBuilder();
}
/// <summary>
/// Initializes a new instance of the <see cref="AgentFake"/> class.
/// </summary>
/// <param name="identification">The identification.</param>
/// <param name="inputGateway">The input gateway.</param>
/// <param name="handlerRepository">The handler repository.</param>
public AgentFake(Identification identification, IInputGateway <IMessage, MessageHeader> inputGateway, IHandlerRepository handlerRepository)
: base(identification, inputGateway, handlerRepository, MessageBuilderFactory.CreateDefaultBuilder(), ReinjectionEngineFactory.CreateDefaultEngine(inputGateway))
{
}
