public void Start()
{
CacheMessage.Subscribe(n => SendMessage(n), CacheNotifyAction.Insert);
CacheRegisterUser.Subscribe(n => RegisterUser(n), CacheNotifyAction.Insert);
CacheCreateClient.Subscribe(n => CreateOrUpdateClient(n), CacheNotifyAction.Insert);
CacheDisableClient.Subscribe(n => DisableClient(n), CacheNotifyAction.Insert);
}
public void AddMesssage(CacheMessage message)
{
list.ForEach(t =>
{
t.Add(message);
});
}
public void Stop()
{
CacheMessage.Unsubscribe(CacheNotifyAction.Insert);
CacheRegisterUser.Unsubscribe(CacheNotifyAction.Insert);
CacheCreateClient.Unsubscribe(CacheNotifyAction.Insert);
CacheDisableClient.Unsubscribe(CacheNotifyAction.Insert);
}
protected void SetResponse(Expression <Func <StatusCode, int> > selector, object input, BaseOutput output)
{
var messageInfo = CacheMessage.Get(selector);
output.code = messageInfo.Code;
output.msg = messageInfo.Description;
}
public static void TryEnqueue(this IBusContext ctx, CacheMessage message)
{
if (message == null)
{
return;
}
ctx.Enqueue(ContextName, message);
}
private static void SendInternal(this IBusContext ctx, CacheMessage message, bool onCallback = false)
{
if (onCallback)
{
message.Token = message.Token ?? message.RequestId.ToString();
MessageLogger.Sended(message);
}
ctx.Enqueue(ContextName, message);
}
public void CacheHitQuery(string id, bool count)
{
var msg = new CacheMessage()
{
Connection = id,
Kind = count ? Kind.CachedCount : Kind.CachedQuery
}.AsTimedMessage(GetPoint());
msg.Duration = NearlyNothing;
Publish2(msg);
}
public void CacheHitObject(string id, int objs)
{
var msg = new CacheMessage()
{
Connection = id,
Kind = Kind.CachedObject,
Objects = objs
}.AsTimedMessage(GetPoint());
msg.Duration = NearlyNothing;
Publish2(msg);
}
/// <summary>
/// 设置单个数据
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="key">key</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
/// <returns></returns>
private bool SetAndPublish <T>(string key, T value, TimeSpan?expiry = null)
{
if (expiry.HasValue)
{
_memoryCache.Set(key, value, expiry.Value);
}
else
{
_memoryCache.Set(key, value);
}
_messageBus?.PublishAsync(CacheSyncChannel, CacheMessage.SetDeleteMessage(_serverId, key));
return(true);
}
private void Timer_Run(object state)
{
//处理日志信息
List <CacheMessage> list = MonitorCache.GetInstance().PopMessages(CacheEnum.LogMonitor);
while (list.Count > 0)
{
CacheMessage message = list[0];
string text = string.Format("{0} -- Message:{1} -- Stack Trace:{2}", message.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss"), message.Message, message.StackTrace);
//_logger.Write(text, false);
list.Remove(message);
}
}
public virtual void StoreCache(CacheMessage message)
{
if (message == null)
{
return;
}
var dto = message.Content.JsonDeserialize <T>();
if (dto == null)
{
return;
}
Process(dto);
}
private static void Loging()
{
SimpleLogger _logger = new SimpleLogger(_logPath);
while (1 == 1)
{
//处理日志信息
List <CacheMessage> list = MonitorCache.GetInstance().PopMessages(CacheEnum.LogMonitor);
while (list.Count > 0)
{
CacheMessage message = list[0];
string text = string.Format("{0} -- Message:{1} -- Stack Trace:{2}", message.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss"), message.Message, message.StackTrace);
_logger.Write(text, false);
list.Remove(message);
}
Thread.Sleep(100);
}
}
private void timer1_Tick(object sender, EventArgs e)
{
//处理日志信息
List <CacheMessage> list = MonitorCache.GetInstance().PopMessages(CacheEnum.FormMonitor);
while (list.Count > 0)
{
if (lbMessage.Items.Count > 100000)
{
lbMessage.Items.Clear();
}
else
{
CacheMessage message = list[0];
string text = string.Format("{0} -- {1}\r\n", message.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss"), message.Message);
lbMessage.Items.Insert(0, text);
list.Remove(message);
}
}
tssTimer.Text = "时间：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
}
private void OnMessage(CacheMessage message)
{
if (message == null ||
message.Keys == null ||
message.ServiceId == SERVICE_ID) //非本程序发送的消息，不做处理
{
return;
}
//检测缓存是否存在
for (var i = 0; i < message.Keys.Length; i++)
{
var key = message.Keys[i];
if (string.IsNullOrEmpty(key))
{
continue;
}
_memoryStore.Remove(key);
}
}
public async Task <TaskResult <ulong> > PostMessage(PlanetMessage msg)
{
//ClientMessage msg = JsonConvert.DeserializeObject<ClientMessage>(json);
if (msg == null)
{
return(new TaskResult <ulong>(false, "Malformed message.", 0));
}
ulong channel_id = msg.Channel_Id;
PlanetChatChannel channel = await Context.PlanetChatChannels.FindAsync(channel_id);
// Get index for message
ulong index = channel.Message_Count;
// Update message count. May have to queue this in the future to prevent concurrency issues.
channel.Message_Count += 1;
await Context.SaveChangesAsync();
msg.Message_Index = index;
string json = JsonConvert.SerializeObject(msg);
await MessageHub.Current.Clients.Group(channel_id.ToString()).SendAsync("Relay", json);
CacheMessage cachemsg = new CacheMessage();
cachemsg.Channel_Id = msg.Channel_Id;
cachemsg.Content = msg.Content;
cachemsg.Message_Index = msg.Message_Index;
cachemsg.TimeSent = msg.TimeSent;
cachemsg.Author_Id = msg.Author_Id;
await Context.Messages.AddAsync(cachemsg);
await Context.SaveChangesAsync();
return(new TaskResult <ulong>(true, $"Posted message {msg.Message_Index}.", index));
}
public async Task <bool> Handle(SendMessageCommand request, CancellationToken cancellationToken)
{
// Get User from Cache
CacheUser cacheUser = await _chatCacheModule.GetUserAsync(request.ConnectionId, cancellationToken);
if (cacheUser == null)
{
throw new Exception("User doesnt exist. Please login");
}
// Get User's Room from Cache
if (cacheUser.ConnectedRoomId == null)
{
throw new Exception("User didnt join any room. Please join to a room");
}
CacheRoom cacheRoom = await _chatCacheModule.GetRoomAsync(cacheUser.ConnectedRoomId, cancellationToken);
// Set Room Message
CacheMessage cacheMessage = new CacheMessage()
{
Message = request.Message, DateTime = request.DateTime, SenderNickName = cacheUser.NickName
};
cacheRoom.Messages.Add(cacheMessage);
await _chatCacheModule.SetRoomAsync(cacheRoom, cancellationToken);
// Publish
await _mediator.Publish(
new ReceiveMessageNotification()
{
RoomId = cacheUser.ConnectedRoomId, ConnectionId = request.ConnectionId, CacheMessage = cacheMessage
},
cancellationToken);
return(await Task.FromResult(true));
}
public void Add(CacheMessage message)
{
MonitorCache.GetInstance().PushMessage(message, CacheEnum.FormMonitor);
}
public void SendMessage(NotifyMessage m)
{
CacheMessage.Publish(m, CacheNotifyAction.Insert);
}
