protected virtual void Dispose(bool disposing) { if (!_disposed && disposing) { _disposed = true; if (_redisClient != null) { _redisClient.Quit(); // NOTE: RedisSubscription is disposable, but cannot be disposed with it holding an active subscription // without it throwing an exception ((and you can't unsubscribe from any thread other than the blocked thread, // this means that the only place that you can unsubscribe is within an onmessage event, triggered by a redis message)) // // Quit() (and dispose) closes the client, which the subscription is reliant on - so there is no // open subscription connections to worry about; basically, this is a problem for the garbage collector // to sort out. if (_redisSubscriber != null) { _redisSubscriber = null; } _redisClient.Dispose(); _redisClient = null; } } }
public RedisSubHelp(Action <string, string> OnMessage) { var config = new RedisConfigs(); var _redisClient = new RedisClient(config.Host, config.Port); _sub = new RedisSubscription(_redisClient); _sub.OnMessage += OnMessage; }
public void Send(RedisSubscription command) { Write(command); if (!Listening) { Listen(command.Parse); } }
public void Start() { _redisClient = CreateClient(); _redisSubscriber = (RedisSubscription)_redisClient.CreateSubscription(); _redisSubscriber.OnMessage += (string channel, string message) => OnRedisMessageRecieved.Invoke(channel, message); CreateAndStartSubscriptionThread(); }
public RedisStorage(IServiceProvider serviceProvider, ConnectionMultiplexer redis, RedisMessageBusOptions options) { _serviceProvider = serviceProvider; this._redis = redis; this._options = options; _database = redis.GetDatabase(); _delayJobChannelSubscription = new RedisSubscription(_serviceProvider, _redis.GetSubscriber(), Helper.GetDelayChannel(_options)); }
private void UseConnection(Action <RedisConnection> action) { var subscription = new RedisSubscription(_storage, RedisUtils.RedisClient); using (var connection = new RedisConnection(_storage, RedisUtils.RedisClient, subscription, new RedisStorageOptions().FetchTimeout)) { action(connection); } }
private void UseConnections(Action <IDatabase, RedisConnection> action) { var redis = RedisUtils.CreateClient(); var subscription = new RedisSubscription(_storage, RedisUtils.CreateSubscriber()); using (var connection = new RedisConnection(_storage, redis, subscription, new RedisStorageOptions().FetchTimeout)) { action(redis, connection); } }
private void UseConnection(Action <RedisConnection> action) { var redis = RedisUtils.CreateClient(); var subscription = new RedisSubscription(RedisUtils.CreateSubscriber()); using (var connection = new RedisConnection(redis, subscription, Guid.NewGuid().ToString(), new RedisStorageOptions().FetchTimeout)) { action(connection); } }
public string WaitForNotifyOnAny(params string[] channelNames) { string result = null; var subscription = new RedisSubscription(readOnlyClient); subscription.OnMessage = (channel, msg) => { result = msg; subscription.UnSubscribeFromAllChannels(); }; subscription.SubscribeToChannels(channelNames); //blocks return(result); }
private void OnSubscribe() { RedisClient newclient = new RedisClient(MainWindow.myRedisIP, MainWindow.myRedisPort, null, MainWindow.database); newclient.Subscribe(RedisKeyName.subscribeKey); RedisSubscription sub = new RedisSubscription(newclient); sub.OnUnSubscribe += (obj) => { Console.WriteLine(); }; sub.OnMessage = (sender, argcs) => { string thisID = argcs; try { Task thisTask = new Task(thisID); this.Dispatcher.BeginInvoke(new Action(() => { finishedTaskQueueListView.Items.Insert(0, thisTask); })); if (thisTask.Command == "svn_switch") { if (currentBranchOfServer.ContainsKey(thisTask.ServerID)) { RedisClient redis = new RedisClient(MainWindow.myRedisIP, MainWindow.myRedisPort, null, MainWindow.database); if (preBranchOfServer.ContainsKey(thisTask.ServerID)) { preBranchOfServer[thisTask.ServerID] = currentBranchOfServer[thisTask.ServerID]; } else { preBranchOfServer.Add(thisTask.ServerID, currentBranchOfServer[thisTask.ServerID]); } currentBranchOfServer[thisTask.ServerID] = int.Parse(thisTask.TagID) + 1; redis.Set <int>(RedisKeyName.currentBranchOfServerPrefix + thisTask.ServerID, int.Parse(thisTask.TagID) + 1); redis.Quit(); } else { currentBranchOfServer.Add(thisTask.ServerID, int.Parse(thisTask.TagID) + 1); } this.Dispatcher.BeginInvoke(new Action(() => { UpdateCurrentBranchInServer(); })); } } catch (Exception ex) { MessageBox.Show(ex.Message, ex.Source); return; } }; sub.SubscribeToChannels(RedisKeyName.subscribeKey); newclient.Quit(); }
/// <summary> /// Creates the input channel. /// </summary> /// <param name="subscription">The subscription parameters with which to create the channel</param> /// <returns>IAmAnInputChannel.</returns> public IAmAChannel CreateChannel(Subscription subscription) { RedisSubscription rmqSubscription = subscription as RedisSubscription; if (rmqSubscription == null) { throw new ConfigurationException("We expect an RedisSubscription or RedisSubscription<T> as a parameter"); } return(new Channel( subscription.ChannelName, _messageConsumerFactory.Create(subscription), subscription.BufferSize )); }
private void _SubscriptionHandler(string channel, RedisValue value) { // get handler lookup RedisSubscription subscription = null; if (m_Subscriptions.TryGetValue(channel, out subscription) == false || subscription == null) { return; } // update last used subscription.LastUsed = DateTime.UtcNow; // call handler subscription.Handler(channel, value); }
public void WaitForJob_WaitForTheTimeout() { //Arrange Stopwatch sw = new Stopwatch(); var subscription = new RedisSubscription(_storage, RedisUtils.CreateSubscriber()); var timeout = TimeSpan.FromMilliseconds(100); sw.Start(); //Act subscription.WaitForJob(timeout, _cts.Token); //Assert sw.Stop(); Assert.InRange(sw.ElapsedMilliseconds, 100, 120); }
public long Subscribe() { RedisClient client = CreateClient(); RedisSubscription sub = new RedisSubscription(client); sub.OnMessage += (channel, msg) => { Debug.WriteLine("<<:" + msg); }; Task.Factory.StartNew(() => { sub.SubscribeToChannels("mq:test"); }); return(0); }
public void HandleSubscription(RedisSubscription command) { _connection.Write(command.Command, command.Arguments); if (!IsSubscribed) { using (new ActivityTracer("Handle subscriptions")) { IsSubscribed = true; while (true) { var resp = _connection.Read(command.Parser); switch (resp.Type) { case RedisSubscriptionResponseType.Subscribe: case RedisSubscriptionResponseType.PSubscribe: case RedisSubscriptionResponseType.Unsubscribe: case RedisSubscriptionResponseType.PUnsubscribe: RedisSubscriptionChannel channel = resp as RedisSubscriptionChannel; Count = channel.Count; if (SubscriptionChanged != null) { SubscriptionChanged(this, new RedisSubscriptionChangedEventArgs(channel)); } break; case RedisSubscriptionResponseType.Message: case RedisSubscriptionResponseType.PMessage: RedisSubscriptionMessage message = resp as RedisSubscriptionMessage; if (SubscriptionReceived != null) { SubscriptionReceived(this, new RedisSubscriptionReceivedEventArgs(message)); } break; } if (Count == 0) { break; } } IsSubscribed = false; } } }
/// <summary> /// 订阅 /// </summary> static void Subscribe() { using (RedisNativeClient redisNativeClient = new RedisNativeClient("localhost", 6379)) using (RedisSubscription redisSubscription = new RedisSubscription(redisNativeClient)) { redisSubscription.OnMessage += (e, m) => { Console.WriteLine("Subscribe OnMessage:{0} {1}", e, m); }; redisSubscription.OnSubscribe += (m) => { Console.WriteLine("Subscribe OnSubscribe:{0}", m); }; redisSubscription.OnUnSubscribe += (m) => { Console.WriteLine(" Subscribe OnUnSubscribe:{0}", m); }; redisSubscription.SubscribeToChannels("channel-lcq"); } }
/// <summary> /// Async connection. Main thread will stall without this if connection cannot instantly be made. /// </summary> public void ConnectAll() { List <string> hosts = AutomationMaster.ConfigReader.GetString("SOCKET_HOSTS_PIPE_SEPERATED").Split('|').ToList(); for (int h = 0; h < hosts.Count; h++) { try { RedisSubscription r = new RedisSubscription(hosts[h], SOCKET_PORT); r.OnSubscribe += OnSubscribe; r.OnUnsubscribe += OnSubscribe; r.Subscribe(SOCKET_CHANNEL_NAME); r.OnMessageReceived += ReceiveCallback; RedisConnection c = new RedisConnection(hosts[h], SOCKET_PORT); Subscriptions.Add(new KeyValuePair <RedisSubscription, RedisConnection>(r, c)); ConnectionStrategy.OutgoingCommandQueue.Add(string.Format("SocketConnectionStrategy Subscription Phase: {0} : SUCCESS", hosts[h])); } catch (System.Net.Sockets.SocketException e) { ConnectionStrategy.OutgoingCommandQueue.Add(string.Format("SocketConnectionStrategy Subscription Phase: {0} : {1}", hosts[h], e.Message)); } } SubscriptionsComplete = true; }
public RedisSubHelp(RedisCache client, Action <string, string> OnMessage) { _sub = new RedisSubscription(client.Client); _sub.OnMessage += OnMessage; }
/// <summary> /// 构造函数 /// </summary> public RedisSubscriber() { this.redisClient = (RedisClient)RedisManager.GetClient(); this.redisSubscription = new RedisSubscription(redisClient); }
static async Task Main(string[] args) { using var client = new RedisClient("localhost"); string msg = await client.EchoAsync("Hello world!"); Console.WriteLine(msg); string response = await client.SelectAsync(0); Console.WriteLine(response); long count = await client.RPushAsync("test", "one"); Console.WriteLine(count); count = await client.RPushAsync("test", "two"); Console.WriteLine(count); count = await client.LInsertBeforeAsync("test", "two", "one.five"); Console.WriteLine("c: " + count); string val = await client.LIndexAsync("test", -2); Console.WriteLine(val); long len = await client.LLenAsync("test"); Console.WriteLine("l: " + len); long len2 = await client.LPushAsync("test", "point.five"); Console.WriteLine("l2: " + len2); long len3 = await client.LPushXAsync("test", "point.twofive"); Console.WriteLine("l3: " + len3); long rem = await client.LRemAsync("test", -2, "one"); Console.WriteLine("rem: " + rem); string s = await client.LSetAsync("test", -4, "upd"); Console.WriteLine("s: " + s); foreach (string item in await client.LRangeAsync("test", 3, 5)) { Console.WriteLine("r: " + item); } string tr = await client.LTrimAsync("test", -2, 0); Console.WriteLine("tr: " + tr); long fin = await client.LPushAsync("test", "final"); Console.WriteLine("fin: " + fin); string rot = await client.RPopLPushAsync("test", "test"); Console.WriteLine("rot: " + rot); string value; while ((value = await client.LPopAsync("test")) != null) { Console.WriteLine(value); } RedisSubscription subscription = await client.SubscribeAsync("test1", "test2"); Console.ReadKey(true); }