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);
}
