public void PubLishMsg(string channel, string msg)
{
try
{
Console.WriteLine("发布服务");
IRedisClientsManager redisClients = new PooledRedisClientManager($"{_option.Password}@{_option.Server}:{_option.Port}");
RedisPubSubServer redisPubSub = new RedisPubSubServer(redisClients, channel)
//{
// //OnMessage = (channel, msg) =>
// //{
// // Console.WriteLine($"从频道{channel}上接收消息：{msg},时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:sss")}");
// // Console.WriteLine("————————————————————————————");
// //},
// OnStart = () =>
// {
// Console.WriteLine("————————发布服务已启动————————————");
// }
// ,
// OnStop = () => { Console.WriteLine("发布服务停止"); },
// OnUnSubscribe = c => { Console.WriteLine(c); },
// OnError = e => { Console.WriteLine(e.Message); },
// OnFailover = s => { Console.WriteLine(s); }
//}
;
redisPubSub.Start();
redisClients.GetClient().PublishMessage(channel, msg);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void UpdateLike()
{
var clientsManager = new RedisManagerPool(RedisIP + ":" + RedisPort);
var redisPubSub = new RedisPubSubServer(clientsManager, "recordlike")
{
OnMessage = (channel, message) => {
string[] strs = message.Split('|');
string userid = strs[1];
string recordid = strs[0].TrimStart('r');
var like = _db.RecordLikes.FirstOrDefault(t => t.CommentUserId == userid && t.RecordId == recordid);
if (like == null)
{
like = new RecordLike();
like.CommentUserId = userid;
like.RecordId = recordid;
like.CreateTime = DateTime.Now;
like.IsCancel = false;
_db.RecordLikes.Add(like);
}
else if (Convert.ToBoolean(strs[2]))
{
like.IsCancel = false;
}
else
{
like.IsCancel = true;
}
_db.SaveChanges();
}
}.Start();
}
static void NotMain(string[] args)
{
Console.WriteLine("Hello World!");
var clientsManager = new PooledRedisClientManager();
Semaphore luck = new Semaphore(0, 1);
var redisPubSub = new RedisPubSubServer(clientsManager, "addtask")
{
OnMessage = (channel, msg) =>
{
if (msg == "aranan")
{
luck.Release();
}
else
{
Console.WriteLine(msg);
}
},
};
var obj = (redisPubSub, luck);
Thread t = new Thread(new ParameterizedThreadStart(CloseRedis));
t.Start(obj);
redisPubSub.Start();
Console.WriteLine("redis started");
while (true)
{
Thread.Sleep(100);
}
Console.WriteLine("finished");
}
public static void Pub()
{
//PooledRedisClientManager
IRedisClientsManager RedisClientManager = new PooledRedisClientManager("192.168.1.117:6379");
//发布、订阅服务 IRedisPubSubServer
RedisPubSubServer pubSubServer = new RedisPubSubServer(RedisClientManager, "channel-1", "channel-2");
//接收消息
pubSubServer.OnMessage = (channel, msg) =>
{
Console.WriteLine(string.Format("服务端:频道{0}接收消息：{1} 时间：{2}", channel, msg, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")));
Console.WriteLine("___________________________________________________________________");
};
pubSubServer.OnStart = () =>
{
Console.WriteLine("发布服务已启动");
Console.WriteLine("___________________________________________________________________");
};
pubSubServer.OnStop = () => { Console.WriteLine("服务停止"); };
pubSubServer.OnUnSubscribe = (channel) => { Console.WriteLine(channel); };
pubSubServer.OnError = (e) => { Console.WriteLine(e.Message); };
pubSubServer.OnFailover = (s) => { Console.WriteLine(s); };
//pubSubServer.OnHeartbeatReceived = () => { Console.WriteLine("OnHeartbeatReceived"); };
//pubSubServer.OnHeartbeatSent = () => { Console.WriteLine("OnHeartbeatSent"); };
//pubSubServer.IsSentinelSubscription = true;
pubSubServer.Start();
}
public static void RedisPubSubBug()
{
/*
* At the beginning I was using servicestack redis client implementation but below is why I changed it to stackexchange client.
* Basically when you publish burst messages subscriber does not call onmessage handler for each message.(something like buffer overflowing occurs probably)
* stackexchange client queues messages and does not have this problem.
*/
var clientsManager = new PooledRedisClientManager();
var guid = Guid.NewGuid();
int count = 0;
var pubsub = new RedisPubSubServer(clientsManager, guid.ToString())
{
OnMessage = ((s, s1) =>
{
count++;
Thread.Sleep(50);
}),
};
pubsub.Start();
var anotherClientsManager = new PooledRedisClientManager();
var client = anotherClientsManager.GetClient();
for (int i = 0; i < 100; i++)
{
client.PublishMessage(guid.ToString(), "asd");
}
pubsub.Dispose();
Console.WriteLine(count);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var redisPubSub = new RedisPubSubServer(_clientManager, "SignalRCore.Hubs.ChatHub:all")
{
OnStart = () =>
{
Trace.WriteLine("Connection started");
},
OnMessage = (channel, msg) =>
{
var message = JsonConvert.DeserializeObject <MessageModel>(msg);
_hubContext.Clients.All.SendAsync("ReceiveMessage", message);
},
OnError = (error) =>
{
Trace.WriteLine($"ProcessingHub -> OnError throws {error}");
},
OnFailover = (error) =>
{
Trace.WriteLine("Failover initiated");
}
};
redisPubSub.IsSentinelSubscription = true;
redisPubSub.Start();
}
public RedisPubSubServer Subscribe(string channel, Action <string, string> message_handler)
{
var subscriber = new RedisPubSubServer(this._redis_pool, channel)
{
OnMessage = message_handler
};
subscriber.Start();
Logger.InfoFormat("Subscribe Redis channel: {0}", channel);
this._subscribers.Add(new KeyValuePair <string, RedisPubSubServer>(channel, subscriber));
return(subscriber);
}
public void Execute()
{
_manager = new RedisManagerPool(Config.MasterHost);
_startedAt = DateTime.Now;
var q = new Timer(OnInterval, null, 0, 1000);
Console.WriteLine(q);
using (_pubSubServer = new RedisPubSubServer(_manager, _channel)
{
OnStart = () => {
Console.WriteLine("OnStart: #" + Interlocked.Increment(ref _startCount));
},
OnHeartbeatSent = () => {
Console.WriteLine("OnHeartbeatSent: #" + Interlocked.Increment(ref _heartbeatsSent));
},
OnHeartbeatReceived = () => {
Console.WriteLine("OnHeartbeatReceived: #" + Interlocked.Increment(ref _heartbeatsReceived));
},
OnMessage = (channel, msg) => {
Console.WriteLine("OnMessage: @" + channel + ": " + msg);
},
OnStop = () => {
Console.WriteLine("OnStop: #" + Interlocked.Increment(ref _stopCount));
},
OnError = ex => {
Console.WriteLine("OnError: #" + Interlocked.Increment(ref _errorCount) + " ERROR: " + ex);
},
OnFailover = server => {
Console.WriteLine("OnFailover: #" + Interlocked.Increment(ref _failoverCount));
},
OnDispose = () => {
Console.WriteLine("OnDispose: #" + Interlocked.Increment(ref _disposeCount));
},
OnUnSubscribe = channel => {
Console.WriteLine("OnUnSubscribe: #" + Interlocked.Increment(ref _unSubscribeCount) + " channel: " + channel);
}
}) {
Console.WriteLine("PubSubServer StartedAt: " + _startedAt.ToLongTimeString());
_pubSubServer.Start();
Thread.Sleep(TimeSpan.FromSeconds(10000));
Console.WriteLine("PubSubServer EndedAt: " + DateTime.Now.ToLongTimeString());
Console.WriteLine("PubSubServer TimeTaken: " + (DateTime.Now - _startedAt).TotalSeconds + "s");
}
}
private static RedisPubSubServer CreatePubSubServer(
int intervalSecs = 1, int timeoutSecs = 3)
{
var clientsManager = new RedisManagerPool(TestConfig.MasterHosts);
using (var redis = clientsManager.GetClient())
redis.FlushAll();
var pubSub = new RedisPubSubServer(
clientsManager,
"topic:test")
{
HeartbeatInterval = TimeSpan.FromSeconds(intervalSecs),
HeartbeatTimeout = TimeSpan.FromSeconds(timeoutSecs)
};
return pubSub;
}
private RedisPubSubServer CreatePubSubServer(int intervalSecs = 1, int timeoutSecs = 3)
{
var clientsManager = new PooledRedisClientManager(Config.MasterHost);
using (var redis = clientsManager.GetClient()) {
redis.FlushAll();
}
var pubSub = new RedisPubSubServer(
clientsManager,
"topic:test")
{
HeartbeatInterval = TimeSpan.FromSeconds(intervalSecs),
HeartbeatTimeout = TimeSpan.FromSeconds(timeoutSecs)
};
return(pubSub);
}
public RedisMqServer(IRedisClientsManager clientsManager,
int retryCount = DefaultRetryCount, TimeSpan?requestTimeOut = null)
{
this.clientsManager = clientsManager;
RedisPubSub = new RedisPubSubServer(clientsManager, QueueNames.TopicIn)
{
OnInit = OnInit,
OnStart = OnStart,
OnStop = OnStop,
OnError = OnError,
OnMessage = OnMessage,
};
this.RetryCount = retryCount;
//this.RequestTimeOut = requestTimeOut;
this.MessageFactory = new RedisMessageFactory(clientsManager);
this.ErrorHandler = ex => Log.Error("Exception in Redis MQ Server: " + ex.Message, ex);
this.WaitBeforeNextRestart = TimeSpan.FromMilliseconds(2000);
}
static void Main(string[] args)
{
try
{
//创建一个公众号--创建一个主题
Console.WriteLine("发布服务");
IRedisClientsManager redisClientManager = new PooledRedisClientManager("[email protected]:6379");
string channelName = "Send_Log"; //频道名
//发布服务器
RedisPubSubServer pubSubServer = new RedisPubSubServer(redisClientManager, channelName)
{
OnMessage = (channel, msg) =>
{
Console.WriteLine($"从频道：{channel}上接受到消息：{msg},时间：{DateTime.Now.ToString("yyyyMMdd HH:mm:ss")}");
Console.WriteLine("___________________________________________________________________");
},
OnStart = () =>
{
Console.WriteLine("发布服务已启动");
Console.WriteLine("___________________________________________________________________");
},
OnStop = () => { Console.WriteLine("发布服务停止"); },
OnUnSubscribe = channel => { Console.WriteLine(channel); },
OnError = e => { Console.WriteLine(e.Message); },
OnFailover = s => { Console.WriteLine(s); },
};
//接收消息
pubSubServer.Start();
while (true)
{
Console.WriteLine("请输入记录的日志");
string message = Console.ReadLine();
redisClientManager.GetClient().PublishMessage(channelName, message);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
//发布直接用client.PublishMessage即可发布消息，但是如下方式可以起到监听发布者的功能
private void button47_Click(object sender, EventArgs e)
{
redisClientManager = new PooledRedisClientManager(textBox_passwd.Text +"@"+ textBox_ip.Text.ToString()+":"+textBox_port.Text.ToString());
pubSubServer = new RedisPubSubServer(redisClientManager, "channel1")
{
OnMessage = (channel, msg) =>
{
Console.WriteLine($"pubServer {channel} 发布服务发布消息 {msg}");
},
OnStart = () =>
{
Console.WriteLine($"pubServer 发布服务start ");
},
OnStop = () => { Console.WriteLine("pubServer 发布服务停止"); },
OnUnSubscribe = (channel) => { Console.WriteLine("pubServer 取消订阅 "+channel); },
OnError = (err) => { Console.WriteLine("pubServer " + err.Message); },
OnFailover = (s) => { Console.WriteLine("pubServer " + s); }
};
pubSubServer.Start();
}
private RedisPubSubServer CreatePubSubServer(
int intervalSecs = 1, int timeoutSecs = 3, params string[] channels)
{
using (var redis = clientsManager.GetClient())
redis.FlushAll();
if (channels.Length == 0)
{
channels = new[] { "topic:test" }
}
;
var pubSub = new RedisPubSubServer(
clientsManager,
channels)
{
HeartbeatInterval = TimeSpan.FromSeconds(intervalSecs),
HeartbeatTimeout = TimeSpan.FromSeconds(timeoutSecs)
};
return(pubSub);
}
/// <summary>
///
/// </summary>
static void PubSubServer()
{
Console.Title = "发布服务器";
string strChannel = "channel-lcq";
using (PooledRedisClientManager pooledRedisClientManager = new PooledRedisClientManager("localhost"))
using (RedisPubSubServer redisPubSubServer = (RedisPubSubServer)pooledRedisClientManager.CreatePubSubServer(channel: strChannel))
{
redisPubSubServer.OnStart += () => { Console.WriteLine("PubSubServer start channel:{0} ", strChannel); };
redisPubSubServer.OnStop += () => { Console.WriteLine("PubSubServer stop channel:{0} ", strChannel); };
redisPubSubServer.OnMessage += (e, m) => { Console.WriteLine("RedisPubSubServer OnMessage:{0} {1}", e, m); };
redisPubSubServer.OnHeartbeatSent += () => { Console.WriteLine("OnHeartbeatSent"); };
redisPubSubServer.Start();//启动发布服务
Console.WriteLine("请输入消息内容...");
while (true)
{
string message = Console.ReadLine();
PublishMessage(message);//发布消息
}
Console.ReadLine();
}
}
public RedisPubSubServerHelper(PubSubChannel pubSubChannelName)
{
pubSubChannel = pubSubChannelName.ToString();
pubSubServer = new RedisPubSubServer(RedisHelper.PooledRedisClientManager, pubSubChannel);
pubSubServer.Start();
}
public void Execute(string ipAddress)
{
Manager = new RedisManagerPool(ipAddress);
StartedAt = DateTime.UtcNow;
var q = new Timer {
Interval = 1000
};
q.Elapsed += OnInterval;
q.Enabled = true;
using (PubSubServer = new RedisPubSubServer(Manager, Channel)
{
OnStart = () =>
{
Console.WriteLine("OnStart: #" + Interlocked.Increment(ref StartCount));
},
OnHeartbeatSent = () =>
{
Console.WriteLine("OnHeartbeatSent: #" + Interlocked.Increment(ref HeartbeatsSent));
},
OnHeartbeatReceived = () =>
{
Console.WriteLine("OnHeartbeatReceived: #" + Interlocked.Increment(ref HeartbeatsReceived));
},
OnMessage = (channel, msg) =>
{
Console.WriteLine("OnMessage: @" + channel + ": " + msg);
},
OnStop = () =>
{
Console.WriteLine("OnStop: #" + Interlocked.Increment(ref StopCount));
},
OnError = ex =>
{
Console.WriteLine("OnError: #" + Interlocked.Increment(ref ErrorCount) + " ERROR: " + ex);
},
OnFailover = server =>
{
Console.WriteLine("OnFailover: #" + Interlocked.Increment(ref FailoverCount));
},
OnDispose = () =>
{
Console.WriteLine("OnDispose: #" + Interlocked.Increment(ref DisposeCount));
},
OnUnSubscribe = channel =>
{
Console.WriteLine("OnUnSubscribe: #" + Interlocked.Increment(ref UnSubscribeCount) + " channel: " + channel);
},
})
{
Console.WriteLine("PubSubServer StartedAt: " + StartedAt.ToLongTimeString());
PubSubServer.Start();
"Press Enter to Quit...".Print();
Console.ReadLine();
Console.WriteLine("PubSubServer EndedAt: " + DateTime.UtcNow.ToLongTimeString());
Console.WriteLine("PubSubServer TimeTaken: " + (DateTime.UtcNow - StartedAt).TotalSeconds + "s");
}
}
