public static void Main(string[] args)
{
IMessageQueue queue = new RabbitQueue();
MessagePublisher publisher = new SyncMessagePublisher(queue);
publisher.Publish("Preved!");
}
protected Worker(string connStr, IBus bus, RabbitQueue queue, string name)
{
if (String.IsNullOrEmpty(connStr))
{
throw new ArgumentNullException("connStr");
}
if (bus == null)
{
throw new ArgumentNullException("bus");
}
if (queue == null)
{
throw new ArgumentNullException("queue");
}
dbConnStr = connStr;
if (DebugFlag.Enabled)
{
try {
dbTextLog = new StreamWriter(Path.Combine(Path.GetTempPath(), Exchange_Svc.MyServiceName, String.Format("{0}.dbTextLog", _Name)))
{
AutoFlush = true
};
} catch (Exception ex) {
Trace.TraceWarning("{2}\t{0}: не удалось создать журнал dbTextLog: {1}", _Name, ex.Message, DateTime.Now);
}
}
Bus = bus;
Queue = queue;
_Name = name;
}
private IValidatorResult GetQueueResult(Models.HareDuSettings settings, RabbitQueue queue)
{
log.Debug("RabbitMQValidator: GetQueueResult for {QueueName} ", queue.Name);
var tags = new List <string>()
{
queue.Name
};
string resultIdentifier = string.Format("{0}:{1}", queue.Name, queue.MessagesReady);
var messageCount = string.IsNullOrEmpty(queue.Messages) ? "0" : queue.Messages;
var description = string.Format("Server: {0}{4} vHost: {1}{5} {2} Messages found in error queue {3}",
settings.RabbitUrl, settings.Vhost, messageCount, queue.Name, Environment.NewLine, Environment.NewLine);
ValidatorResultCode code = ValidatorResultCode.Success;
if (queue.Messages != null && queue.MessagesReady > 0)
{
code = ValidatorResultCode.Error;
}
log.Debug("RabbitMQValidator GetQueueResult for {QueueName} has messages {Message} and message ready count {MessagesReady}", queue.Name, queue.Messages, queue.MessagesReady);
return(new ValidatorResult(this.ValidatorProxyId, description, code, queue.Name, tags));
}
public async Task InsertEmptyGuidEmpty()
{
var rabbit = new RabbitQueue(ValidRabbitSettings);
var result = await rabbit.AddToQueueAsync(new byte[0], Guid.Empty);
Assert.IsFalse(result);
}
public RabbitConfig()
{
this.HostName = "192.168.33.10";
this.UserName = "******";
this.Password = "******";
this.Exchange = "cqrs";
this.Queues = new RabbitQueue();
}
public RabbitElasticLogsService(RabbitQueue rabbitEnum, IModel channel, IOptions <SeriLogSetting> settings, IServiceProvider serviceProvider)
{
_rabbitEnum = rabbitEnum;
_channel = channel;
_elasticSearchService = serviceProvider.GetRequiredService <IElasticSearchService>();
_seriLogSetting = settings.Value;
baseDir = _seriLogSetting.baseDir;
logfile = Path.Combine(baseDir, _seriLogSetting.App_Data, _seriLogSetting.logs, _seriLogSetting.log);
}
public static QueueDeclareOk QueueDeclare(this IModel model, RabbitQueue queue)
{
return(model.QueueDeclare(
queue: queue.QueueName,
durable: queue.Durable,
exclusive: queue.Exclusive,
autoDelete: queue.AutoDelete,
arguments: queue.Arguments));
}
public void CanPublishMessages()
{
var mq = new RabbitQueue("valid connection stirng");
var testItems = new List<TestItems>
{
{new TestItems { Id =1, Url = "http://www.google.com"}},
{new TestItems { Id=2, Url = "http://www.yahoo.com"}}
};
Assert.DoesNotThrow(() => mq.PublishMessages(testItems));
}
public AsyncBasicRpcServer(IOptions <RpcServerConfiguration> rpcServerConfiguration, IRabbitConnectionManager rabbitConnectionManager, ILogger logger)
{
var options = rpcServerConfiguration.Value;
_requestQueue = options.RequestQueue;
_threadCount = options.ThreadCount ?? 1;
_rabbitConnectionManager = rabbitConnectionManager;
_channelsInUse = new ConcurrentDictionary <string, IModel>();
_logger = logger;
}
public IObservableMessageDequeuer <IncomingChildLetter> CreateConsumer()
{
return(RabbitQueue.Consumer()
.Queue(x =>
{
x.Name = QueueKeys.IncomingLetters.QueueName;
x.Durable = true;
x.PrefetchCount = 16 * 1000;
})
.Create <IncomingChildLetter>(_connectionFactory.Create()));
}
public void Send(RabbitQueue rabbitQueue, RabbitTransportMessage message)
{
using (var channel = _rabbitChannelManager.GetChannel())
{
channel.QueueDeclare(rabbitQueue);
var props = channel.CreateBasicProperties();
if (message.Headers != null && message.Headers.Count > 0)
{
props.Headers = message.Headers;
}
channel.BasicPublish("", rabbitQueue.QueueName, props, message.BodyBytes);
}
}
public void StartConsuming(RabbitQueue rabbitQueue, bool autoAck = false)
{
try
{
_channel.QueueDeclare(rabbitQueue);
_consumer = new AsyncEventingBasicConsumer(_channel);
_consumer.Received += AsyncDataHandler;
_channel.BasicConsume(rabbitQueue.QueueName, autoAck, _consumer);
}
catch (Exception exception)
{
_logger.LogError("An {@Exception} occured on {QueueName} consuming start", exception, rabbitQueue.QueueName);
}
}
public static IRabbitBaseService createInstance(RabbitQueue rabbitEnum, IModel channel, IOptions <SeriLogSetting> serLogSettings, IServiceProvider serviceProvider)
{
IRabbitBaseService instance = null;
switch (rabbitEnum)
{
case RabbitQueue.ElasticLogs:
instance = new RabbitElasticLogsService(rabbitEnum, channel, serLogSettings, serviceProvider);
break;
default:
break;
}
return(instance);
}
public void PublishToQueue(RabbitQueue queue, string message)
{
var factory = new ConnectionFactory()
{
HostName = baseUri
};
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();
channel.QueueDeclare(queue: Utilities.GetParentType(queue), durable: false, exclusive: false, autoDelete: true, arguments: null);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
routingKey: Utilities.GetParentType(queue),
basicProperties: null,
body: body);
}
public void StartConsuming(RabbitExchange rabbitExchange, bool autoAck = false)
{
try
{
_channel.ExchangeDeclare(rabbitExchange);
_consumer = new AsyncEventingBasicConsumer(_channel);
_consumer.Received += AsyncDataHandler;
var queue = new RabbitQueue()
{
QueueName = rabbitExchange.ExchangeName + "Queue"
};
_channel.QueueDeclare(queue);
_channel.QueueBind(queue.QueueName, rabbitExchange.ExchangeName, routingKey: "");
_channel.BasicConsume(queue.QueueName, autoAck, _consumer);
}
catch (Exception exception)
{
_logger.LogError("An {@Exception} occured on {ExchangeName} consuming start", exception, rabbitExchange.ExchangeName);
}
}
public void Load(IStartupSettings startupSettings)
{
IConnection connection = _manager.GetConnection();
IMessageEnqueuer <IncomingChildLetter> letterEnqueuer = RabbitQueue.Producer()
.UseExchange(x =>
{
x.Name = QueueKeys.IncomingLetters.ExchangeName;
x.Type = RabbitExchangeType.Direct;
})
.Queue(x =>
{
x.Name = QueueKeys.IncomingLetters.QueueName;
x.Durable = true;
x.PrefetchCount = 16 * 1000;
x.RoutingKey = QueueKeys.IncomingLetters.RoutingKey;
})
.Create <IncomingChildLetter>(connection);
_letterEnqueuer = letterEnqueuer.ToOption();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
ServiceLocator.SetServices(host.Services);
var capBus = ServiceLocator.GetService <ICapPublisher>();
var queueName = ConfigurtaionHelper.Configuration["Exceptionless:ApiKey"];
IQueue queue1 = new RabbitQueue();
Console.WriteLine("接收MQ消息中......");
while (true)
{
queue1.BeginReceive(queueName, (sender, queue) =>
{
Console.WriteLine("接收到队列[{0}]的消息，内容;[{1}]", queueName, queue.Message);
capBus.Publish(queueName, queue.Message);
queue1.AfterReceive(sender, queue.Index, false);
});
}
}
public void Enqueue(PUSH_TOKEN token, T t)
{
var q = _queues.GetOrAdd(token.InstanceKey, (key) =>
{
var queue = RabbitQueue.CreateSender(_connectionString, "pushqueue", $"{token.InstanceKey}");
queue.Start();
return(queue);
});
using (var st = new MemoryStream())
{
var hdr = new MessageHeader()
{
Token = token,
MessageType = _pushMessageType,
};
BinaryWriter writer = new BinaryWriter(st);
writer.Write(hdr.CalculateSize());
hdr.WriteTo(st);
t.WriteTo(st);
q.Send(st.ToArray());
}
}
public AsyncRpcClient(IOptions <RpcClientConfiguration> rpcClientConfiguration, IRabbitConnectionManager rabbitConnectionManager, ILogger <AsyncRpcClient> logger)
{
_logger = logger;
_requestQueue = rpcClientConfiguration.Value.RequestQueue;
_threadCount = rpcClientConfiguration.Value.ThreadCount;
_timeout = rpcClientConfiguration.Value.Timeout ?? Timeout.InfiniteTimeSpan;
_rabbitConnectionManager = rabbitConnectionManager;
_pendingMessages = new ConcurrentDictionary <string, TaskCompletionSource <byte[]> >();
_channel = rabbitConnectionManager.GetChannel();
_consumer = new AsyncEventingBasicConsumer(_channel);
_consumer.Received += async(model, ea) => {
_pendingMessages.TryRemove(ea.BasicProperties.CorrelationId, out var tcs);
if (tcs != null)
{
tcs.SetResult(ea.Body);
}
else
{
_logger.LogWarning("No result on {CorrelationId}", ea.BasicProperties.CorrelationId);
}
};
_channel.BasicQos(0, (ushort?)_threadCount ?? 1, false);
_channel.BasicConsume(_replyQueue.QueueName, true, _consumer);
}
public PushQueueReciever(string connectionString, int instanceKey, IConnectionManager connectionManager, PushMessageType pushMessageType, ILogger logger)
{
_pushMessageType = pushMessageType;
_connectionManager = connectionManager;
_queue = RabbitQueue.CreateReciever(connectionString, "pushqueue", $"{instanceKey}", OnRecieve);
}
public void NameTest()
{
var rabbit = new RabbitQueue(ValidRabbitSettings);
Assert.AreEqual("RabbitMQ", rabbit.Name);
}
public void OnlineTest()
{
var rabbit = new RabbitQueue(ValidRabbitSettings);
Assert.IsTrue(rabbit.IsOnline());
}
public void InitializeNull()
{
var rabbit = new RabbitQueue(settings: (Settings)null);
}
public static IServiceCollection AddRabbitMqRpcClient(this IServiceCollection services, RabbitQueue requestRabbitQueue)
{
services.AddSingleton(sp => requestRabbitQueue);
services.AddSingleton <IRpcClient, AsyncRpcClient>();
return(services);
}
public Receiver(string connStr, IBus bus, RabbitQueue queue)
: base(connStr, bus, queue, String.Format("receiver_{0}", queue.Queue_Id))
{
this.Encoding = (Queue.Codepage > 0) ? Encoding.GetEncoding((int)Queue.Codepage) : Encoding.UTF8;
}
public Sender(string connStr, IBus bus, RabbitQueue queue)
: base(connStr, bus, queue, String.Format("sender_{0}", queue.Queue_Id))
{
PollInterval = (Queue.SenderPollInterval > 0) ? (int)Queue.SenderPollInterval : 10000;
}
