async void buttonSendMessage_Click(object sender, RoutedEventArgs e) { try { using (var connection = new SocketConnection("127.0.0.1", 4525, Scheduler.Immediate)) { var publisher = connection.AsPublisher(); await publisher.PublishMessage("alert1", textBoxMessage.Text); //await publisher.PublishMessage("alert2", textBoxMessage.Text); } using (var connection = new SocketConnection("127.0.0.1", 4525, Scheduler.Immediate)) { var cacheClient = connection.AsCacheClient(); //await cacheClient.SetValue("alert1", textBoxMessage.Text); var result = await cacheClient.GetValues(new string[]{"alert1", "alert3"}); await cacheClient.Del("alert1"); var result2 = await cacheClient.GetValues(new string[] { "alert1", "alert3" }); } } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
public RedisCacheClient(SocketConnection socketConnection) { if (socketConnection == null) throw new ArgumentNullException("socketConnection"); this.socketConnection = socketConnection; }
public async Task CanPublishAndReceiveMultipleMessagesOnChannel() { var expected = "CanPublishAndReceiveOnChannel"; using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { using (var publisherConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var subscriber = socketConnection.AsSubscriber(); var publisher = publisherConnection.AsPublisher(); var matchedReplies = 0; var tcs = new TaskCompletionSource<bool>(); var expectedMessagesCount = 512; var messagesChannel = await subscriber.Subscribe("channel1"); messagesChannel.Subscribe(message => { if (string.Compare(message.Content, expected, StringComparison.InvariantCultureIgnoreCase) == 0) matchedReplies += 1; if (matchedReplies == expectedMessagesCount) tcs.SetResult(true); }); foreach (var once in Enumerable.Repeat(Unit.Default, expectedMessagesCount)) { var result = await publisher.PublishMessage("channel1", expected); } await Task.WhenAny(Task.Delay(1000), tcs.Task); Assert.AreEqual(expectedMessagesCount, matchedReplies); } } }
public async Task CanSetKeyAndGetValue() { var expected = "CanSetKeyAndGetValue"; using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var cacheClient = socketConnection.AsCacheClient(); await cacheClient.SetValue("test1", expected); var cacheValue = await cacheClient.GetValue("test1"); Assert.AreEqual(expected, cacheValue); } }
public async Task CanSetMultipleKeysAndGetValues() { var expected = "CanSetMultipleKeysAndGetValues"; var map = new Dictionary<string, string>(); map.Add("test2", expected); map.Add("test3", expected); using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var cacheClient = socketConnection.AsCacheClient(); await cacheClient.SetValues(map); var cacheValues = await cacheClient.GetValues(map.Keys.ToArray()); Assert.AreEqual(expected, cacheValues.Take(1).First()); Assert.AreEqual(expected, cacheValues.Skip(1).Take(1).First()); } }
async void Subscribe() { var connection = new SocketConnection("127.0.0.1", 4525, Scheduler.Immediate); var currentSyncronizationContext = SynchronizationContext.Current; var subscriber = connection.AsSubscriber(); try { var channelMessagesReceived = 0; var channelsSubscription = await subscriber.Subscribe("alert1"); channelsSubscription .Buffer(TimeSpan.FromSeconds(1)) .ObserveOn(currentSyncronizationContext) .Subscribe(messages => { channelMessagesReceived += messages.Count; channelMessages.Text = channelMessagesReceived.ToString(); //listBoxAlerts.Items.Add(new ListBoxItem { Content = message.ChannelName + ":" + message.Content }); }, ex => { MessageBox.Show(ex.ToString()); }); var patternChannelMessagesReceived = 0; var channelsPatternSubscription = await subscriber.PSubscribe("alert*"); channelsPatternSubscription .Buffer(TimeSpan.FromSeconds(1)) .ObserveOn(currentSyncronizationContext) .Subscribe(messages => { patternChannelMessagesReceived += messages.Count; channelPatternMessages.Text = patternChannelMessagesReceived.ToString(); //listBoxAlerts.Items.Add(new ListBoxItem { Content = message.Pattern + ":" + message.Content }); }, ex => { MessageBox.Show(ex.ToString()); }); } catch (AggregateException ex) { MessageBox.Show(ex.ToString()); } }
public async Task CanSetKeysAndThenDeleteAll() { var expected = "CanSetKeysAndThenDeleteAll"; using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var cacheClient = socketConnection.AsCacheClient(); var map = new Dictionary<string, string>(); map.Add("test5", expected); map.Add("test6", expected); await cacheClient.SetValues(map); await cacheClient.Del(map.Keys.ToArray()); var cacheValues = await cacheClient.GetValues(map.Keys.ToArray()); Assert.IsTrue(cacheValues.All(x => x == null)); } }
public async Task CanPublishAndReceiveOnChannel() { var expected = "CanPublishAndReceiveOnChannel"; using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { using (var publisherConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var subscriber = socketConnection.AsSubscriber(); var publisher = publisherConnection.AsPublisher(); var messagesChannel = await subscriber.Subscribe("channel1"); var replaySubject = new ReplaySubject<string>(); messagesChannel.Take(1).Select(x => x.Content).Subscribe(replaySubject); await publisher.PublishMessage("channel1", expected); var result = await replaySubject.FirstAsync(); Assert.AreEqual(expected, result); } } }
public RedisSubscriber(SocketConnection socketConnection) { if (socketConnection == null) throw new ArgumentNullException("socketConnection"); this.socketConnection = socketConnection; this.upstreamChannelMessages = new Subject<RedisChannelMessage>(); this.upstreamChannelPatternMessages = new Subject<RedisChannelPatternMessage>(); this.disposables = new CompositeDisposable(); this.remainder = string.Empty; Func<bool> tryParseRemainder = () => { var parseChannelPatternMessage = RedisChannelPatternMessage.RedisChannelPatternMessageParser.TryParse(remainder); if (parseChannelPatternMessage.WasSuccessful) { var position = parseChannelPatternMessage.Remainder.Position; remainder = parseChannelPatternMessage.Remainder.Source.Substring(position); upstreamChannelPatternMessages.OnNext(parseChannelPatternMessage.Value); return true; } var parseSubscriptionMessage = RedisParsersModule.SubscriptionMessageParser.TryParse(remainder); if (parseSubscriptionMessage.WasSuccessful) { var position = parseSubscriptionMessage.Remainder.Position; remainder = parseSubscriptionMessage.Remainder.Source.Substring(position); return true; } var parseChannelMessage = RedisChannelMessage.RedisChannelMessageParser.TryParse(remainder); if (parseChannelMessage.WasSuccessful) { var position = parseChannelMessage.Remainder.Position; remainder = parseChannelMessage.Remainder.Source.Substring(position); upstreamChannelMessages.OnNext(parseChannelMessage.Value); return true; } return false; }; disposables.Add(upstreamChannelMessages); disposables.Add(upstreamChannelPatternMessages); disposables.Add( socketConnection .GetConnection() .Select(connection => connection.ReceiveMessage()) .Merge(1) .DoWhile(() => !socketConnection.IsDisposed) .SubscribeOn(socketConnection.Scheduler) .Subscribe(message => { if (message.StartsWith("-", StringComparison.InvariantCultureIgnoreCase)) { var error = new ParseException(remainder); upstreamChannelMessages.OnError(error); upstreamChannelPatternMessages.OnError(error); } remainder += message; bool previousMessageWasParsed = false; do { previousMessageWasParsed = tryParseRemainder(); } while (previousMessageWasParsed); }, ex => { upstreamChannelMessages.OnError(ex); upstreamChannelPatternMessages.OnError(ex); }, () => { upstreamChannelMessages.OnCompleted(); upstreamChannelPatternMessages.OnCompleted(); })); }
public async Task CanSetKeyAndGetText() { var expected = Enumerable.Repeat("CanSetKeyAndGetText", 1024) .Aggregate( new StringBuilder(), (builder, value) => builder.Append(value), builder => builder.ToString()); using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var cacheClient = socketConnection.AsCacheClient(); await cacheClient.SetValue("test7", expected); var cacheValue = await cacheClient.GetValue("test7"); Assert.AreEqual(expected, cacheValue); } }
public async Task ChannelsObservablesDontThrowExceptionWhenSocketConnectionIsDisposed() { var subscriptionCompleted = new TaskCompletionSource<bool>(); using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate)) { var subscriber = socketConnection.AsSubscriber(); var channelPatternMessages = await subscriber.PSubscribe("channel*"); channelPatternMessages.Subscribe( _ => { }, ex => { subscriptionCompleted.SetException(ex); }, () => { subscriptionCompleted.SetResult(true); }); } try { var completed = await subscriptionCompleted.Task; Assert.IsTrue(completed); } catch (AggregateException ex) { if (ex.InnerException is RedisException) { throw new Exception(((RedisException)ex.InnerException).SocketError.ToString()); } throw ex.InnerException; } }