private void StartConsumingInternal()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
// connection is not connected, so just ignore this call. A consumer will
// be created and start consuming when the connection reconnects.
return;
}
if (shouldRecover && configuration.RecoveryAction != null)
{
configuration.RecoveryAction();
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.TryAdd(internalConsumer, null);
internalConsumer.Cancelled += consumer => Dispose();
internalConsumer.ConsumerLost += OnConsumerLost;
internalConsumer.StartConsuming(
connection,
queue,
onMessage,
configuration
);
}
private void StartConsumingInternal()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
// connection is not connected, so just ignore this call. A consumer will
// be created and start consuming when the connection reconnects.
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.TryAdd(internalConsumer, null);
internalConsumer.Cancelled += consumer => Dispose();
internalConsumer.StartConsuming(
connection,
queueConsumerPairs,
configuration);
}
private void StartConsumer()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
return;
}
lock (syncLock)
{
if (isStarted)
{
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.TryAdd(internalConsumer, null);
internalConsumer.Cancelled += consumer => Dispose();
var status = internalConsumer.StartConsuming(connection, queue, onMessage, configuration);
if (status == StartConsumingStatus.Succeed)
{
isStarted = true;
}
else
{
internalConsumer.Dispose();
object value;
internalConsumers.TryRemove(internalConsumer, out value);
}
}
}
private void StartConsumingInternal()
{
if (disposed)
{
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.Add(internalConsumer);
internalConsumer.Cancelled += consumer => Dispose();
var status = internalConsumer.StartConsuming(
queue,
onMessage,
configuration
);
if (status == StartConsumingStatus.Succeed)
{
eventBus.Publish(new StartConsumingSucceededEvent(this, queue));
}
else
{
eventBus.Publish(new StartConsumingFailedEvent(this, queue));
}
}
public Given_a_PersistentConsumer()
{
eventBus = new EventBus();
internalConsumers = new List <IInternalConsumer>();
createConsumerCalled = 0;
mockBuilder = new MockBuilder();
queue = new Queue(queueName, false);
onMessage = (body, properties, info) => Task.Factory.StartNew(() => { });
persistentConnection = Substitute.For <IPersistentConnection>();
internalConsumerFactory = Substitute.For <IInternalConsumerFactory>();
internalConsumerFactory.CreateConsumer().Returns(x =>
{
var internalConsumer = Substitute.For <IInternalConsumer>();
internalConsumers.Add(internalConsumer);
createConsumerCalled++;
return(internalConsumer);
});
configuration = new ConsumerConfiguration(0);
consumer = new PersistentConsumer(
queue,
onMessage,
persistentConnection,
configuration,
internalConsumerFactory,
eventBus);
AdditionalSetup();
}
private void StartConsumingInternal()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
// connection is not connected, so just ignore this call. A consumer will
// be created and start consuming when the connection reconnects.
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.TryAdd(internalConsumer, null);
internalConsumer.Cancelled += consumer =>
{
// Console.Out.WriteLine(">>>>>>>> internalConsumer.Cancelled");
// if (disposed) return;
//
// object value; // cruft from using a ConcurrentDictionary
// internalConsumers.TryRemove(consumer, out value);
// StartConsumingInternal();
};
internalConsumer.StartConsuming(
connection,
queue,
onMessage);
}
private void StartConsumingInternal()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
return;
}
lock (syncLock)
{
if (isStarted)
{
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.TryAdd(internalConsumer, null);
internalConsumer.Cancelled += consumer => Dispose();
var status = internalConsumer.StartConsuming(connection, queue, onMessage, configuration);
if (status == StartConsumingStatus.Succeed)
{
isStarted = true;
eventBus.Publish(new StartConsumingSucceededEvent(this, queue));
}
else
{
internalConsumer.Dispose();
internalConsumers.TryRemove(internalConsumer, out _);
eventBus.Publish(new StartConsumingFailedEvent(this, queue));
}
}
}
private void StartConsumingInternal()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
// connection is not connected, so just ignore this call. A consumer will
// be created and start consuming when the connection reconnects.
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.TryAdd(internalConsumer, null);
internalConsumer.Cancelled += consumer => Dispose();
var status = internalConsumer.StartConsuming(
connection,
queue,
onMessage,
configuration);
if (status == StartConsumingStatus.Succeed)
{
eventBus.Publish(new StartConsumingSucceededEvent(this, queue));
}
else
{
eventBus.Publish(new StartConsumingFailedEvent(this, queue));
}
}
public IDisposable StartConsuming()
{
internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumer.Cancelled += consumer => Dispose();
var status = internalConsumer.StartConsuming(
connection,
queue,
onMessage,
configuration
);
if (status == StartConsumingStatus.Succeed)
{
eventBus.Publish(new StartConsumingSucceededEvent(this, queue));
}
else
{
eventBus.Publish(new StartConsumingFailedEvent(this, queue));
}
consumerCancellation = new ConsumerCancellation(Dispose);
return(consumerCancellation);
}
public void StartConsuming()
{
internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumer.Cancelled += consumer => OnRemoveMeFromList();
internalConsumer.StartConsuming(
connection,
queue,
onMessage);
}
public IDisposable StartConsuming()
{
internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumer.Cancelled += consumer => Dispose();
internalConsumer.StartConsuming(
connection,
queue,
onMessage);
return(new ConsumerCancellation(Dispose));
}
public void StartConsuming()
{
internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumer.Cancelled += consumer => OnRemoveMeFromList();
internalConsumer.AckOrNackWasSent += context =>
{
OnRemoveMeFromList();
Dispose();
};
internalConsumer.StartConsuming(
connection,
queue,
onMessage);
}
private void StartConsumingInternal()
{
if (disposed)
{
return;
}
if (!connection.IsConnected)
{
return;
}
var internalConsumer = internalConsumerFactory.CreateConsumer();
internalConsumers.Add(internalConsumer);
internalConsumer.Cancelled += consumer => Dispose();
internalConsumer.StartConsuming(
queueConsumerPairs,
configuration
);
}
