public void Init(IRabbitMQClient client)
{
var isOnce = QueueCount == 1;
if (isOnce)
{
models.Add(Queue, client.PullModel().GetAwaiter().GetResult());
}
else
{
nodeList = new List <string>();
for (int i = 0; i < QueueCount; i++)
{
var queue = $"{ Queue}_{i}";
nodeList.Add(queue);
if (!models.ContainsKey(queue))
{
models.Add(queue, client.PullModel().GetAwaiter().GetResult());
}
}
_CHash = new ConsistentHash(nodeList, QueueCount * 10);
}
//申明exchange
client.ExchangeDeclare(Exchange).Wait();
Client = client;
}
public RabbitProducer(
IRabbitMQClient rabbitMQClient,
RabbitEventBus publisher)
{
this.publisher = publisher;
this.rabbitMQClient = rabbitMQClient;
}
public void Init(IRabbitMQClient client)
{
QueueList = new List <QueueInfo>();
if (originQueueList?.Count > 0)
{
foreach (var q in originQueueList)
{
QueueList.Add(BuildQueueInfo(q));
}
}
else if (!string.IsNullOrEmpty(queue))
{
if (QueueCount == 1)
{
QueueList.Add(BuildQueueInfo(queue));
}
else
{
for (int i = 0; i < QueueCount; i++)
{
QueueList.Add(BuildQueueInfo(queue + "_" + i));
}
}
}
//申明exchange
client.ExchangeDeclare(this.Exchange).Wait();
}
public EventBusContainer(
IServiceProvider serviceProvider,
IRabbitMQClient rabbitMQClient)
{
this.serviceProvider = serviceProvider;
this.rabbitMQClient = rabbitMQClient;
}
public RabbitSubManager(ILogger <RabbitSubManager> logger, IRabbitMQClient client, IServiceProvider provider)
{
this.client = client;
this.client = client;
this.logger = logger;
this.provider = provider;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="logger"></param>
/// <param name="orderRepository"></param>
/// <param name="adminUserManager"></param>
/// <param name="orderBillingRepository"></param>
/// <param name="goodsRepository"></param>
/// <param name="assetsRepository"></param>
/// <param name="partnerApplyRepository"></param>
/// <param name="customerRepository"></param>
/// <param name="paymentService"></param>
/// <param name="orderService"></param>
/// <param name="customerManager"></param>
/// <param name="client"></param>
/// <param name="cache"></param>
/// <param name="mapper"></param>
public OrderController(ILogger <OrderController> logger,
IAdminUserManager adminUserManager,
IRepositoryByInt <Orders> orderRepository,
IRepositoryByInt <OrderBilling> orderBillingRepository,
IRepositoryByInt <Goods> goodsRepository,
IRepositoryByInt <Assets> assetsRepository,
IRepositoryByInt <PartnerApply> partnerApplyRepository,
IRepositoryByInt <Customer> customerRepository,
IPaymentService paymentService,
IOrderService orderService,
ICustomerManager customerManager,
IRabbitMQClient client,
IMemoryCache cache,
IMapper mapper)
{
_logger = logger;
_adminUserManager = adminUserManager;
_orderRepository = orderRepository;
_orderBillingRepository = orderBillingRepository;
_goodsRepository = goodsRepository;
_assetsRepository = assetsRepository;
_partnerApplyRepository = partnerApplyRepository;
_customerRepository = customerRepository;
_paymentService = paymentService;
_orderService = orderService;
_customerManager = customerManager;
_client = client;
_cache = cache;
_mapper = mapper;
}
public RabbitProducer(
IRabbitMQClient rabbitMQClient,
IOptions <RabbitOptions> rabbitOptions)
{
this.rabbitMQClient = rabbitMQClient;
this.rabbitOptions = rabbitOptions.Value;
}
public Form1()
{
InitializeComponent();
var conFactory = new UriRabbitMqConfiguration("GPSLocation",
"amqp://*****:*****@clam.rmq.cloudamqp.com/kkxglvxw");
_rabbitClient = new RabbitMQClient(conFactory);
}
public MQServiceContainer(IRabbitMQClient rabbitMQClient)
{
this.rabbitMQClient = rabbitMQClient;
PublisherDictionary = new Dictionary <Type, RabbitPublisher>
{
{ typeof(MyPub), new RabbitPublisher("Demo", "demo", 4) }
};
}
public CommunicationManager(IRabbitMQClient rabbitMQClient, CommunicationType communicationType, string queueName)
{
this.rabbitMQClient = rabbitMQClient;
this.communicationType = communicationType;
this.queueName = queueName;
Initialize();
}
public ProducerContainer(IRabbitMQClient rabbitMQClient)
{
this.rabbitMQClient = rabbitMQClient;
PublisherDictionary = new Dictionary <Type, RabbitPublisher>
{
{ typeof(Account), new RabbitPublisher("Account", "account", 20) }
};
}
public RabbitProducer(
IRabbitMQClient rabbitMQClient,
RabbitEventBus publisher,
Type grainType)
{
GrainType = grainType;
this.publisher = publisher;
this.rabbitMQClient = rabbitMQClient;
}
public MQConsumerClient(IRabbitMQClient client, IOptions <RabbitMQOption> options)
{
var rabbitMQ = options.Value;
_client = client;
_maxTaskCount = rabbitMQ.MaxTaskCount;
_connection = _client.GetMQConnection();
TaskDo();
}
public MQProducerClient(IRabbitMQClient client, IOptions <RabbitMQOption> options)
{
var rabbitMQ = options.Value;
_durable = rabbitMQ.Durable;
_client = client;
_connection = _client.GetMQConnection();
}
public EventBusContainer(
IServiceProvider serviceProvider,
IObserverUnitContainer observerUnitContainer,
IRabbitMQClient rabbitMQClient)
{
this.serviceProvider = serviceProvider;
this.rabbitMQClient = rabbitMQClient;
this.observerUnitContainer = observerUnitContainer;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="shipmentRepository"></param>
/// <param name="smsService"></param>
/// <param name="client"></param>
/// <param name="mapper"></param>
public AdminShipmentController(IRepositoryByInt <Shipment> shipmentRepository,
ISmsService smsService,
IRabbitMQClient client,
IMapper mapper)
{
_shipmentRepository = shipmentRepository;
_smsService = smsService;
_client = client;
_mapper = mapper;
}
public EventBusContainer(
IServiceProvider serviceProvider,
IObserverUnitContainer observerUnitContainer,
IRabbitMQClient rabbitMQClient,
IOptions <RabbitOptions> rabbitOptions)
{
this.serviceProvider = serviceProvider;
this.rabbitMQClient = rabbitMQClient;
this.observerUnitContainer = observerUnitContainer;
this.rabbitOptions = rabbitOptions.Value;
}
public void Init(IRabbitMQClient client)
{
for (int i = 0; i < QueueCount; i++)
{
nodeList.Add(Queue + "_" + i);
}
_CHash = new ConsistentHash(nodeList, QueueCount * 10);
//申明exchange
client.ExchangeDeclare(Exchange).Wait();
Client = client;
}
public ConsumerRunner(
IRabbitMQClient client,
ILogger <ConsumerRunner> logger,
RabbitConsumer consumer,
QueueInfo queue)
{
Client = client;
Logger = logger;
Consumer = consumer;
Queue = queue;
}
public ConsumerRunner(
IRabbitMQClient client,
IServiceProvider provider,
RabbitConsumer consumer,
QueueInfo queue)
{
Client = client;
Logger = provider.GetService <ILogger <ConsumerRunner> >();
mpscChannel = provider.GetService <IMpscChannel <BasicDeliverEventArgs> >();
mpscChannel.BindConsumer(BatchExecuter);
Consumer = consumer;
Queue = queue;
}
public ConsumerManager(
ILogger <ConsumerManager> logger,
IRabbitMQClient client,
IGrainFactory grainFactory,
IServiceProvider provider,
IRabbitEventBusContainer rabbitEventBusContainer)
{
this.provider = provider;
this.client = client;
this.logger = logger;
this.rabbitEventBusContainer = rabbitEventBusContainer;
this.grainFactory = grainFactory;
}
public MessagePublisher(
IConfiguration configuration,
IPolicyManager policyManager,
IRabbitMQClient rabbitMQClient,
IMessageConsumer messageConsumer)
{
Configuration = configuration;
m_RabbitMQClient = rabbitMQClient;
m_Channel = m_RabbitMQClient.SetupMQTTBindings(MqttBinding);
m_BatchReplyMap = new ConcurrentDictionary <Guid, BatchStatus>();
m_PolicyManager = policyManager;
m_MessageConsumer = messageConsumer;
m_MessageConsumer.BatchReplyEventChanged += OnBatchReplyChanged;
}
public ConsumerRunner(
IRabbitMQClient client,
IServiceProvider provider,
RabbitConsumer consumer,
QueueInfo queue,
RabbitOptions rabbitOptions)
{
Client = client;
Logger = provider.GetService <ILogger <ConsumerRunner> >();
serializer = provider.GetService <ISerializer>();
channel = provider.GetService <IChannel <BasicDeliverEventArgs> >();
channel.BindConsumer(Executer);
Consumer = consumer;
Queue = queue;
this.rabbitOptions = rabbitOptions;
}
public async ValueTask Build(IRabbitMQClient client)
{
while (!buildedResult)
{
if (Interlocked.CompareExchange(ref isBuilded, 1, 0) == 0)
{
try
{
await Init(client);
buildedResult = true;
}
finally
{
Interlocked.Exchange(ref isBuilded, 0);
}
}
await Task.Delay(50);
}
}
private async Task Init(IRabbitMQClient client)
{
var isOnce = QueueCount == 1;
if (isOnce)
{
var pullTask = client.PullModel();
if (!pullTask.IsCompleted)
{
await pullTask;
}
models.Add(Queue, pullTask.Result);
}
else
{
var nodeList = new List <string>();
for (int i = 0; i < QueueCount; i++)
{
var queue = $"{ Queue}_{i}";
nodeList.Add(queue);
if (!models.ContainsKey(queue))
{
var pullTask = client.PullModel();
if (!pullTask.IsCompleted)
{
await pullTask;
}
models.Add(queue, pullTask.Result);
}
}
_CHash = new ConsistentHash(nodeList, QueueCount * 10);
}
//申明exchange
await client.ExchangeDeclare(Exchange);
Client = client;
}
public HomeController(IRabbitMQClient rabbitMQ)
{
_rabbitMQ = rabbitMQ;
}
public EventStreamFactory(IRabbitMQClient rabbitMQClient, IGrainFactory grainFactory)
{
this.grainFactory = grainFactory;
this.rabbitMQClient = rabbitMQClient;
}
public OrdersController(ILogger <OrdersController> logger, IRabbitMQClient rabbitMqClient)
{
_logger = logger;
_rabbitMqClient = rabbitMqClient;
}
public EventStream(IRabbitMQClient rabbitMQClient, string exchange, string routingKey)
{
this.rabbitMQClient = rabbitMQClient;
this.exchange = exchange;
this.routingKey = routingKey;
}
public MQServiceContainer(IRabbitMQClient client)
{
this.client = client;
}
