public async Task <RabbitConsumer> SetupChannel(string queue, bool retryOnFailure = true)
{
RabbitConsumer consumer = null;
if (await EnsureConnection())
{
try
{
_channel = _connection.CreateModel();
consumer = new RabbitConsumer(_channel, _queueName);
var queueBinding = await GetBinding(queue);
_channel.ExchangeDeclare(queueBinding.source, ExchangeType.Topic);
_channel.QueueDeclare(queue: $"Mirror{queue}", durable: true, exclusive: false, autoDelete: false, arguments: null);
_channel.QueueBind(queue: $"Mirror{queue}",
exchange: queueBinding.source,
routingKey: queueBinding.routing_key);
_channel.BasicQos(0, 1000, global: false);
_channel.BasicConsume(queue: $"Mirror{queue}", autoAck: true, consumer: consumer);
_channel.CallbackException += async(sender, ea) =>
{
_channel.Dispose();
if (retryOnFailure)
{
await SetupChannel(queue, false);
}
};
}
catch (Exception ex)
{
throw;
}
}
return(consumer);
}
private void startMq(String ageintId)
{
RabbitConsumer.Connect(ageintId);
RabbitConsumer.ConsumeMessagesStart(ageintId);
bgAgentWorker = new BackgroundWorker();
//ReportProgress메소드를 호출하기 위해서 반드시 true로 설정, false일 경우 ReportProgress메소드를 호출하면 exception 발생
bgAgentWorker.WorkerReportsProgress = true;
//스레드에서 취소 지원 여부
bgAgentWorker.WorkerSupportsCancellation = true;
//스레드가 run시에 호출되는 핸들러 등록
bgAgentWorker.DoWork += new DoWorkEventHandler(bw_DoWork);
// ReportProgress메소드 호출시 호출되는 핸들러 등록
bgAgentWorker.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
// 스레드 완료(종료)시 호출되는 핸들러 동록
bgAgentWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
bgAgentWorker.RunWorkerAsync();
/* Mq 수신 시작 알림 */
MqSendHealthVo msVo = new MqSendHealthVo();
msVo.agent_id = ageintId;
msVo.agent_status = "IDLE";
msVo.res_typ = "RES";
RabbitProducer.Connect();
RabbitProducer.MqSendMessages(ageintId, msVo.toJson());
RabbitProducer.Disconnect();
logger.Info("agent_id : " + msVo.agent_id + " IDLE.. ");
startAgent.Text = "STOP";
this.Visible = false;
trayIcon.Visible = true;
}
public async Task <RabbitConsumer> InitConsumer(string queueName)
{
RabbitConsumer consumer = null;
_queueName = queueName;
if (!await EnsureConnection())
{
throw new Exception("Failed asablishing connection with RabbitMQ");
}
try
{
consumer = await Consume(_queueName);
}
catch (Exception)
{
throw;
}
return(consumer);
}
public void ShouldInvokeConsumer()
{
// GIVEN
var serviceCollectionFactory = new ServiceCollection();
// Make singleton so we can assert that the method ran
serviceCollectionFactory.AddSingleton <ConsumerController>();
serviceCollectionFactory.AddTransient <IByteConversionService, ByteConversionService>();
serviceCollectionFactory.AddTransient <IInvocationParameterService, InvocationParameterService>();
var serviceCollection = serviceCollectionFactory.BuildServiceProvider();
var consumerMethod = new ConsumerMethod(
typeof(ConsumerController).GetMethod("Consume"),
typeof(ConsumerController),
new RabbitConsumerAttribute("consumerQueue"),
null
);
var mockModel = new Mock <IModel>();
var logger = TestLogger.CreateXUnit <RabbitConsumer>(this.output);
var eventArgs = new BasicDeliverEventArgs();
// WHEN
var rabbitConsumer = new RabbitConsumer(
consumerMethod,
mockModel.Object,
null,
serviceCollection,
logger
);
rabbitConsumer.RecievedEventHandler(null, eventArgs);
// THEN
var service = serviceCollection.GetRequiredService <ConsumerController>();
Assert.True(service.ConsumeCalled);
}
public async Task StopConsumeAsync_Test()
{
var consumer = new RabbitConsumer(_connection, _serviceName, _topicName, MessageHandler,
() => { }, false, 100, _options, _logger);
await consumer.StartConsumeAsync(_cancellationTokenSource.Token);
Assert.IsTrue(consumer.IsStarted);
// first stop
consumer.AbortConsume();
A.CallTo(() => _rabbitChannel.BasicCancel(_consumerTag))
.MustHaveHappenedOnceExactly();
Assert.IsFalse(consumer.IsStarted);
// does not repeat execution if stopped multiple times
consumer.AbortConsume();
A.CallTo(() => _rabbitChannel.BasicCancel(_consumerTag))
.MustHaveHappenedOnceExactly();
Assert.IsFalse(consumer.IsStarted);
}
public void ShouldPublishToConfiguredExchange()
{
// GIVEN - A consumer which will publish the returned value
var routingKeyConfigKey = "Config:Key:For:RoutingKey";
var routingKeyConfigVal = "routingKey";
var exchangeNameConfigKey = "Config:Key:For:ExchangeName";
var exchangeNameConfigVal = "exchangeName";
var configDict = new Dictionary <string, string>()
{
{ routingKeyConfigKey, routingKeyConfigVal },
{ exchangeNameConfigKey, exchangeNameConfigVal }
};
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(configDict)
.Build();
var serviceCollectionFactory = new ServiceCollection();
// Make singleton so we can assert that the method ran
serviceCollectionFactory.AddSingleton <ConsumerController>(new ConsumerController(returnValue: "returnValue"));
serviceCollectionFactory.AddTransient <IByteConversionService, ByteConversionService>();
serviceCollectionFactory.AddTransient <IInvocationParameterService, InvocationParameterService>();
var serviceCollection = serviceCollectionFactory.BuildServiceProvider();
var consumerMethod = new ConsumerMethod(
typeof(ConsumerController).GetMethod("Consume"),
typeof(ConsumerController),
new RabbitConsumerAttribute(
queueName: "consumerQueue",
acknowledgementType: AcknowledgementType.AutoAck,
nackOnException: true),
new RabbitPublisherAttribute(
routingKey: "{" + routingKeyConfigKey + "}",
exchangeName: "{" + exchangeNameConfigKey + "}"
)
);
var mockModel = new Mock <IModel>();
var logger = TestLogger.CreateXUnit <RabbitConsumer>(this.output);
var eventArgs = new BasicDeliverEventArgs()
{
DeliveryTag = 99
};
// WHEN - The consumer consumes a message
var rabbitConsumer = new RabbitConsumer(
consumerMethod,
mockModel.Object,
configuration,
serviceCollection,
logger
);
rabbitConsumer.RecievedEventHandler(null, eventArgs);
// THEN - Ack should be called but it will throw exception so nack will be called
var service = serviceCollection.GetRequiredService <ConsumerController>();
Assert.True(service.ConsumeCalled);
mockModel.Verify(m => m.BasicConsume(
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <EventingBasicConsumer>()
)
);
mockModel.Verify(m => m.BasicPublish(
It.Is <string>(s => s == exchangeNameConfigVal),
It.Is <string>(s => s == routingKeyConfigVal),
It.IsAny <bool>(),
It.IsAny <IBasicProperties>(),
It.IsAny <byte[]>()
));
mockModel.VerifyNoOtherCalls();
}
public void ShouldNackOnInvocationException()
{
// GIVEN - An ack on invoke consumer, throw exception when acking
ulong deliveryTag = 99;
var serviceCollectionFactory = new ServiceCollection();
// Make singleton so we can assert that the method ran
serviceCollectionFactory.AddSingleton <ConsumerController>(new ConsumerController(throwException: true));
//serviceCollectionFactory.AddSingleton<ConsumerController>();
serviceCollectionFactory.AddTransient <IByteConversionService, ByteConversionService>();
serviceCollectionFactory.AddTransient <IInvocationParameterService, InvocationParameterService>();
var serviceCollection = serviceCollectionFactory.BuildServiceProvider();
var consumerMethod = new ConsumerMethod(
typeof(ConsumerController).GetMethod("Consume"),
typeof(ConsumerController),
new RabbitConsumerAttribute(
queueName: "consumerQueue",
acknowledgementType: AcknowledgementType.AckOnPublish,
nackOnException: true),
null
);
var mockModel = new Mock <IModel>();
var logger = TestLogger.CreateXUnit <RabbitConsumer>(this.output);
var eventArgs = new BasicDeliverEventArgs()
{
DeliveryTag = deliveryTag
};
// WHEN - The consumer consumes a message
var rabbitConsumer = new RabbitConsumer(
consumerMethod,
mockModel.Object,
null,
serviceCollection,
logger
);
Assert.Throws <TargetInvocationException>(() => {
rabbitConsumer.RecievedEventHandler(null, eventArgs);
});
// THEN - Ack should be called but it will throw exception so nack will be called
var service = serviceCollection.GetRequiredService <ConsumerController>();
Assert.True(service.ConsumeCalled);
mockModel.Verify(m => m.BasicConsume(
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(),
It.IsAny <EventingBasicConsumer>()
)
);
mockModel.Verify(m => m.BasicNack(
It.Is <ulong>(l => l == deliveryTag),
It.IsAny <bool>(),
It.IsAny <bool>()
));
mockModel.VerifyNoOtherCalls();
}
public void RunConsumer(string queueName)
{
consumer = new RabbitConsumer <string>(queueName);
consumer.DequeueMessageDel = OnGetMessageFromGenerator;
consumer.ProcessMessages();
}
private static void MessageStuff()
{
var config = new RabbitConsumerConfig()
{
ExchangeBindings = new List <ExchangeBinding>()
{
new ExchangeBinding
{
RoutingKey = "billing.account.create",
ExchangeName = "Billing"
},
new ExchangeBinding
{
RoutingKey = "billing.account.delete",
ExchangeName = "Billing"
},
new ExchangeBinding
{
RoutingKey = "policy.term.created",
ExchangeName = "Policy"
}
},
QueueName = "PrototypeQueue",
HostName = "10.0.0.190",
UserName = "******",
Password = "******",
Port = 5672
};
var account = new CreateAccount
{
AccountName = "Account Name",
Amount = 10.20m,
CorrelationId = "1234"
};
var deleteAccount = new AccountDelete()
{
CorrelationId = "1234",
AccountId = 2
};
var stringValue = JsonConvert.SerializeObject(deleteAccount);
var factory = new MessageFactory(MessageMap.GetMessageMap());
UnityContainer container = new UnityContainer();
container.RegisterType <IMessageHandler <CreateAccount>, CreateAccountHandler>();
var handler = new CreateAccountHandler();
var badHandler = new DeleteAccountHandler();
var dispatcher = new MessageDispatcher();
dispatcher.RegisterHandler(handler);
dispatcher.RegisterHandler(badHandler);
dispatcher.Register <CreateAccount>((i) =>
{
System.Console.WriteLine($"From Action account Name {i.AccountName}");
});
var consumer = new RabbitConsumer(config, factory, dispatcher);
string value = string.Empty;
while (value != "exit")
{
value = System.Console.ReadLine();
}
consumer.Dispose();
}
public static void LogRollback(
this ISilverbackLogger logger,
string deliveryTag,
RabbitConsumer consumer) =>
Rollback(logger.InnerLogger, deliveryTag, consumer.Id, consumer.Endpoint.DisplayName, null);
public bool AddConnection(string clientId, RabbitConsumer consumer)
{
_consumers[clientId] = consumer;
return(true);
}
public void DirectExchangeTest()
{
Dictionary <string, int> dict = new Dictionary <string, int>(); //接收的消息数量
Dictionary <string, int> expectedDict = new Dictionary <string, int>(); //发送的消息数量
string[] queues = new string[] { $"integration.{queue1}.direct", $"integration.{queue2}.direct" };
var routeQueues = queues.Select(f => new RouteQueue()
{
Arguments = null,
Queue = f,
Route = f,
Options = new QueueOptions()
{
AutoDelete = true,
Durable = true,
Arguments = arguments
}
}).ToArray();
//消费
var consumer = new RabbitConsumer(hosts)
{
Password = password,
Port = port,
UserName = userName,
VirtualHost = virtualHost
};
foreach (var queue in queues)
{
dict[queue] = 0;
expectedDict[queue] = 0;
consumer.Listen(direct, queue, new ExchangeConsumeQueueOptions()
{
Arguments = arguments,
AutoAck = false,
AutoDelete = true,
Durable = true,
FetchCount = 1,
RouteQueues = routeQueues,
Type = RabbitExchangeType.Direct
}, result =>
{
Output.WriteLine($"{queue}:" + result.Body);
dict[queue]++;
result.Commit();
});
}
//发布
var producer = new RabbitProducer(hosts)
{
Password = password,
Port = port,
UserName = userName,
VirtualHost = virtualHost
};
for (var i = 0; i < queues.Length; i++)
{
var queue = queues[i];
expectedDict[queue]++;
producer.Publish(direct, queue, "direct" + i, new ExchangeQueueOptions()
{
Arguments = arguments,
AutoDelete = true,
Durable = true,
RouteQueues = routeQueues,
Type = RabbitExchangeType.Direct
});
}
BlockUntil(() => dict.Sum(f => f.Value) >= queues.Length, 3000);
producer.Dispose();
consumer.Dispose();
foreach (var queue in queues)
{
Output.WriteLine($"{queue}:{expectedDict[queue]}-{dict[queue]}");
Assert.Equal(expectedDict[queue], dict[queue]);
}
}
//스레드의 run함수가 종료될 경우 해당 핸들러가 호출됩니다.
private void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
RabbitConsumer.DisConnect();
logger.Info(" RabbitConsumer.DisConnect ");
}
private static void Init()
{
Types[typeof(IProducer)] = new RabbitProducer();
Types[typeof(IConsumer)] = new RabbitConsumer();
isInit = true;
}
public static void LogCommit(
this ISilverbackLogger logger,
string deliveryTag,
RabbitConsumer consumer) =>
Commit(logger.InnerLogger, deliveryTag, consumer.Id, consumer.Endpoint.Name, null);
