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); }