public NetEventIOServer_Options(OnPasswordLogin onPasswordLogin, OnTokenLogin onTokenLogin, OnSubscribe onSubscribe,
OnUnsubscribe onUnsubscribe, OnUnsubscribeAll onUnsubscribeAll) : this(onPasswordLogin, onTokenLogin)
{
this.onSubscribe = onSubscribe;
this.onUnsubscribe = onUnsubscribe;
this.onUnsubscribeAll = onUnsubscribeAll;
}
/// <summary>
/// 回调函数
/// </summary>
/// <param name="sessionId"></param>
/// <param name="msgType"></param>
/// <param name="error"></param>
/// <param name="info"></param>
/// <param name="pUser"></param>
/// <returns></returns>
public static int HandlerWork(IntPtr sessionId, uint msgType, uint error, string info, IntPtr pUser)
{
OnSubscribe?.Invoke(null, new SubscribeEventArgs(sessionId, msgType, error, info, pUser));
return(0);
//switch (MsgType)
//{
// case 20:
// JObject obj = (JObject)JsonConvert.DeserializeObject(Info);
// if (Error == 0)
// {
// //PlayMainWindow.jObjInfo = obj;
// //PlayMainWindow.isOpertion = 2;
// }
// break;
// case 3:// 播放开始
// break;
// case 4:// 播放终止
// break;
// case 5:// 播放结束，回放结束时会有此消息
// //PlayMainWindow.mType = PlayMainWindow.MessageType.INS_PLAY_ARCHIVE_END;
// break;
// default:
// break;
//}
//return 0;
}
private void SubscribeCommandParams(Chat chat, User user, InputMessage message, String param)
{
if ([email protected] == 0)
{
var formatedParam = SUPPORTED_SUBSCRIBE_TYPES.FirstOrDefault(x => x.Equals(param, StringComparison.InvariantCultureIgnoreCase));
if (formatedParam != null)
{
[email protected](formatedParam);
SendText(chat, $"Please input {formatedParam} id.");
return;
}
}
else if ([email protected] == 1)
{
long id;
if (long.TryParse(param, out id))
{
[email protected](id.ToString());
DisagreeCurrentCommand(chat);
OnSubscribe?.Invoke(message);
SendText(chat, $"You are successfully subscribed to {message.@params[0]} with ID {message.@params[1]}.");
return;
}
}
DisagreeCurrentCommand(chat);
SendText(chat, $"Invalid parameter.{Environment.NewLine}Please try execute '/{message.action}' again.");
}
public NetEventIOServer_Options(OnPasswordLogin onPasswordLogin, OnTokenLogin onTokenLogin) : this()
{
this.onPasswordLogin = onPasswordLogin;
this.onTokenLogin = onTokenLogin;
this.onSubscribe = (NetEventIO sender, string topicName) => { return(false); };
this.onUnsubscribe = (NetEventIO sender, string topicName) => { return(false); };
this.onUnsubscribeAll = (NetEventIO sender) => { return(false); };
}
public async Task <bool> Subscribe(string topic, Action <Message> callback)
{
if (Id != null && Id.Length > 0)
{
callbacks[topic] = callback;
bool result = await Client.InvokeAsync <bool>("+", new object[] { topic }).ConfigureAwait(false);
Message();
OnSubscribe?.Invoke(topic);
return(result);
}
return(false);
}
internal Task Dispatcher(string PublishName, dynamic Args, string ConnectionId)
{
if (OnSubscribe == null)
{
return(Task.CompletedTask);
}
var task = Task.Run(() =>
{
OnSubscribe.Invoke(new HubArgs
{
PublishName = PublishName,
PublishArgs = Args,
ConnectionId = ConnectionId
});
});
return(Task.WhenAll(new Task[] { task }));
}
public NetEventIOServer_Options()
{
onPasswordLogin = (NetEventIO client, string pwd) =>
{
return(false);
};
onTokenLogin = (NetEventIO client, string token, string addr) =>
{
return(false);
};
onSubscribe = (NetEventIO sender, string topicName) =>
{
return(false);
};
onUnsubscribe = (NetEventIO sender, string topicName) =>
{
return(false);
};
}
public void StartServer(string UID, string PWD, int Port)
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(Port)
.WithConnectionValidator(c =>
{
if (c.Username != UID)
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
if (c.Password != PWD)
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
c.ReasonCode = MqttConnectReasonCode.Success;
//Dopo aver validato il Client,Registro la connessione
OnSubscribe?.Invoke(c.ClientId);
});
var factory = new MqttFactory();
var server = factory.CreateMqttServer();
server.UseApplicationMessageReceivedHandler(x => OnReceive?.Invoke(
new Models.MQTTBrokerMessage()
{
ID = x.ClientId,
Payload = x.ApplicationMessage.ConvertPayloadToString(),
Topic = x.ApplicationMessage.Topic
}));
server.StartAsync(optionsBuilder.Build()).Wait();
server.ClientSubscribedTopicHandler = new MqttServerClientSubscribedHandlerDelegate(e =>
{
Console.WriteLine("{0} {1} è in ascolto sul topic {2}", DateTime.Now, e.ClientId, e.TopicFilter.Topic);
});
}
public void Register(IEventSubscription subscription, Dictionary <string, string> connectArgs = null)
{
try
{
lock (subscription)
{
if (connectArgs != null)
{
subscription.Publish("cmd.onConnect", connectArgs.ToJson());
}
subscription.OnUnsubscribe = HandleUnsubscription;
foreach (string channel in subscription.Channels ?? EventSubscription.UnknownChannel)
{
RegisterSubscription(subscription, channel, ChannelSubcriptions);
}
RegisterSubscription(subscription, subscription.SubscriptionId, Subcriptions);
RegisterSubscription(subscription, subscription.UserId, UserIdSubcriptions);
RegisterSubscription(subscription, subscription.UserName, UserNameSubcriptions);
RegisterSubscription(subscription, subscription.SessionId, SessionSubcriptions);
OnSubscribe?.Invoke(subscription);
if (NotifyChannelOfSubscriptions && subscription.Channels != null && NotifyJoin != null)
{
NotifyJoin(subscription);
}
else
{
FlushNopToChannels(subscription.Channels);
}
}
}
catch (Exception ex)
{
Log.Error("Register: " + ex.Message, ex);
OnError?.Invoke(subscription, ex);
throw;
}
}
/// <summary>
/// 订阅（关注）事件
/// </summary>
public override IResponseMessageBase OnEvent_SubscribeRequest(RequestMessageEvent_Subscribe requestMessage)
{
//1、业务处理
OnSubscribe?.Invoke(null, requestMessage);
//2、图文消息
if (!string.IsNullOrEmpty(Messages.SubscribeMsg))
{
var textResponseMessage = base.CreateResponseMessage <ResponseMessageText>();
textResponseMessage.Content = Messages.SubscribeMsg;
return(textResponseMessage);
}
else if (Messages.SubscribeArticle != null)
{
var newsResponseMessage = base.CreateResponseMessage <ResponseMessageNews>();
newsResponseMessage.ArticleCount = 1;
newsResponseMessage.Articles.Add(Messages.SubscribeArticle);
return(newsResponseMessage);
}
//3、没有配置 不回复任何信息
return(new SuccessResponseMessage());
}
protected bool Subscribe(string topic, ServiceContext context)
{
var id = GetId(context);
var topics = Messages.GetOrAdd(id, (_) => new ConcurrentDictionary <string, BlockingCollection <Message> >());
if (topics.TryGetValue(topic, out var messages))
{
if (messages != null)
{
return(false);
}
}
messages = new BlockingCollection <Message>(MessageQueueMaxLength);
topics.AddOrUpdate(topic, messages, (_, oldmessages) => {
if (oldmessages != null)
{
messages.Dispose();
return(oldmessages);
}
return(messages);
});
OnSubscribe?.Invoke(id, topic, context);
return(true);
}
/// <summary>
/// Processes the message, updating our internal state and then invokes the events.
/// </summary>
/// <param name="message"></param>
private void ProcessMessage(IMessage message)
{
if (message == null)
{
return;
}
switch (message.Type)
{
//We got a update, so we will update our current presence
case MessageType.PresenceUpdate:
lock (_sync)
{
PresenceMessage pm = message as PresenceMessage;
if (pm != null)
{
//We need to merge these presences together
if (CurrentPresence == null)
{
CurrentPresence = pm.Presence;
}
else if (pm.Presence == null)
{
CurrentPresence = null;
}
else
{
CurrentPresence.Merge(pm.Presence);
}
//Update the message
pm.Presence = CurrentPresence;
}
}
break;
//Update our configuration
case MessageType.Ready:
ReadyMessage rm = message as ReadyMessage;
if (rm != null)
{
lock (_sync)
{
Configuration = rm.Configuration;
CurrentUser = rm.User;
}
//Resend our presence and subscription
SynchronizeState();
}
break;
//Update the request's CDN for the avatar helpers
case MessageType.JoinRequest:
if (Configuration != null)
{
//Update the User object within the join request if the current Cdn
JoinRequestMessage jrm = message as JoinRequestMessage;
if (jrm != null)
{
jrm.User.SetConfiguration(Configuration);
}
}
break;
case MessageType.Subscribe:
lock (_sync)
{
SubscribeMessage sub = message as SubscribeMessage;
Subscription |= sub.Event;
}
break;
case MessageType.Unsubscribe:
lock (_sync)
{
UnsubscribeMessage unsub = message as UnsubscribeMessage;
Subscription &= ~unsub.Event;
}
break;
//We got a message we dont know what to do with.
default:
break;
}
//Invoke the appropriate methods
switch (message.Type)
{
case MessageType.Ready:
if (OnReady != null)
{
OnReady.Invoke(this, message as ReadyMessage);
}
break;
case MessageType.Close:
if (OnClose != null)
{
OnClose.Invoke(this, message as CloseMessage);
}
break;
case MessageType.Error:
if (OnError != null)
{
OnError.Invoke(this, message as ErrorMessage);
}
break;
case MessageType.PresenceUpdate:
if (OnPresenceUpdate != null)
{
OnPresenceUpdate.Invoke(this, message as PresenceMessage);
}
break;
case MessageType.Subscribe:
if (OnSubscribe != null)
{
OnSubscribe.Invoke(this, message as SubscribeMessage);
}
break;
case MessageType.Unsubscribe:
if (OnUnsubscribe != null)
{
OnUnsubscribe.Invoke(this, message as UnsubscribeMessage);
}
break;
case MessageType.Join:
if (OnJoin != null)
{
OnJoin.Invoke(this, message as JoinMessage);
}
break;
case MessageType.Spectate:
if (OnSpectate != null)
{
OnSpectate.Invoke(this, message as SpectateMessage);
}
break;
case MessageType.JoinRequest:
if (OnJoinRequested != null)
{
OnJoinRequested.Invoke(this, message as JoinRequestMessage);
}
break;
case MessageType.ConnectionEstablished:
if (OnConnectionEstablished != null)
{
OnConnectionEstablished.Invoke(this, message as ConnectionEstablishedMessage);
}
break;
case MessageType.ConnectionFailed:
if (OnConnectionFailed != null)
{
OnConnectionFailed.Invoke(this, message as ConnectionFailedMessage);
}
break;
default:
//This in theory can never happen, but its a good idea as a reminder to update this part of the library if any new messages are implemented.
Logger.Error("Message was queued with no appropriate handle! {0}", message.Type);
break;
}
}
/// <summary>
/// Dequeues all the messages from Discord and invokes appropriate methods. This will process the message and update the internal state before invoking the events. Returns the messages that were invoked and in the order they were invoked.
/// </summary>
/// <returns>Returns the messages that were invoked and in the order they were invoked.</returns>
public IMessage[] Invoke()
{
//Dequeue all the messages and process them
IMessage[] messages = connection.DequeueMessages();
for (int i = 0; i < messages.Length; i++)
{
//Do a bit of pre-processing
var message = messages[i];
HandleMessage(message);
//Invoke the appropriate methods
switch (message.Type)
{
case MessageType.Ready:
if (OnReady != null)
{
OnReady.Invoke(this, message as ReadyMessage);
}
break;
case MessageType.Close:
if (OnClose != null)
{
OnClose.Invoke(this, message as CloseMessage);
}
break;
case MessageType.Error:
if (OnError != null)
{
OnError.Invoke(this, message as ErrorMessage);
}
break;
case MessageType.PresenceUpdate:
if (OnPresenceUpdate != null)
{
OnPresenceUpdate.Invoke(this, message as PresenceMessage);
}
break;
case MessageType.Subscribe:
if (OnSubscribe != null)
{
OnSubscribe.Invoke(this, message as SubscribeMessage);
}
break;
case MessageType.Unsubscribe:
if (OnUnsubscribe != null)
{
OnUnsubscribe.Invoke(this, message as UnsubscribeMessage);
}
break;
case MessageType.Join:
if (OnJoin != null)
{
OnJoin.Invoke(this, message as JoinMessage);
}
break;
case MessageType.Spectate:
if (OnSpectate != null)
{
OnSpectate.Invoke(this, message as SpectateMessage);
}
break;
case MessageType.JoinRequest:
if (OnJoinRequested != null)
{
OnJoinRequested.Invoke(this, message as JoinRequestMessage);
}
break;
case MessageType.ConnectionEstablished:
if (OnConnectionEstablished != null)
{
OnConnectionEstablished.Invoke(this, message as ConnectionEstablishedMessage);
}
break;
case MessageType.ConnectionFailed:
if (OnConnectionFailed != null)
{
OnConnectionFailed.Invoke(this, message as ConnectionFailedMessage);
}
break;
default:
//This in theory can never happen, but its a good idea as a reminder to update this part of the library if any new messages are implemented.
Logger.Error("Message was queued with no appropriate handle! {0}", message.Type);
break;
}
}
//Finally, return the messages
return(messages);
}
protected override void OnMessage(MessageEventArgs e)
{
if (!e.IsText)
{
return;
}
var msg = e.Data;
logger.Debug(new LogReceivedMessage
{
Message = msg,
Session = ID
}.ToJson());
string msgType = null;
try
{
msgType = JObject.Parse(msg)["type"]?.ToObject <string>();
switch (msgType)
{
case "Authorization":
OnAuthorization?.Invoke(this, Authorization.FromJson(msg));
return;
case "Client.Initialized":
OnClientInitialized?.Invoke(this, ClientInitialized.FromJson(msg));
return;
case "Client.Register":
OnClientRegister?.Invoke(this, ClientRegister.FromJson(msg));
return;
case "Config.Change":
if (Configurer)
{
OnConfigChange?.Invoke(this, ConfigChange.FromJson(msg));
}
return;
case "Config.Register":
Configurer = true;
Subscriber = true;
OnConfigRegister?.Invoke(this);
return;
case "Config.Start":
if (Configurer)
{
OnConfigStart?.Invoke(this);
}
return;
case "Config.Stop":
if (Configurer)
{
OnConfigStop?.Invoke(this);
}
return;
case "Execution.StartRequest":
OnExecutionRequest?.Invoke(this, ExecutionStartRequest.FromJson(msg));
return;
case "Execution.Started":
OnExecutionStarted?.Invoke(this, ExecutionStarted.FromJson(msg));
return;
case "Execution.Stopped":
OnExecutionStopped?.Invoke(this, ExecutionStopped.FromJson(msg));
return;
case "Info.Message":
OnInfo?.Invoke(this, InfoMessage.FromJson(msg));
return;
case "Info.Subscribe":
if (!Subscriber)
{
Subscriber = true;
OnSubscribe?.Invoke(this);
}
return;
case "Info.Unsubscribe":
Subscriber = false;
return;
default:
logger.Info(new LogReceivedUnknownMessageType
{
MessageType = msgType,
Session = ID
}.ToJson());
return;
}
}
catch (Exception ex)
{
//logger.Error()
logger.Error(new LogMessageHandlingError
{
Exception = ex,
MessageType = msgType,
Session = ID
}.ToJson());
}
}
internal List <string> Subscribe(MqttMessage message)
{
return(OnSubscribe?.Invoke(this, new MqttMessageEventArgs(message)));
}
