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; }