public async Task DeclareAsync() { bool exists = await _bunny.ExchangeExistsAsync(Name); if (exists) { return; } IModel channel = null; try { channel = _bunny.Channel(newOne: true); await Task.Run(() => { channel.ExchangeDeclare(Name, ExchangeType, Durable, AutoDelete, _args); }); } catch (System.Exception exc) { throw DeclarationException.DeclareFailed(exc, "exchange-declare failed!"); } finally { channel.Close(); } }
///<summary> /// Enter Queue DeclarationMode ///</summary> public static IQueue Queue(this IDeclare declare, string name) { if ((declare is DeclareBase) == false) { throw DeclarationException.WrongType(typeof(DeclareBase), declare); } IBunny bunny = CheckGetBunny(declare, name, "queue"); return(new DeclareQueue(bunny, name)); }
public IPublish <T> WithConfirm(Func <BasicAckEventArgs, Task> onAck, Func <BasicNackEventArgs, Task> onNack) { if (onAck == null || onNack == null) { throw DeclarationException.Argument(new ArgumentException("handlers for ack and nack must not be null")); } _useConfirm = true; _ackCallback = onAck; _nackCallback = onNack; return(this); }
public DeclareResponder(IBunny bunny, string rpcExchange, string fromQueue, Func <TRequest, Task <TResponse> > respond) { if (respond == null) { throw DeclarationException.Argument(new ArgumentException("respond delegate must not be null")); } _bunny = bunny; _respond = respond; _rpcExchange = rpcExchange; _serialize = Config.Serialize; _consumeFromQueue = fromQueue; _thisChannel = new PermanentChannel(bunny); _deserialize = Config.Deserialize <TRequest>; }
private static IBunny CheckGetBunny(IDeclare declare, string toCheck, string errorPrefix) { if (string.IsNullOrWhiteSpace(toCheck)) { var arg = new ArgumentException($"{errorPrefix}-name must not be null-or-whitespace"); throw DeclarationException.Argument(arg); } if (toCheck.Length > 255) { var arg = new ArgumentException($"{errorPrefix}-length must be less than or equal to 255 character"); throw DeclarationException.Argument(arg); } return(declare.Bunny); }
private void AttemptPassiveDeclarations() { DeclarationException failures = null; foreach (var queueName in Queues) { try { try { Channel.QueueDeclarePassive(queueName); } catch (RC.Exceptions.WireFormattingException e) { try { if (Channel is IChannelProxy) { ((IChannelProxy)Channel).TargetChannel.Close(); } } catch (TimeoutException) { } throw new FatalListenerStartupException("Illegal Argument on Queue Declaration", e); } } catch (RC.Exceptions.RabbitMQClientException e) { Logger?.LogWarning("Failed to declare queue: {name} ", queueName); if (!Channel.IsOpen) { throw new RabbitIOException(e); } if (failures == null) { failures = new DeclarationException(e); } failures.AddFailedQueue(queueName); } } if (failures != null) { throw failures; } }
internal static async Task <bool> ExchangeExistsAsync(this IBunny bunny, string name) { try { var channel = bunny.Channel(newOne: true); await Task.Run(() => channel.ExchangeDeclarePassive(name)); return(true); } catch (RabbitMQ.Client.Exceptions.OperationInterruptedException) { return(false); } catch (Exception ex) { throw DeclarationException.DeclareFailed(ex); } }
internal static async Task <bool> QueueExistsAsync(this IBunny bunny, string name) { try { var channel = bunny.Channel(newOne: true); var result = await new TaskFactory().StartNew <QueueDeclareOk>(() => channel.QueueDeclarePassive(name)); return(true); } catch (RabbitMQ.Client.Exceptions.OperationInterruptedException) { return(false); } catch (Exception ex) { throw DeclarationException.DeclareFailed(ex); } }
private void HandleDeclarationException(int passiveDeclareRetries, DeclarationException e) { if (passiveDeclareRetries > 0 && Channel.IsOpen) { Logger?.LogWarning(e, "Queue declaration failed; retries left={retries}", passiveDeclareRetries); try { Thread.Sleep(FailedDeclarationRetryInterval); } catch (Exception e1) { Declaring = false; ActiveObjectCounter.Release(this); throw RabbitExceptionTranslator.ConvertRabbitAccessException(e1); } } else if (e.FailedQueues.Count < Queues.Count) { Logger?.LogWarning("Not all queues are available; only listening on those that are - configured: {queues}; not available: {notavail}", string.Join(',', Queues), string.Join(',', e.FailedQueues)); lock (MissingQueues) { foreach (var q in e.FailedQueues) { MissingQueues.Add(q); } } LastRetryDeclaration = DateTimeOffset.Now.ToUnixTimeMilliseconds(); } else { Declaring = false; ActiveObjectCounter.Release(this); throw new QueuesNotAvailableException("Cannot prepare queue for listener. Either the queue doesn't exist or the broker will not allow us to use it.", e); } }
public Task DeclareAsync() { throw DeclarationException.BaseNotValid(); }