private Message ProcessExitMessage(ExitMessage exitMessage)
{
Message reply;
if (exitMessage.IsValid)
{
var game = Game.FindGame(exitMessage.GameId);
if (game == null)
{
Log.InfoFormat("Invalid Game Id {0} from {1}", exitMessage.GameId, exitMessage.SenderEndPoint);
reply = new ErrorMessage(exitMessage.GameId, $"Invalid game id = {exitMessage.GameId}");
}
else
{
game.Exit();
reply = new AckMessage(game.Id);
game.Student.IncExitCount();
game.LastMessageTime = DateTime.Now;
}
}
else
{
Log.InfoFormat("Invalid exitHit message from {0}", exitMessage.SenderEndPoint);
reply = new ErrorMessage(exitMessage.GameId, @"Invalid exitHint message");
}
return(reply);
}
private void HandleSubscribeEventMessage(SubscribeEventMessage subscribeEventMessage, IInputContext context)
{
if (!_objectsRepository.TryGetObject(subscribeEventMessage.ObjectId, out var objectAdapter) || objectAdapter == null)
{
WriteObjectNotFoundError(context, subscribeEventMessage.ObjectId);
return;
}
if (!objectAdapter.Events.TryGetValue(subscribeEventMessage.EventName, out var ev))
{
WriteEventNotFoundError(context, subscribeEventMessage.ObjectId, subscribeEventMessage.EventName);
return;
}
var subscription = new Subscription(subscribeEventMessage.ObjectId, subscribeEventMessage.EventName,
subscribeEventMessage.ClientHostAddress, _outputChannel, ev);
lock (_subscriptions)
{
if (_subscriptions.ContainsKey(ev))
{
WriteEventAlreadySubscribedError(context, subscribeEventMessage.ObjectId, subscribeEventMessage.EventName);
return;
}
_subscriptions.Add(ev, subscription);
}
var ackMessage = new AckMessage(subscribeEventMessage.ClientHostAddress);
context.Write(ackMessage.ToFrame());
}
public void HandleAckMessage(AckMessage ackMessage)
{
OutboundMessage outboundMessage = null;
if (outboundMessagesBySequence.TryGetValue(ackMessage.AckedSequenceNumber, out outboundMessage))
{
outboundMessages.Remove(outboundMessage);
outboundMessagesBySequence.Remove(ackMessage.AckedSequenceNumber);
outboundMessagePool.Push(outboundMessage);
}
if (isResetPending && outboundMessages.FirstOrDefault(x => x.NeedsAck) == null)
{
if (IsVerbose)
{
NeutrinoConfig.Log(node.Name + " drained all outbound - resetting sequence and sending queued");
}
isResetPending = false;
nextSequence = 0;
foreach (byte[] buffer in pendingResetOutboundMessages)
{
Enqueue(msgFactory.Read(buffer));
}
pendingResetOutboundMessages.Clear();
}
}
/// <summary>
/// Procesa un mensaje que no ha podido ser envíado correctamente
/// </summary>
/// <param name="message">El mensaje</param>
internal void routerMessageErrorHandler(Message message)
{
//ImAliveMessage
if (message.Type == MessageType.IMALIVE)
{
ImAliveMessage imAliveMessage = (ImAliveMessage)message;
produceEvent(CommunicationEvent.NETINFORMATION, "ROUTER: message delivery fail " + imAliveMessage.ToString());
}
//AckMessage
else if (message.Type == MessageType.ACK)
{
AckMessage ackMessage = (AckMessage)message;
produceEvent(CommunicationEvent.NETINFORMATION, "ROUTER: message delivery fail " + ackMessage.ToString());
}
//Resto de los mensajes
else
{
SubProtocolI subProtocol = (SubProtocolI)subProtocols[message.ProtocolType];
if (subProtocol != null)
{
eventQueuePC.put(new Event(new MessageEvent(subProtocol.errorMessage), message));
}
else
{
produceEvent(CommunicationEvent.ERRORMESSAGE, message);
}
produceEvent(CommunicationEvent.NETINFORMATION, "ROUTER: message delivery fail " + message.ToString());
}
}
public void CreateAckForMessage()
{
DeathRecordSubmission submission = BaseMessage.Parse <DeathRecordSubmission>(FixtureStream("fixtures/json/DeathRecordSubmission.json"));
AckMessage ack = new AckMessage(submission);
Assert.Equal("http://nchs.cdc.gov/vrdr_acknowledgement", ack.MessageType);
Assert.Equal(submission.MessageId, ack.AckedMessageId);
Assert.Equal(submission.MessageSource, ack.MessageDestination);
Assert.Equal(submission.MessageDestination, ack.MessageSource);
Assert.Equal(submission.StateAuxiliaryIdentifier, ack.StateAuxiliaryIdentifier);
Assert.Equal(submission.CertificateNumber, ack.CertificateNumber);
Assert.Equal(submission.NCHSIdentifier, ack.NCHSIdentifier);
submission = null;
ack = new AckMessage(submission);
Assert.Equal("http://nchs.cdc.gov/vrdr_acknowledgement", ack.MessageType);
Assert.Null(ack.AckedMessageId);
Assert.Null(ack.MessageDestination);
Assert.Null(ack.MessageSource);
Assert.Null(ack.CertificateNumber);
Assert.Null(ack.StateAuxiliaryIdentifier);
Assert.Null(ack.NCHSIdentifier);
submission = new DeathRecordSubmission();
ack = new AckMessage(submission);
Assert.Equal("http://nchs.cdc.gov/vrdr_acknowledgement", ack.MessageType);
Assert.Equal(submission.MessageId, ack.AckedMessageId);
Assert.Equal(submission.MessageSource, ack.MessageDestination);
Assert.Equal(submission.MessageDestination, ack.MessageSource);
Assert.Equal(submission.StateAuxiliaryIdentifier, ack.StateAuxiliaryIdentifier);
Assert.Equal(submission.CertificateNumber, ack.CertificateNumber);
Assert.Equal(submission.NCHSIdentifier, ack.NCHSIdentifier);
}
public void DefaultConstructorTest()
{
var newAck = new AckMessage();
Assert.IsNull(newAck.ReferenceMessageID);
Assert.IsNull(newAck.AckHello);
}
public override void Execute()
{
Envelope envelope = null;
if (args.Length > 1)
{
try
{
short pid = Convert.ToInt16(args[0]);
short seq = Convert.ToInt16(args[1]);
MessageId msgId = new MessageId()
{
Pid = pid, Seq = seq
};
Message m = new AckMessage(msgId, -1);
envelope = new Envelope(m, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
myAppWorker.commFacility.Process(envelope);
// TODO: Change AppState
myAppWorker.SetState(((GameManagerAppWorker)myAppWorker).TempState);
}
public bool RegisterNode(ServerAddress selfAddress)
{
var channel = OpenConnection();
var client = new PublisherServer.PublisherServerClient(channel);
AckMessage response = new AckMessage();
try
{
CLI.DisplayLine("Attempting connection");
response = client.RegisterNode(new ServerAddressMessage
{
Ip = selfAddress.Ip
,
Port = selfAddress.Port
});
} catch (RpcException)
{
CLI.DisplayLine("Connection failed");
return(false);
}
channel.ShutdownAsync().Wait();
return(response.Status == AckMessage.Types.Status.Ok);
}
private void HandleUnsubscribeEventMessage(UnsubscribeEventMessage unsubscribeEventMessage,
IInputContext context)
{
if (!_objectsRepository.TryGetObject(unsubscribeEventMessage.ObjectId, out var objectAdapter) || objectAdapter == null)
{
WriteObjectNotFoundError(context, unsubscribeEventMessage.ObjectId);
return;
}
if (!objectAdapter.Events.TryGetValue(unsubscribeEventMessage.EventName, out var ev))
{
WriteEventNotFoundError(context, unsubscribeEventMessage.ObjectId, unsubscribeEventMessage.EventName);
return;
}
ISubscription subscription;
lock (_subscriptions)
{
if (!_subscriptions.TryGetValue(ev, out subscription))
{
//No exception or error is needed (same as for standard c# events when unsubscribed from a delegate that was not subscribed before).
return;
}
_subscriptions.Remove(ev);
}
subscription.Dispose();
var ackMessage = new AckMessage(unsubscribeEventMessage.ClientHostAddress);
context.Write(ackMessage.ToFrame());
}
public void UserApp_StartGameConversation_Test()
{
//--------------SET UP VARIABLES-------------------//
RegistryData registryData = new RegistryData();
RegistryData.GameInfo gameInfo = new RegistryData.GameInfo();
TestAppWorker testAppWorker = new TestAppWorker(registryData);
testAppWorker.StartTest();
var gameManager = new UdpCommunicator()
{
MinPort = 10000,
MaxPort = 10999,
Timeout = 1000,
EnvelopeHandler = ProcessEnvelope1
};
gameManager.Start();
IPEndPoint registryEp = new IPEndPoint(IPAddress.Loopback, testAppWorker.commFacility.udpCommunicator.Port);
IPEndPoint gameManagerEp = new IPEndPoint(IPAddress.Loopback, gameManager.Port);
gameInfo.RemoteEndPoint = gameManagerEp;
gameInfo.GameActive = false;
Assert.IsTrue(registryData.AddGame(gameInfo));
StartGameMessage msg1 = new StartGameMessage(1);
Envelope env1 = new Envelope(msg1, registryEp);
//--------------TEST INITIAL SET UP AND SEND INITIAL MESSAGE-------------------//
Assert.IsNull(testAppWorker.commFacility.convDictionary.GetConv(msg1.convId));
Assert.IsFalse(gameInfo.GameActive);
gameManager.Send(env1);
Thread.Sleep(1000);
//--------------TEST OUTCOME-------------------//
Assert.AreNotSame(msg1, _lastIncomingEnvelope1);
// Make sure received message isn't null
Assert.IsNotNull(_lastIncomingEnvelope1);
Assert.IsNotNull(_lastIncomingEnvelope1.message);
// Make sure received message is AckMessage
Assert.AreEqual(msg1.convId, _lastIncomingEnvelope1.message.convId);
AckMessage msg2 = _lastIncomingEnvelope1.message as AckMessage;
Assert.IsNotNull(msg2);
Assert.IsTrue(gameInfo.GameActive);
Assert.IsNull(testAppWorker.commFacility.convDictionary.GetConv(msg1.convId));
//--------------CLOSE EVERYTHING-------------------//
testAppWorker.StopTest();
gameManager.Stop();
}
internal void HandleMessageReceived(byte[] buffer, int numBytesReceived)
{
previousActivityTimeTicks = Environment.TickCount;
foreach (var msg in msgFactory.Read(buffer, numBytesReceived))
{
msg.Source = this;
AckMessage ackMsg = msg as AckMessage;
if (ackMsg != null)
{
outboundQueue.HandleAckMessage(ackMsg);
}
else
{
bool shouldHandle = true;
int sequenceNumber = 0;
if (msg.IsGuaranteed)
{
sequenceNumber = msg.SequenceNumber;
if (idempotentSequenceNumbers[sequenceNumber] == 1)
{
shouldHandle = false;
}
else
{
idempotentSequenceNumbers[sequenceNumber] = 1;
if (sequenceNumber > 0 && (
idempotentSequenceNumbers[sequenceNumber - 1] == 0 ||
pendingOutOfSequenceMessages.ContainsKey(sequenceNumber - 1)))
{
pendingOutOfSequenceMessages[sequenceNumber] = msg.Clone();
shouldHandle = false;
}
}
}
if (shouldHandle)
{
ProcessMessage(msg);
for (int i = sequenceNumber + 1; i < NeutrinoConfig.MaxPendingGuaranteedMessages; i++)
{
NetworkMessage pendingMessage = null;
if (pendingOutOfSequenceMessages.TryGetValue(i, out pendingMessage))
{
pendingOutOfSequenceMessages.Remove(i);
ProcessMessage(pendingMessage);
}
else
{
break;
}
}
}
if (msg.IsGuaranteed)
{
ackMessage.AckedSequenceNumber = (ushort)sequenceNumber;
SendNetworkMessage(ackMessage);
}
}
}
}
public void InheritsMessageTest()
{
var newAck = new AckMessage();
Assert.AreEqual(0, newAck.SourceID);
Assert.IsNull(newAck.ConversationID);
Assert.IsNull(newAck.MessageID);
}
public override void Execute()
{
AckMessage Continue = new AckMessage(myConversation.FirstEnvelope.message.convId, ((GameManagerAppWorker)myConversation.commFacility.myAppWorker).GameInfo.GameId);
Ack = new Envelope(Continue, myConversation.FirstEnvelope.remoteEndPoint);
SendMessage(Ack);
myConversation.Stop();
}
/// <summary>
/// Procesa un mensaje de confirmación que se ha recibido
/// </summary>
/// <param name="ackMessage">el mensaje de confirmación</param>
public void proccessAckMessage(AckMessage ackMessage)
{
if (notConfirmedMessageList.remove(ackMessage.MessageId))
{
//statics
nMessagesConfirmed++;
}
}
public void Handle(AckMessage message)
{
// Extend a timout while the sender of the Ack is processing the original request.
_logger?.Invoke($"AckMessage received Id:{message.CorrelationId}");
var dueTime = _expiryCalculator.CalcExpiry(_config.AckTimeout);
_acks[message.CorrelationId] = dueTime;
}
public static AckMessage GetAckMessage(string messageID, AckType ackType, string error = "")
{
AckMessage message = new AckMessage();
message.Segments.Add(GetMSHSegment(string.Empty, "ACK"));
message.Segments.Add(GetMSASegment(messageID, error, ackType));
return(message);
}
public override BaseMessage ToMessage()
{
var msg = new AckMessage(Id);
msg.RecipientId = RecipientId;
msg.Response = Response;
return(msg);
}
internal void Init(Node node, Socket socket, IPAddress address, int port, string nickname)
{
this.node = node;
msgFactory = node.MessageFactory;
Nickname = nickname;
this.endpoint = new IPEndPoint(address, port);
outboundQueue = new OutboundQueue(node, this.endpoint, socket);
ackMessage = msgFactory.Get <AckMessage>();
previousActivityTimeTicks = Environment.TickCount;
}
private async Task ProcessMessage(int internalMessageID, Message message)
{
Log.CoreLogger.Debug("Generating ACK for message received on port " + _port);
AckMessage ackMessage = MessageGenerator.GetAckMessage(message.MessageID, AckType.AA);
await SendAck(internalMessageID, ackMessage).ConfigureAwait(false);
Log.CoreLogger.Debug("ACK sent for message received on port " + _port);
// send message upstream
}
protected override void OnMessageReceived(NetPeer peer, NetworkMessage message)
{
if (peer != client)
{
return;
}
if (message is SynMessage syn)
{
if (syn.GameName == "Pong" && syn.MajorVersion == 1 && syn.MinorVersion == 0)
{
multiplayer.SetRemoteName(syn.PlayerName);
SynAckMessage synAck = new SynAckMessage();
synAck.PlayerName = Manager.GameManager.UI.PlayerName;
Send(synAck, SendOptions.ReliableOrdered);
ConnectionStatus = ConnectionStatus.Connecting;
connectDeadline = Time.time + 5;
}
}
else if (message is AckMessage)
{
if (ConnectionStatus == ConnectionStatus.Connecting)
{
ConnectionStatus = ConnectionStatus.Connected;
multiplayer.StartGame();
}
else if (ConnectionStatus == ConnectionStatus.Disconnecting)
{
ConnectionStatus = ConnectionStatus.Unconnected;
FinishDisconnect();
}
}
else if (message is FinMessage fin)
{
FinAckMessage finAck = new FinAckMessage();
Send(finAck, SendOptions.ReliableOrdered);
disconnectDeadline = Time.time + 5;
ConnectionStatus = ConnectionStatus.Disconnecting;
}
else if (message is FinAckMessage finAck)
{
AckMessage ack = new AckMessage();
Send(ack, SendOptions.ReliableOrdered);
if (ConnectionStatus == ConnectionStatus.Disconnecting)
{
ConnectionStatus = ConnectionStatus.Unconnected;
FinishDisconnect();
}
}
else if (message is PaddleUpdateMessage update)
{
(Manager.GameManager.CurrentGame as Multiplayer).HandlePaddleUpdate(update);
}
}
private void RpcNotifyAckMessage_S2C(uLink.BitStream stream)
{
AckMessage ackMessage = new AckMessage();
ackMessage.ReadFrom(stream);
if (ackMessage.ACKUCMD.UCMDID > m_LastReceviedAckMessage.ACKUCMD.UCMDID)
{
m_LastReceviedAckMessage = ackMessage;
m_NeedRollbackToLastReceviedAckMessage = true;
}
}
/// <summary>
/// Default message handler for the received Hl7 message - just send an ACK.
/// </summary>
/// <param name="hl7RequestMessage">Received HL7 message.</param>
/// <returns>Hl7Message response.</returns>
public virtual Hl7Message MessageHandler(Hl7Message hl7RequestMessage)
{
// Set up an ACK message to return
AckMessage hl7ResponseMessage = new AckMessage(hl7RequestMessage.MessageSubType);
// fill in the MSA segment
hl7ResponseMessage.MSA[1] = "AA";
hl7ResponseMessage.MSA[2] = hl7RequestMessage.MessageControlId;
return(hl7ResponseMessage);
}
private void HandleConnect(ConnectMessage connectMessage, IInputContext context)
{
if (!_objectsRepository.TryGetObject(connectMessage.ObjectId, out _))
{
WriteObjectNotFoundError(context, connectMessage.ObjectId);
return;
}
var ackMessage = new AckMessage(connectMessage.ClientHostAddress);
context.Write(ackMessage.ToFrame());
}
public void CreateAckFromXML()
{
AckMessage ack = BaseMessage.Parse <AckMessage>(FixtureStream("fixtures/xml/AckMessage.xml"));
Assert.Equal("http://nchs.cdc.gov/vrdr_acknowledgement", ack.MessageType);
Assert.Equal("a9d66d2e-2480-4e8d-bab3-4e4c761da1b7", ack.AckedMessageId);
Assert.Equal("nightingale", ack.MessageDestination);
Assert.Equal("2018MA000001", ack.NCHSIdentifier);
Assert.Equal((uint)1, ack.CertificateNumber);
Assert.Equal((uint)2018, ack.DeathYear);
Assert.Equal("42", ack.StateAuxiliaryIdentifier);
}
private void ProcessAckMessage(AckMessage msg, uint connNodeId)
{
if (!LastTickAcknowledged.ContainsKey(connNodeId) ||
LastTickAcknowledged[connNodeId] < msg.AcknowledgedTick)
{
LastTickAcknowledged[connNodeId] = msg.AcknowledgedTick;
}
else
{
// If AcknowledgedTick is decreasing, something is wrong
Logger.Debug("SyncNode", $"Acknowledged Tick from NodeId={connNodeId} is decreasing. It's strange!");
}
}
public void TestAckMessage()
{
AckMessage origMessage = new AckMessage(MessageId.Create(), 1);
byte[] bytes = origMessage.Encode();
AckMessage decodedMessage = AckMessage.Decode(bytes);
Assert.AreEqual(origMessage.MessageType, 11, "Incorrect MessageType");
Assert.AreEqual(origMessage.msgId, decodedMessage.msgId, "msgId did not match");
Assert.AreEqual(origMessage.convId, decodedMessage.convId, "convId did not match");
Assert.AreEqual(origMessage.MessageType, decodedMessage.MessageType, "MessageType did not match");
Assert.AreEqual(origMessage.GameId, decodedMessage.GameId, "GameId did not match");
}
public static Message Create(IFrame frame, string side = "")
{
var messageType = (MessageType)frame.TakeByte();
var clientHostAddress = HostAddress.Read(frame);
switch (messageType)
{
case MessageType.Hello:
return(HelloMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Ack:
return(AckMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Connect:
return(ConnectMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Heartbeat:
return(HeartbeatMessage.ReadInternal(clientHostAddress));
case MessageType.TerminateSession:
return(TerminateMessage.ReadInternal(clientHostAddress));
case MessageType.ErrorMessage:
return(ErrorMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Exception:
return(ExceptionMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Event:
return(EventMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Request:
return(RequestMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Response:
return(ResponseMessage.ReadInternal(clientHostAddress, frame));
case MessageType.SubscribeEvent:
return(SubscribeEventMessage.ReadInternal(clientHostAddress, frame));
case MessageType.UnsubscribeEvent:
return(UnsubscribeEventMessage.ReadInternal(clientHostAddress, frame));
case MessageType.Notification:
return(NotificationMessage.ReadInternal(clientHostAddress, frame));
default:
throw new IOException(
$"Unknown Message type {messageType} is received");
}
}
public void InitializeTest()
{
string referenceID = "1-2-3";
string hello = "hello";
var m = new AckMessage
{
ReferenceMessageID = referenceID,
AckHello = hello
};
Assert.AreEqual(referenceID, m.ReferenceMessageID);
Assert.AreEqual(hello, m.AckHello);
}
private void Socket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
tcs.SetResult(true);
Log.CoreLogger.Debug("Client received message on port " + _port);
AckMessage message = new AckMessage();
message[ControlCharacters.Default] = e.Message.ToString();
AckMessageReceived?.Invoke(this, new MessageReceivedEventArgs()
{
Message = message
});
}
private void TestEncodeDecode()
{
AckMessage before = new AckMessage();
before.EphemeralPublicKey = _privateKey.PublicKey;
before.Nonce = new byte[AckMessageSerializer.NonceLength];
_random.NextBytes(before.Nonce);
before.IsTokenUsed = true;
byte[] data = _serializer.Serialize(before);
AckMessage after = _serializer.Deserialize(data);
Assert.AreEqual(before.EphemeralPublicKey, after.EphemeralPublicKey);
Assert.True(Bytes.UnsafeCompare(before.Nonce, after.Nonce));
Assert.AreEqual(before.IsTokenUsed, after.IsTokenUsed);
}
