public async Task throw_when_subscribe_and_already_subscribing()
{
var cts = new CancellationTokenSource(10000);
var mockSubscriptionListener = new Mock <ISubscriptionListener>();
var mockResolutionManager = new Mock <IResolutionManager>();
var mockSortingManager = new Mock <ISortingManager>();
var mockHandlingManager = new Mock <IHandlingManager>();
var mockStreamClient = new Mock <IStreamClient>();
var regionId1 = "r1";
var regionId2 = "r2";
var streamId = "s";
var options = new SubscriberOptions(new List <SubscriptionStreamId>()
{
new SubscriptionStreamId(regionId1, streamId),
new SubscriptionStreamId(regionId2, streamId)
});
var subscriber = new Subscriber(NullStandardLogger.Instance, null, mockSubscriptionListener.Object, mockResolutionManager.Object, mockSortingManager.Object, mockHandlingManager.Object, null, options);
var mockAwaiter = new ManualResetEventSlim(false);
mockSubscriptionListener.Setup(x => x.ListenAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>())).Returns(mockAwaiter.WaitHandle.AsTask());
mockResolutionManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(mockAwaiter.WaitHandle.AsTask());
mockSortingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(mockAwaiter.WaitHandle.AsTask());
mockHandlingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(mockAwaiter.WaitHandle.AsTask());
var subscribeTask = subscriber.SubscribeAsync(cts.Token);
await Assert.ThrowsAsync <InvalidOperationException>(() => subscriber.SubscribeAsync(cts.Token));
cts.Cancel();
await subscribeTask;
}
public void Init_And_Update_With_Generic_Options()
{
var unsub = new Func <SubscriptionToken, bool>(_ => true);
var action = new Action <string>((t) =>
{
});
var token = new SubscriptionToken(unsub);
var weakAction = new WeakDelegate(action, false);
var subscription = new Subscriber <string>(token, synchronizationContext, weakAction);
var options = new SubscriberOptions <string>(subscription);
Assert.AreEqual(token, options.Token);
//
Assert.AreEqual(ExecutionStrategyType.PublisherThread, subscription.ExecutionStrategy);
options.WithExecutionStrategy(ExecutionStrategyType.UIThread);
Assert.AreEqual(ExecutionStrategyType.UIThread, subscription.ExecutionStrategy);
//
Assert.IsNotNull(subscription.Filter);
var newFilter = new Func <string, bool>(_ => true);
options.WithFilter(newFilter);
Assert.AreEqual("MvvmLib.Core.Tests.Message.SubscriberOptionsTests+<>c", subscription.Filter.Target.GetType().FullName);
}
private void ViewBagSchedule()
{
ViewBag.MonthRange = SubscriberOptions.Month();
ViewBag.WeekRange = SubscriberOptions.DayInWeek();
ViewBag.DayRange = SubscriberOptions.Day();
ViewBag.HourRange = SubscriberOptions.Hour();
}
public void construct()
{
var subscriptionStreamIds = new List <SubscriptionStreamId>();
var options = new SubscriberOptions(subscriptionStreamIds);
Assert.Equal(subscriptionStreamIds, options.SubscriptionStreamIds);
}
public void OnNavigatingTo(NavigationContext navigationContext)
{
SetTitle();
PeopleListSource.SelectedItemChanged += OnDetailsSourceSelectedItemChanged;
this.PersonAddedSubscriberOptions = eventAggregator.GetEvent <PersonAddedEvent>().Subscribe(OnPersonAdded);
this.PersonUpdatedSubscriberOptions = eventAggregator.GetEvent <PersonUpdatedSuccesfullyEvent>().Subscribe(OnPersonUpdated);
Load();
}
public async Task clear_stream_state_errors()
{
var mockStreamStateRepo = new Mock <IStreamStateRepo>();
var options = new SubscriberOptions(new List <SubscriptionStreamId>());
var subscriber = new Subscriber(NullStandardLogger.Instance, null, null, null, null, null, mockStreamStateRepo.Object, options);
await subscriber.ClearStreamStateErrorsAsync();
mockStreamStateRepo.Verify(x => x.ClearStreamStateErrorsAsync());
}
internal Subscriber(Subscription subscription, Func <ReadOnlyMemory <Message>, CancellationToken, Task> pushHandler, long completedMessageId,
SubscriberOptions subscriberOptions)
{
this.subscription = subscription;
this.topic = subscription.Topic;
this.pushHandler = pushHandler;
sentMessageId = completedMessageId;
maxMessagesInBatch = subscriberOptions.MaxMessagesInBatch;
pushIntervalMilliseconds = subscriberOptions.PushIntervalMilliseconds;
cancellationTokenSource = new CancellationTokenSource();
}
private void ViewBagTask()
{
var first = Enumerable.Range(1, 1)
.Select(s => new SelectListItem {
Value = "", Text = "-----"
});
var scheduleRange = SubscriberOptions.Schedule();
ViewBag.ScheduleRange = first.Union(scheduleRange);
}
public async Task listen_and_start_managers_until_cancelled()
{
var cts = new CancellationTokenSource();
var mockSubscriptionListener = new Mock <ISubscriptionListener>();
var mockResolutionManager = new Mock <IResolutionManager>();
var mockSortingManager = new Mock <ISortingManager>();
var mockHandlingManager = new Mock <IHandlingManager>();
var mockStreamClient = new Mock <IStreamClient>();
var regionId = "r";
var streamId = "s";
var options = new SubscriberOptions(new List <SubscriptionStreamId>()
{
new SubscriptionStreamId(regionId, streamId)
});
var mockAwaiter = new ManualResetEventSlim(false);
var listeningSignal = new ManualResetEventSlim(false);
var resolutionManagingSignal = new ManualResetEventSlim(false);
var sortingManagingSignal = new ManualResetEventSlim(false);
var handlingManagingSignal = new ManualResetEventSlim(false);
mockSubscriptionListener.Setup(x => x.ListenAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>())).Callback(() => listeningSignal.Set()).Returns(mockAwaiter.WaitHandle.AsTask());
mockResolutionManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Callback(() => resolutionManagingSignal.Set()).Returns(mockAwaiter.WaitHandle.AsTask());
mockSortingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Callback(() => sortingManagingSignal.Set()).Returns(mockAwaiter.WaitHandle.AsTask());
mockHandlingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Callback(() => handlingManagingSignal.Set()).Returns(mockAwaiter.WaitHandle.AsTask());
var subscriber = new Subscriber(NullStandardLogger.Instance, null, mockSubscriptionListener.Object, mockResolutionManager.Object, mockSortingManager.Object, mockHandlingManager.Object, null, options);
var subscribeTask = subscriber.SubscribeAsync(cts.Token);
var timeoutToken1 = new CancellationTokenSource(10000).Token;
await Task.WhenAny(new[] { Task.WhenAll(new[] { listeningSignal.WaitHandle.AsTask(), resolutionManagingSignal.WaitHandle.AsTask(), sortingManagingSignal.WaitHandle.AsTask(), handlingManagingSignal.WaitHandle.AsTask() }), timeoutToken1.WaitHandle.AsTask() });
if (timeoutToken1.IsCancellationRequested)
{
throw new TimeoutException();
}
mockSubscriptionListener.Verify(x => x.ListenAsync(regionId, streamId, cts.Token));
mockResolutionManager.Verify(x => x.ManageAsync(cts.Token));
mockSortingManager.Verify(x => x.ManageAsync(cts.Token));
mockHandlingManager.Verify(x => x.ManageAsync(cts.Token));
cts.Cancel();
var timeoutToken2 = new CancellationTokenSource(10000).Token;
await Task.WhenAny(new[] { subscribeTask, timeoutToken2.WaitHandle.AsTask() });
if (timeoutToken2.IsCancellationRequested)
{
throw new TimeoutException();
}
}
public async Task throw_exception_when_subscribing()
{
var cts = new CancellationTokenSource(10000);
var mockSubscriptionListener = new Mock <ISubscriptionListener>();
var mockResolutionManager = new Mock <IResolutionManager>();
var mockSortingManager = new Mock <ISortingManager>();
var mockHandlingManager = new Mock <IHandlingManager>();
var mockStreamClient = new Mock <IStreamClient>();
var options = new SubscriberOptions(new List <SubscriptionStreamId>());
var subscriber = new Subscriber(NullStandardLogger.Instance, null, mockSubscriptionListener.Object, mockResolutionManager.Object, mockSortingManager.Object, mockHandlingManager.Object, null, options);
mockResolutionManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Throws(new TestException());
mockSortingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
mockHandlingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
await Assert.ThrowsAsync <TestException>(() => subscriber.SubscribeAsync(cts.Token));
}
public void Init_And_Update()
{
var unsub = new Func <SubscriptionToken, bool>(_ => true);
var action = new Action(() =>
{
});
var token = new SubscriptionToken(unsub);
var weakAction = new WeakDelegate(action, false);
var subscription = new Subscriber(token, synchronizationContext, weakAction);
var options = new SubscriberOptions(subscription);
Assert.AreEqual(token, options.Token);
//
Assert.AreEqual(ExecutionStrategyType.PublisherThread, subscription.ExecutionStrategy);
options.WithExecutionStrategy(ExecutionStrategyType.UIThread);
Assert.AreEqual(ExecutionStrategyType.UIThread, subscription.ExecutionStrategy);
}
public async Task subscribe_to_multiple_regions()
{
var cts = new CancellationTokenSource(10000);
var mockSubscriptionListener = new Mock <ISubscriptionListener>();
var mockResolutionManager = new Mock <IResolutionManager>();
var mockSortingManager = new Mock <ISortingManager>();
var mockHandlingManager = new Mock <IHandlingManager>();
var mockStreamClient = new Mock <IStreamClient>();
var regionId1 = "r1";
var regionId2 = "r2";
var streamId = "s";
var options = new SubscriberOptions(new List <SubscriptionStreamId>()
{
new SubscriptionStreamId(regionId1, streamId),
new SubscriptionStreamId(regionId2, streamId)
});
var subscriber = new Subscriber(NullStandardLogger.Instance, null, mockSubscriptionListener.Object, mockResolutionManager.Object, mockSortingManager.Object, mockHandlingManager.Object, null, options);
var mockAwaiter = new ManualResetEventSlim(false);
var listeningSignal = new ManualResetEventSlim(false);
var resolutionManagingSignal = new ManualResetEventSlim(false);
var sortingManagingSignal = new ManualResetEventSlim(false);
var handlingManagingSignal = new ManualResetEventSlim(false);
mockSubscriptionListener.Setup(x => x.ListenAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
mockResolutionManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
mockSortingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
mockHandlingManager.Setup(x => x.ManageAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
await subscriber.SubscribeAsync(cts.Token);
if (cts.IsCancellationRequested)
{
throw new TimeoutException();
}
mockSubscriptionListener.Verify(x => x.ListenAsync(regionId1, streamId, cts.Token));
mockSubscriptionListener.Verify(x => x.ListenAsync(regionId2, streamId, cts.Token));
}
internal Subscriber CreateSubscriber(Func <ReadOnlyMemory <Message>, CancellationToken, Task> push, SubscriberOptions subscriberOptions)
{
lock (sync)
{
if (subscriber != null)
{
throw new SubscriptionManagementException($"Subscription {name} is already used");
}
subscriber = new Subscriber(this, push, completedMessageId, subscriberOptions);
subscriber.StartPushLoop();
return(subscriber);
}
}
private void InitSubscriber()
{
var taskParameters = Task.Subscriber.Parameters;
switch (Task.Subscriber.Type.ToUpper())
{
case "KAFKA":
{
taskParameters.EnsureValue(nameof(KafkaOptions.Servers), out string services);
taskParameters.EnsureValue(nameof(KafkaOptions.Servers), out string topic);
KafkaOptions kafkaOptions = new KafkaOptions
{
Servers = services,
Topic = topic,
Config = Task.Subscriber.Parameters
};
Task.Subscriber.Instance =
new KafkaSubscriber(kafkaOptions, _loggerFactory.CreateLogger <KafkaSubscriber>());
break;
}
case "RABBITMQ":
{
taskParameters.EnsureValue(nameof(SubscriberOptions.HostName), out string hostName);
taskParameters.EnsureValue(nameof(SubscriberOptions.UserName), out string userName);
taskParameters.EnsureValue(nameof(SubscriberOptions.Password), out string password);
taskParameters.EnsureValue(nameof(SubscriberOptions.RoutingKey), out string routerKey);
taskParameters.EnsureValue(nameof(SubscriberOptions.QueueName), out string queueName);
taskParameters.EnsureValue(nameof(SubscriberOptions.Exchange), out string exchange);
SubscriberOptions rabbitMqOptions = new SubscriberOptions
{
HostName = hostName,
UserName = userName,
Password = password,
RoutingKey = routerKey,
QueueName = queueName,
Exchange = exchange
};
if (taskParameters.Value(nameof(SubscriberOptions.VirtualHost), out String virtualHost))
{
rabbitMqOptions.VirtualHost = virtualHost;
}
if (taskParameters.Value(nameof(SubscriberOptions.ExchangeType), out String exchangeType))
{
rabbitMqOptions.ExchangeType = exchangeType;
}
if (taskParameters.Value(nameof(SubscriberOptions.RequestedHeartbeat),
out ushort requestedHeartbeat))
{
rabbitMqOptions.RequestedHeartbeat = requestedHeartbeat;
}
if (taskParameters.Value(nameof(SubscriberOptions.AutomaticRecoveryEnabled),
out bool automaticRecoveryEnabled))
{
rabbitMqOptions.AutomaticRecoveryEnabled = automaticRecoveryEnabled;
}
Task.Subscriber.Instance = new RabbitMQSubscriber(_loggerFactory.CreateLogger <RabbitMQSubscriber>()
, rabbitMqOptions
, new PersistentConnection(rabbitMqOptions,
_loggerFactory.CreateLogger <PersistentConnection>()
));
break;
}
default:
{
throw new ArgumentException($"Can not support Subscriber.Type:[{Task.Subscriber.Type}].");
}
}
}
public SubscriberOptions(SubscriberOptions options)
{
PushIntervalMilliseconds = options.PushIntervalMilliseconds;
MaxMessagesInBatch = options.MaxMessagesInBatch;
}
