/// <summary>
/// 开启服务
/// </summary>
/// <param name="config"></param>
private static void OpenRabbitMqService(RabbitMqConfig config)
{
if (_conn != null && _conn.IsOpen)
{
return;
}
lock (LockObj)
{
config.NetworkRecoveryInterval = TimeSpan.FromSeconds(10);
var factory = new ConnectionFactory
{
//设置主机名
HostName = config.Host,
//设置心跳时间
RequestedHeartbeat = config.HeartBeat,
//设置自动重连
AutomaticRecoveryEnabled = config.AutomaticRecoveryEnabled,
//重连时间
NetworkRecoveryInterval = config.NetworkRecoveryInterval,
//用户名
UserName = config.UserName,
//密码
Password = config.Password,
//虚拟主机
VirtualHost = config.VirtualHost
};
_conn = _conn ?? factory.CreateConnection();
}
}
private static void RunHandlerOnMultipleThreads(int noOfThreads, int msgs)
{
using (var mqServer = CreateMqServer()) {
var timesCalled = 0;
RabbitMqConfig.UsingChannel(mqServer.ConnectionFactory, channel => channel.PurgeQueue <Wait>());
object WaitProcessMessageFn(IMqMessage <Wait> m)
{
Interlocked.Increment(ref timesCalled);
Thread.Sleep(m.GetBody().ForMs);
return(null);
}
mqServer.RegisterHandler <Wait>(WaitProcessMessageFn, noOfThreads);
mqServer.Start();
using (var mqClient = mqServer.CreateMessageQueueClient()) {
var dto = new Wait {
ForMs = 100
};
for (var i1 = 0; i1 < msgs; i1++)
{
mqClient.Publish(dto);
}
Thread.Sleep(1000);
Assert.That(timesCalled, Is.EqualTo(msgs));
}
}
}
IBusControl ConfigureBus(IConfigurationRoot configuration)
{
var logFactory = new NLog.LogFactory();
logFactory.LoadConfiguration("nlog.config");
RabbitMqConfig configFromfile = configuration.GetSection("RabbitMq").Get <RabbitMqConfig>();
return(Bus.Factory.CreateUsingRabbitMq(cfg =>
{
cfg.Host(configFromfile.HostUrl, (hostCfg) =>
{
hostCfg.Username(configFromfile.Username);
hostCfg.Password(configFromfile.Password);
});
cfg.ReceiveEndpoint("user_created", e =>
{
e.Consumer <UserCreatedConsumer>(() =>
{
return new UserCreatedConsumer(new Common.LoggerHelper(logFactory.GetLogger("UserCreatedConsumer")));
});
});
}));
}
public void Can_receive_and_process_same_reply_responses()
{
var called = 0;
using (var mqServer = CreateMqServer()) {
RabbitMqConfig.UsingChannel(mqServer.ConnectionFactory, channel => channel.PurgeQueue <Incr>());
Incr ProcessMessageFn(IMqMessage <Incr> m)
{
Console.WriteLine("In Incr #" + m.GetBody().Value);
Interlocked.Increment(ref called);
return(m.GetBody().Value > 0 ? new Incr {
Value = m.GetBody().Value - 1
} : null);
}
mqServer.RegisterHandler <Incr>(ProcessMessageFn);
mqServer.Start();
var incr = new Incr {
Value = 5
};
using (var mqClient = mqServer.CreateMessageQueueClient()) {
mqClient.Publish(incr);
}
Thread.Sleep(1000);
Assert.That(called, Is.EqualTo(1 + incr.Value));
}
}
static void Main(string[] args)
{
Console.Title = "Consumer";
RabbitMqConfig config = new RabbitMqConfig();
config.ExchangeName = "test";
config.HostName = "localhost";
config.Password = "******";
config.UserName = "******";
config.VirtualHost = "/";
ConsumerFactory factory = new ConsumerFactory(config);
var consumer = factory.CreateConsumer("ConsumerId1", true);
consumer.MessageReceive += (sender, e) =>
{
Console.WriteLine($"{sender.ConsumerId}收到消息,Topic:{e.Topic}:Key:{e.Key},Content:{e.Content}");
e.Result = ConsumeResult.Success;
};
Console.WriteLine("请输入要订阅的Topic");
var input = Console.ReadLine();
consumer.Subscribe(input);
Console.ReadKey();
}
/// <summary>
/// 服务注册与系统配置
/// </summary>
/// <param name="cfg"><see cref="IConfiguration"/></param>
/// <param name="services"><see cref="IServiceCollection"/></param>
/// <param name="env"><see cref="IWebHostEnvironment"/></param>
/// <param name="serviceInfo"><see cref="ServiceInfo"/></param>
public SharedServicesRegistration(IConfiguration cfg
, IServiceCollection services
, IWebHostEnvironment env
, ServiceInfo serviceInfo)
{
_cfg = cfg;
_env = env;
_services = services;
_serviceInfo = serviceInfo;
//读取Jwt配置
_jwtConfig = _cfg.GetSection("JWT").Get <JWTConfig>();
//读取mongodb配置
_mongoConfig = _cfg.GetSection("MongoDb").Get <MongoConfig>();
//读取mysql配置
_mysqlConfig = _cfg.GetSection("Mysql").Get <MysqlConfig>();
//读取redis配置
_redisConfig = _cfg.GetSection("Redis").Get <RedisConfig>();
//读取rabbitmq配置
_rabbitMqConfig = _cfg.GetSection("RabbitMq").Get <RabbitMqConfig>();
//读取consul配置
_consulConfig = _cfg.GetSection("Consul").Get <ConsulConfig>();
//读取是否开启SSOAuthentication(单点登录验证)
_isSSOAuthentication = _cfg.GetValue("SSOAuthentication", false);
}
public void Can_consume_messages_from_RabbitMQ_with_BasicGet()
{
RabbitMqConfig.UsingChannel(channel => {
PublishHelloRabbit(channel);
while (true)
{
var basicGetMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Direct, false);
if (basicGetMsg == null)
{
Console.WriteLine("End of the road...");
return;
}
var msg = MqMessageExtensions.FromJsonBytes <HelloRabbit>(basicGetMsg.Body);
Console.WriteLine(msg);
Thread.Sleep(1000);
channel.BasicAck(basicGetMsg.DeliveryTag, false);
}
});
}
public void Can_consume_messages_from_RabbitMQ_with_BasicConsume()
{
RabbitMqConfig.UsingChannel(channel => {
var consumer = new RabbitMqBasicConsumer(channel);
channel.BasicConsume(MqQueueNames <HelloRabbit> .Direct, false, consumer);
string recvMsg = null;
ExecUtils.ExecMultiThreading(1, () => PublishHelloRabbit(channel));
while (true)
{
try {
var e = consumer.Queue.Dequeue();
Console.WriteLine("Dequeued");
recvMsg = e.Body.FromUtf8Bytes();
// ... process the message
Console.WriteLine(recvMsg);
channel.BasicAck(e.DeliveryTag, false);
break;
} catch (OperationInterruptedException) {
// The consumer was removed, either through
// channel or connection closure, or through the
// action of IModel.BasicCancel().
Console.WriteLine("End of the road...");
break;
}
}
Assert.That(recvMsg, Is.Not.Null);
});
}
private void ConfigureRabbitMq(IServiceCollection services, ServiceProvider loggerServicesProvier)
{
var config = new RabbitMqConfig();
Configuration.GetSection("RabbitMq").Bind(config);
var factory = RabbitMqFactory.Create(config);
var cardsConsumer = factory.CreateConsumer(Queues.Cards);
var awaiter = new EventsAwaiter("Cards", loggerServicesProvier.GetService <ILogger <EventsAwaiter> >());
awaiter.BindConsumer(cardsConsumer);
services.AddSingleton(awaiter);
var publishers = new Dictionary <string, IPublisher>();
publishers.Add(Queues.APIGateway, factory.CreatePublisher(Queues.APIGateway));
publishers.Add(Queues.Accounts, factory.CreatePublisher(Queues.Accounts));
publishers.Add(Queues.Transactions, factory.CreatePublisher(Queues.Transactions));
var publishingRouter = new PublishingRouter(publishers);
services.AddSingleton(publishingRouter);
var servicesProvider = services.BuildServiceProvider();
var cardsService = servicesProvider.GetService <CardsService>();
var consumingRouter = ConsumingRouter <CardsService> .Create(cardsService, publishingRouter, "Cards", loggerServicesProvier.GetService <ILogger <IConsumer> >());
consumingRouter.LinkConsumer(cardsConsumer);
services.AddSingleton(consumingRouter);
}
public RabbitMqConnectionManager(RabbitMqConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (config.Vhost == null)
{
throw new ArgumentNullException(nameof(config.Vhost));
}
if (config.User == null)
{
throw new ArgumentNullException(nameof(config.User));
}
if (config.Password == null)
{
throw new ArgumentNullException(nameof(config.Password));
}
if (config.Nodes == null)
{
throw new ArgumentNullException(nameof(config.Nodes));
}
_connectionFactory = new ConnectionFactory
{
VirtualHost = config.Vhost,
UserName = config.User,
Password = config.Password,
DispatchConsumersAsync = true,
AutomaticRecoveryEnabled = true
};
_endpoints = config.Nodes.Select(n => new AmqpTcpEndpoint(n)).ToList();
}
public void Does_publish_to_dead_letter_exchange()
{
RabbitMqConfig.UsingChannel(channel => {
PublishHelloRabbit(channel);
var basicGetMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Direct, true);
var dlqBasicMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Dlq, true);
Assert.That(basicGetMsg, Is.Not.Null);
Assert.That(dlqBasicMsg, Is.Null);
PublishHelloRabbit(channel);
basicGetMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Direct, false);
Thread.Sleep(500);
dlqBasicMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Dlq, false);
Assert.That(basicGetMsg, Is.Not.Null);
Assert.That(dlqBasicMsg, Is.Null);
channel.BasicNack(basicGetMsg.DeliveryTag, false, false);
Thread.Sleep(500);
dlqBasicMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Dlq, true);
Assert.That(dlqBasicMsg, Is.Not.Null);
});
}
public EventBus(IRabbitMQPersistentConnection persistentConnection, ILogger <EventBus> logger, ISubscriptionsManager subscriptionsManager, RabbitMqConfig config)
{
_persistentConnection = persistentConnection ?? throw new ArgumentNullException(nameof(persistentConnection));
_subscriptionsManager = subscriptionsManager ?? throw new ArgumentNullException(nameof(subscriptionsManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_config = config;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSwaggerGenNewtonsoftSupport();
services.AddSwaggerGen(o =>
{
var appXmlName = AppDomain.CurrentDomain.FriendlyName + ".xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, appXmlName);
o.IncludeXmlComments(xmlPath);
});
var rabbitConfig = new RabbitMqConfig()
{
UserName = "******",
Password = "******",
Host = "localhost",
Port = 5672,
VirtualHost = "/",
Exchange = "test"
};
services.AddSingleton(rabbitConfig);
services.AddSingleton <IRabbitConnectionWrapper, RabbitConnectionWrapper>();
services.AddRabbitMq(typeof(AppleCreatedEventHandler).Assembly);
services.AddCommandHandlers(typeof(AppleCommandHandlers).Assembly);
services.AddInternalEventHandlers(typeof(AppleCommandHandlers).Assembly,
typeof(AppleReadModel).Assembly);
services.AddInternalEventPublisher();
services.AddCommandSender();
var eventStoreConfig = new EventStoreConfig();
Configuration.GetSection(nameof(EventStoreConfig)).Bind(eventStoreConfig);
var mongoConfig = new MongoConfig();
Configuration.GetSection(nameof(MongoConfig)).Bind(mongoConfig);
services.AddSingleton <IEventProducer, RabbitMqProducer>();
services.AddEventStoreConfig(eventStoreConfig);
services.AddMongoDb(mongoConfig);
services.ConfigureMongoEventStore();
services.ConfigureRepositories();
var ravenSettings = new RavenSettings();
Configuration.GetSection(nameof(RavenSettings)).Bind(ravenSettings);
services.AddSingleton(ravenSettings);
services.AddRavenDb(ravenSettings);
services.AddQueryHandlers(typeof(AppleReadModel).Assembly);
services.AddQueryProcessor();
services
.AddTransient <IReadModelRepository <AppleReadModel, string>,
RavenReadModelRepository <AppleReadModel, string> >();
services.AddControllers().AddNewtonsoftJson(o =>
{
o.SerializerSettings.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
});
}
/// <summary>
/// 初始化rabbitmq
/// </summary>
/// <param name="container"></param>
/// <param name="config"></param>
private static void InitRabbitMq(ContainerBuilder container, RabbitMqConfig config)
{
if (!config.IsOpen)
{
return;
}
var subscriptionAdapt = new SubscriptionAdapt();
var consumers = Assembly.Load("TTY.GMP.EventConsumer").GetTypes();
foreach (var consumer in consumers)
{
var attributions = consumer.GetCustomAttributes(typeof(QueueConsumerAttribution), false);
if (attributions.Length > 0)
{
var consumerQueue = ((QueueConsumerAttribution)attributions[0]).QueueName;
var consumerSuperClass = consumer.GetInterfaces().FirstOrDefault(d => d.IsGenericType && d.GetGenericTypeDefinition() == typeof(IEventConsumer <>));
if (consumerSuperClass == null)
{
continue;
}
container.RegisterType(consumer).As(consumerSuperClass);
var consumerType = consumerSuperClass.GetGenericArguments().Single();
var methodInfo = typeof(SubscriptionAdapt).GetMethod("SubscribeAt").MakeGenericMethod(new Type[] { consumerType });
var busControl = (IBusControl)methodInfo.Invoke(subscriptionAdapt, new object[] { config.Host, consumerQueue, config.UserName, config.Password });
var publisher = new EventPublisher(busControl);
container.RegisterInstance(publisher).As <IEventPublisher>();
}
}
Console.WriteLine("RabbitMq订阅成功");
}
private void ConfigureRabbitMq(IServiceCollection services)
{
var config = new RabbitMqConfig();
Configuration.GetSection("RabbitMq").Bind(config);
var factory = RabbitMqFactory.Create(config);
var publishers = new Dictionary <string, IPublisher>();
publishers.Add(Queues.APIGateway, factory.CreatePublisher(Queues.APIGateway));
publishers.Add(Queues.Transactions, factory.CreatePublisher(Queues.Transactions));
var publishingRouter = new PublishingRouter(publishers);
services.AddSingleton(new PublishingRouter(publishers));
var servicesProvider = services.BuildServiceProvider();
var logger = servicesProvider.GetService <ILogger <IConsumer> >();
var paymentsService = servicesProvider.GetService <PaymentsService>();
var consumingRouter = ConsumingRouter <PaymentsService> .Create(paymentsService, publishingRouter, "Payments", logger);
var consumer = factory.CreateConsumer(Queues.Payments);
consumingRouter.LinkConsumer(consumer);
services.AddSingleton(consumingRouter);
}
static void Main(string[] args)
{
Console.Title = "Producer";
RabbitMqConfig config = new RabbitMqConfig();
config.ExchangeName = "test";
config.HostName = "localhost";
config.Password = "******";
config.UserName = "******";
config.VirtualHost = "/";
ProducerFactory factory = new ProducerFactory(config);
var producer = factory.CreateProducer("Producer1");
Console.WriteLine("准备就绪");
Console.WriteLine("请输入要发送的消息,格式: Topic,Message。按 Q 退出");
while (true)
{
var input = Console.ReadLine();
if ("Q".Equals(input, StringComparison.OrdinalIgnoreCase))
{
break;
}
var array = input.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length != 2)
{
Console.WriteLine("消息格式错误,请重新输入");
continue;
}
producer.Publish(array[0], Guid.NewGuid().ToString("N"), array[1]);
}
}
public void TestFixtureTearDown()
{
string[] exchangeNames =
{
_exchange,
_exchangeDlq,
_exchangeTopic,
_exchangeFanout,
MqQueueNames.Exchange,
MqQueueNames.ExchangeDlq,
MqQueueNames.ExchangeTopic
};
RabbitMqConfig.UsingChannel(channel => {
foreach (var value in exchangeNames)
{
channel.ExchangeDelete(value);
}
channel.DeleteQueue <AlwaysThrows>();
channel.DeleteQueue <HelloRabbit>();
channel.DeleteQueue <Incr>();
channel.DeleteQueue <Reverse>();
channel.DeleteQueue <NothingHere>();
});
}
static void Main(string[] args)
{
// 1.初始化rabbit配置
RabbitMqConfig.Init();
// 2.消息生成者
MessageSender sender = new MessageSender();
// 3.发送消息
Console.WriteLine("Input a messge to send");
while (true)
{
string messageText = Console.ReadLine();
if (messageText == "q")
{
Console.WriteLine("send message quit");
break;
}
sender.SendMessage(new MessageModel()
{
Content = messageText
});
Console.WriteLine("send finish");
}
Console.ReadLine();
}
public void Does_process_messages_sent_before_it_was_started()
{
var reverseCalled = 0;
using (var mqServer = RabbitMqServerTests.CreateMqServer()) {
void Action0(IModel channel)
{
channel.PurgeQueue <Reverse>();
channel.PurgeQueue <ReverseResponse>();
}
RabbitMqConfig.UsingChannel(mqServer.ConnectionFactory, Action0);
mqServer.RegisterHandler <Reverse>(x => {
Interlocked.Increment(ref reverseCalled);
return(new ReverseResponse {
Value = string.Join(",", x.GetBody().Value.Reverse())
});
});
using (var mqClient = mqServer.CreateMessageQueueClient()) {
RabbitMqServerTests.Publish_4_messages(mqClient);
mqServer.Start();
Thread.Sleep(2000);
Assert.That(mqServer.GetStats().TotalMessagesProcessed, Is.EqualTo(4));
Assert.That(reverseCalled, Is.EqualTo(4));
}
}
}
public void TestRabbitMq()
{
RabbitMqConfig rabbitMqConfig = new RabbitMqConfig
{
Host = "10.10.10.110",
UserName = "******",
Password = "******",
};
RabbitMqService rabbitMqService = new RabbitMqService(rabbitMqConfig);
Task.Factory.StartNew(() =>
{
while (true)
{
rabbitMqService.Publish("test-exchange", "test-queue", "test-exchange", "{\"Data\":\"啊实打实大苏打实打实打算大苏打\"}");
System.Threading.Thread.Sleep(1000);
}
});
Task.Factory.StartNew(() =>
{
rabbitMqService.Subscribe <object>("test-queue", false, t =>
{
var msg = JsonConvert.SerializeObject(t);
Debug.WriteLine($"时间：{DateTime.Now},当前消息内容：{msg}");
System.Threading.Thread.Sleep(1000);
}, false);
});
while (true)
{
}
}
/// <summary>
/// 定时器回调
/// </summary>
private void OneRunTimerCallBack()
{
if (!IsMqAlive())
{
if (_isFirstTimeToStart)
{
_isFirstTimeToStart = false;
NLogHelper.Debug($"首次尝试启动mq");
StartMq(ex =>
{
NLogHelper.Error($"首次尝试启动mq失败:{ex}");
});
}
else
{
bool needToStartMq = false;
_timerNonAliveCount++;
if (_timerNonAliveCount > 1 || _rmqConfigList.Count == 1)
{
//count == 1表示单机版
if (_timerNonAliveCount > 1000000)
{
//避免溢出
_timerNonAliveCount = 100;
}
needToStartMq = true;
}
if (needToStartMq)
{
RabbitMqConfig oldConfig = GetCurrentUsedRmq();
//取下一个机器
lock (_locker)
{
_currentUsedRmqIndex++;
}
RabbitMqConfig newConfig = GetCurrentUsedRmq();
//第二次才尝试启动
StartMq(ex =>
{
NLogHelper.Error($"尝试启动mq失败:{ex}");
});
//mq切机
_mqChangeCallback?.Invoke(oldConfig, newConfig);
}
}
}
else
{
_timerNonAliveCount = 0;
}
}
private void SetProjectionListener(PaymentsRepository repository, IServiceCollection services)
{
var config = new RabbitMqConfig();
configuration.GetSection("RabbitMq").Bind(config);
var logger = services.BuildServiceProvider().GetService <ILogger <RabbitMqPublisher> >();
var rabbitMq = new RabbitMqChannelFactory().CreateReadChannel <Models.Payment, string>(config, "PaymentsRead", logger);
rabbitMq.Received += (sender, projection) =>
{
if (projection.Upsert != null && projection.Upsert.Length > 0)
{
repository.Upsert(projection.Upsert);
}
if (projection.Upsert != null && projection.Upsert.Length == 0)
{
repository.Clear();
}
if (projection.Remove != null)
{
repository.Remove(projection.Remove);
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="UsernameUpdateSender"/> class.
/// </summary>
/// <param name="rabbitMqOptions">The rabbit mq options.</param>
public VendorStatusUpdateSender(RabbitMqConfig rabbitMqOptions)
{
hostname = rabbitMqOptions.Hostname;
username = rabbitMqOptions.UserName;
password = rabbitMqOptions.Password;
queueName = rabbitMqOptions.QueueName;
exchangeName = rabbitMqOptions.ExchangeName;
}
/// <summary>
/// 自定义配置和消息处理方式
/// </summary>
/// <param name="config"></param>
/// <param name="handler"></param>
public RabbitMQSubscriber(RabbitMqConfig config, IMQMsgHandler handler)
{
//自定义MQ配置
this.rabbitMqService = new RabbitMqService(config);
//自定义消息处理方式
this.mqMsgHandler = handler;
}
/// <summary>
/// 自定义配置
/// </summary>
/// <param name="config"></param>
public RabbitMQSubscriber(RabbitMqConfig config)
{
//自定义MQ配置
this.rabbitMqService = new RabbitMqService(config);
//使用默认消息处理方式
this.mqMsgHandler = new DefaultMQMsgHandler();
}
public ImageController(IOptionsSnapshot <ImageServiceConfig> imageServiceConfig,
IOptionsSnapshot <RabbitMqConfig> rabbitMqConfig,
IImageService imageService)
{
this._imageServiceConfig = imageServiceConfig.Value;
this._rabbitMqConfig = rabbitMqConfig.Value;
this._imageService = imageService;
}
public static IServiceCollection AddRabbitMqConsumer(
this IServiceCollection services,
RabbitMqConfig config)
{
return(services
.AddSingleton(config)
.AddSingleton <RabbitMqConsumer>());
}
public void Publishing_message_with_routingKey_sends_only_to_registered_queue()
{
RabbitMqConfig.UsingChannel(channel => {
PublishHelloRabbit(channel);
var basicGetMsg = channel.BasicGet(MqQueueNames <HelloRabbit> .Direct, true);
Assert.That(basicGetMsg, Is.Not.Null);
});
}
public static IServiceCollection AddUpdatesConsumer <TConsumer>(
this IServiceCollection services,
RabbitMqConfig rabbitMqConfig) where TConsumer : class, IUpdateConsumer
{
return(services
.AddRabbitMqConsumer(rabbitMqConfig)
.AddSingleton <IUpdateConsumer, TConsumer>()
.AddHostedService <UpdatesConsumerService>());
}
public static IServiceCollection AddRabbitMqUpdatesPublisher(
this IServiceCollection services,
RabbitMqConfig config)
{
return(services
.AddSingleton(config)
.AddSingleton <RabbitMqPublisher>()
.AddSingleton <IUpdatesPublisher, RabbitMqUpdatesPublisher>());
}
