public void HandleMessage(AMessage message, VSPCContext context)
{
var textMessage = (ATextMessage)message;
bool messageShown = false;
mainWindow.DoInUIThread(() =>
{
foreach (var ccTab in mainWindow.CommChannelTabs.Where(t => !t.IsAllTab))
{
if (ccTab.MessageBelongsToMe(textMessage, context.Callsign))
{
messageShown |= (!ccTab.IsAllTab || textMessage.SenderIsServer); // Only mark message as shown if the message is shown in a tab other than "All" with server messages as exception
ccTab.ShowMessage(textMessage);
}
}
if (!messageShown && NewTabShouldBeOpened(textMessage, context))
{
CommChannelTab newCommTab = mainWindow.AddNewCommTab(textMessage.Sender);
newCommTab.ShowMessage(textMessage);
messageShown = true;
}
var allTab = mainWindow.CommChannelTabs.Single(t => t.IsAllTab);
if (messageShown || textMessage.SenderIsServer)
allTab.ShowMessage(textMessage);
});
}
public void TestMessageToString()
{
var message = new AMessage();
var myIdValue = message.MessageId.Value;
message.Should().NotBeNull();
message.ToString().Should().Be(myIdValue);
}
public void Run()
{
Stopwatch timer = Stopwatch.StartNew();
const int channelCount = 10000;
const int seedCount = 500;
var channels = new UntypedChannel[channelCount];
var connections = new ChannelConnection[channelCount];
var complete = new Future<int>();
var latch = new CountdownLatch(channelCount*seedCount, complete.Complete);
for (int i = 0; i < channelCount; i++)
{
int channelNumber = i;
channels[i] = new ChannelAdapter();
connections[i] = channels[i].Connect(x =>
{
x.AddConsumerOf<AMessage>()
.UsingConsumer(message =>
{
if (channelNumber < channels.Length - 1)
channels[channelNumber + 1].Send(message);
latch.CountDown();
});
});
}
var body = new AMessage();
for (int i = 0; i < seedCount; i++)
{
channels[i].Send(body);
for (int j = 0; j < i; j++)
latch.CountDown();
}
bool completed = complete.WaitUntilCompleted(2.Minutes());
timer.Stop();
connections.Each(x => x.Dispose());
if (!completed)
{
Console.WriteLine("Process did not complete");
return;
}
Console.WriteLine("Processed {0} messages in with {1} channels in {2}ms", seedCount, channelCount,
timer.ElapsedMilliseconds);
Console.WriteLine("That's {0} messages per second!", ((long)seedCount*channelCount*1000)/timer.ElapsedMilliseconds);
}
public void Publish(AMessage msg)
{
List<IVSPCMessageHandler> filteredHandlers;
if (messageHandlers.TryGetValue(msg.GetType(), out filteredHandlers))
{
filteredHandlers.ForEach(h => h.HandleMessage(msg, context));
}
}
public void HandleMessage(AMessage message, VSPCContext context)
{
if (InvokeRequired)
{
BeginInvoke(new InvokeDelegate(() => HandleMessage(message, context)));
}
else
{
textBoxMessages.Text += message.ToString() + Environment.NewLine;
}
}
public override void HandleMessage(AMessage message, VSPCContext context)
{
if (message is UserClickedLoginMessage)
Connect((UserClickedLoginMessage)message, context);
else if (message is UserClickedLogoffMessage)
Disconnect((UserClickedLogoffMessage)message, context);
else if (message is PositionReportMessage)
SendPositionReportToFSDServer((PositionReportMessage)message, context);
else if (message is ErrorMessage)
Logger.Error("FSD Error received: {0} {1} {2}", ((ErrorMessage)message).ErrorCode, ((ErrorMessage)message).ErrorInfo, ((ErrorMessage)message).ErrorText);
else if (message is VSPC.Core.Messages.FLSIM.FlightsimConnectedMessage)
context.FlightsimIsConnected = true;
else if (message is VSPC.Core.Messages.FLSIM.FlightsimDisconnectedMessage)
context.FlightsimIsConnected = false;
else if (message is TextMessageSend)
SendTextMessage((TextMessageSend)message);
else
Logger.Error("Unexpected message type received in FSDMessageHandler: " + message.GetType().Name);
}
public void RecieveMessages()
{
if (!Client.Connected)
throw new NotConnectedException();
try
{
while (isConnected)
{
if (Stream.DataAvailable)
{
AMessage recieveMessage = binary.Deserialize(Stream) as AMessage;
if (recieveMessage != null)
{
lastMessage = recieveMessage;
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Unexpected Error: " + e.Message);
}
}
public void Dispatch(Session session, ushort opcode, int offset, byte[] messageBytes, AMessage message)
{
// 收到actor rpc request
if (message is ActorRpcRequest actorRpcRequest)
{
Entity entity = Game.Scene.GetComponent <ActorManagerComponent>().Get(actorRpcRequest.Id);
if (entity == null)
{
Log.Warning($"not found actor: {actorRpcRequest.Id}");
ActorRpcResponse response = new ActorRpcResponse
{
RpcId = actorRpcRequest.RpcId,
Error = ErrorCode.ERR_NotFoundActor
};
session.Reply(response);
return;
}
entity.GetComponent <ActorComponent>().Add(new ActorMessageInfo()
{
Session = session, Message = actorRpcRequest
});
return;
}
// 收到actor消息分发给actor自己去处理
if (message is ActorRequest actorRequest)
{
Entity entity = Game.Scene.GetComponent <ActorManagerComponent>().Get(actorRequest.Id);
if (entity == null)
{
Log.Warning($"not found actor: {actorRequest.Id}");
ActorResponse response = new ActorResponse
{
RpcId = actorRequest.RpcId,
Error = ErrorCode.ERR_NotFoundActor
};
session.Reply(response);
return;
}
entity.GetComponent <ActorComponent>().Add(new ActorMessageInfo()
{
Session = session, Message = actorRequest
});
return;
}
if (message is AMessage || message is ARequest)
{
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(session, message);
return;
}
throw new Exception($"message type error: {message.GetType().FullName}");
}
public abstract void HandleMessage(AMessage message, VSPCContext context);
public void SendMessage(AMessage sendMessage)
{
if (sendMessage.Message != "")
{
sendMessage.ID = ClientNumber;
binary.Serialize(Stream, sendMessage);
}
}
public Task Handle(AMessage message, IMessageHandlerContext context)
{
return(Task.FromResult(0));
}
public Task <SagaWithNoCorrelation.SagaData> FindBy(AMessage message, SynchronizedStorageSession session, ReadOnlyContextBag context, CancellationToken cancellationToken = default) => null;
public MessageValidator(AMessage mess)
{
_mess = mess;
}
public Task <SagaWithNoCorrelation.SagaData> FindBy(AMessage message, SynchronizedStorageSession session, ReadOnlyContextBag context)
{
return(null);
}
/// <summary>
/// Sends the specified message to a window or windows.
/// The SendMessage function calls the window procedure for the specified window and does not return until the window
/// procedure has processed the message.
/// </summary>
/// <param name="message">The message data to send.</param>
public static IntPtr SendMessage(AMessage message)
{
return(SendMessage(message.HWnd, message.Msg, message.WParam, message.LParam));
}
public async void Dispatch(Session session, Opcode opcode, int offset, byte[] messageBytes, AMessage message)
{
// gate session收到actor消息直接转发给actor自己去处理
if (message is AActorMessage)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
actorProxy.Send(message);
return;
}
// gate session收到actor rpc消息，先向actor 发送rpc请求，再将请求结果返回客户端
if (message is AActorRequest aActorRequest)
{
long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId;
ActorProxy actorProxy = Game.Scene.GetComponent <ActorProxyComponent>().Get(unitId);
uint rpcId = aActorRequest.RpcId;
AResponse response = await actorProxy.Call <AResponse>(aActorRequest);
response.RpcId = rpcId;
session.Reply(response);
return;
}
if (message != null)
{
Game.Scene.GetComponent <MessageDispatherComponent>().Handle(session, message);
return;
}
throw new Exception($"message type error: {message.GetType().FullName}");
}
public void TestDisposeWhileHandlingMessageOnReceive()
{
DeleteQueues();
try
{
var publishedMessage = new AMessage();
using (var sendingBus = DependencyResolver.Get<ISendingBus>())
{
var receivingBus = DependencyResolver.Get<IReceivingBus>();
var subscriptionId = SubscriptionId.FromString("TestDisposeWhileHandlingMessageOnReceive");
var messageReceived = false;
receivingBus.Receive<AMessage>(subscriptionId, m =>
{
messageReceived = true;
Thread.Sleep(10000); // It will take 10 seconds, but the ReceivingBus will be disposed after just 1 second
});
sendingBus.Send(publishedMessage, subscriptionId, StorageType.NonPersistent);
Thread.Sleep(1000);
Assert.IsTrue(messageReceived, "Message should be received by the message handler!");
try
{
receivingBus.Dispose();
}
catch
{
Assert.Fail("Exception disposing ReceivingBus while handling received message!");
}
}
}
finally
{
DeleteQueues();
}
}
public void TestAutoConnectAfterReceive()
{
DeleteQueues();
try
{
var publishedMessage = new AMessage();
MessageId receivedMessageId = null;
var expectedMessageId = publishedMessage.MessageId;
using (var sendingBus = DependencyResolver.Get<ISendingBus>())
{
using (var receivingBus = DependencyResolver.Get<IReceivingBus>())
{
var subscriptionId = SubscriptionId.FromString("TestAutoConnectAfterReceive");
receivingBus.Receive<AMessage>(subscriptionId, m => receivedMessageId = ((AMessage)m).MessageId);
RestartMessageBrokerToForceConnectionToBeLost();
sendingBus.Send(publishedMessage, subscriptionId, StorageType.NonPersistent);
Thread.Sleep(1000);
receivedMessageId.Should().Be(expectedMessageId, "The sent message should be received even if the connection was closed after the receiving!");
}
}
}
finally
{
DeleteQueues();
}
}
public void TestMessageReferenceInequality()
{
var aMessage = new AMessage();
var anotherMessage = new AMessage();
Assert.False(aMessage.Equals(anotherMessage), "Message inequality failed: {0} != {1}", aMessage, anotherMessage);
}
public MessageInfo(ushort opcode, AMessage message)
{
this.Opcode = opcode;
this.Message = message;
}
private void ClientMethod(Object obj)
{
Client client = obj as Client;
if (client != null)
{
try
{
while (client.Connected)
{
AMessage recievedMessage = binary.Deserialize(client.Stream) as AMessage;
if (recievedMessage != null)
{
if (recievedMessage.Type == MessageType.LEAVE && recievedMessage.ID == client.ClientNumber)
{
client.Connected = false;
userList.Remove(client);
}
if (recievedMessage.Type == MessageType.CLIENTCOUNT)
{
messageQueue.Enqueue("Client Count Request From: " + recievedMessage.ID);
recievedMessage.Message = "" + userList.Count;
SendMessageToAll(recievedMessage);
}
else if (recievedMessage.Type == MessageType.INFOTO1)
{
string id = recievedMessage.Message.Split(';')[0];
recievedMessage.Message = recievedMessage.Message.Substring(id.Length + 1);
messageQueue.Enqueue("Client " + recievedMessage.ID + " - " + recievedMessage.Message + " - To: " + id);
SendMessageToOne(recievedMessage, Convert.ToInt32(id));
}
else if (recievedMessage.Type == MessageType.INFOEXCEPT1)
{
string id = recievedMessage.Message.Split(';')[0];
recievedMessage.Message = recievedMessage.Message.Substring(id.Length + 1);
messageQueue.Enqueue("Client " + recievedMessage.ID + " - " + recievedMessage.Message + " - Except: " + id);
SendMessageToAllButOne(recievedMessage, Convert.ToInt32(id));
}
else
{
messageQueue.Enqueue("Client " + recievedMessage.ID + " - " + recievedMessage.Message + " - To All");
SendMessageToAll(recievedMessage);
}
}
}
}
catch (Exception e)
{
messageQueue.Enqueue(e.Message + ": " + e.TargetSite);
}
finally
{
userList.Remove(client);
messageQueue.Enqueue("Client " + client.ClientNumber + " Removed");
}
}
}
