public async Task GetTheSameMessageAsSendAsync()
{
HeartbeatMessage receivedHeartbeat = default(HeartbeatMessage);
IMavlinkCommunicator mavlinkCommunicator = MavlinkCommunicatorFactory.Create(Stream);
IMessageNotifier messageNotifier = mavlinkCommunicator.SubscribeForReceive(m => m.Id == MessageId.Heartbeat);
messageNotifier.MessageReceived += (s, e) =>
{
receivedHeartbeat = (HeartbeatMessage)e.Message;
};
HeartbeatMessage sentHeartbetat = new HeartbeatMessage
{
Autopilot = MavAutopilot.Ardupilotmega,
BaseMode =
MavModeFlag.CustomModeEnabled | MavModeFlag.StabilizeEnabled | MavModeFlag.ManualInputEnabled,
MavlinkVersion = 3,
Type = MavType.Quadrotor,
SystemStatus = MavState.Active,
CustomMode = 0
};
await mavlinkCommunicator.SendMessageAsync(sentHeartbetat, 1, 1);
Stream.Seek(0, SeekOrigin.Begin);
Thread.Sleep(3000);
Assert.AreEqual(sentHeartbetat.Autopilot, receivedHeartbeat.Autopilot);
Assert.AreEqual(sentHeartbetat.Type, receivedHeartbeat.Type);
Assert.AreEqual(sentHeartbetat.CustomMode, receivedHeartbeat.CustomMode);
Assert.AreEqual(sentHeartbetat.BaseMode, receivedHeartbeat.BaseMode);
Assert.AreEqual(sentHeartbetat.SystemStatus, receivedHeartbeat.SystemStatus);
Assert.AreEqual(sentHeartbetat.MavlinkVersion, receivedHeartbeat.MavlinkVersion);
mavlinkCommunicator.Dispose();
Thread.Sleep(1000);
}
private static async Task SendHeartbeat(ModuleClient moduleClient, Int64 msgId)
{
Log.Information("{deviceId} sending heartbeat {MsgId}", deviceId, msgId);
try
{
HeartbeatMessage msg = new HeartbeatMessage
{
MsgType = "Heartbeat",
DeviceId = deviceId,
ModuleId = moduleId,
Id = (Int64)msgId,
HeartbeatCreatedTicksUtc = DateTime.UtcNow.Ticks
};
var json = Google.Protobuf.JsonFormatter.Default.Format(msg);
Message sendMsg = new Message(Encoding.UTF8.GetBytes(json));
HbStatus[msgId] = MessageStatus.Sent;
await moduleClient.SendEventAsync("sendHeartbeat", sendMsg);
}
catch (Exception e)
{
Log.Error("Error Sending Heartbeat: {Error}", e);
Console.WriteLine(e.Message);
}
}
public void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_HEARTBEAT:
double currentTimestamp = (DateTime.Now - DateTime.MinValue).TotalMilliseconds;
RequestHeartbeatMessage requestMessage = (RequestHeartbeatMessage)message;
HeartbeatMessage heartbeatMessage = new HeartbeatMessage(requestMessage);
heartbeatMessage.serverTimestamp = ((RequestHeartbeatMessage)message).createdTimestamp;
heartbeatMessage.createdTimestamp = currentTimestamp;
sendMessage(heartbeatMessage);
break;
case QTMessage.type.ROOM_INFO:
RoomInfoMessage infoMessage = (RoomInfoMessage)message;
WorkerServerManager.instance.room = infoMessage.room;
WorkerInfoMessage workerMessage = new WorkerInfoMessage();
workerMessage.id = WorkerServerManager.instance.room.id;
workerMessage.ip = "127.0.0.1";
sendMessage(workerMessage);
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Sending worker info message...");
break;
}
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="heartbeat">TradeHub Heartbeat Message</param>
/// <param name="heartbeatValidationInterval">Time interval to wait for Heartbeat before issuing disconnect event</param>
/// <param name="heartbeatResponseInterval">Timer Interval after which to send Heartbeat response</param>
public HeartBeatProcessor(HeartbeatMessage heartbeat, int heartbeatValidationInterval, int heartbeatResponseInterval)
{
_applicationId = heartbeat.ApplicationId;
_heartbeatInterval = heartbeat.HeartbeatInterval;
_heartbeatValidationInterval = heartbeatValidationInterval;
_heartbeatResponseInterval = heartbeatResponseInterval;
// Initialize Server Heartbeat response
_serverHeartbeat = new HeartbeatMessage
{
ApplicationId = _applicationId,
HeartbeatInterval = _heartbeatResponseInterval,
ReplyTo = heartbeat.ReplyTo
};
double disconnectInterval = _heartbeatInterval + _heartbeatValidationInterval;
// Initialize Timers
_validationTimer = new Timer();
_responseTimer = new Timer();
// Set Timer Intervals
_validationTimer.Interval = disconnectInterval;
_responseTimer.Interval = _heartbeatResponseInterval;
// Register Elapse Events
_validationTimer.Elapsed += OnValidationTimerElapsed;
_responseTimer.Elapsed += OnResponseTimerElapsed;
// Start Validation Timer
StartValidationTimer();
// Start Heartbeat Response Timer
StartResponseTimer();
}
/// <summary>
/// Handles the new incoming heartbeat
/// </summary>
/// <param name="heartbeat">TradeHub Heartbeat Message</param>
public void Update(HeartbeatMessage heartbeat)
{
try
{
HeartBeatProcessor processor;
if (!_heartBeatProcessors.TryGetValue(heartbeat.ApplicationId, out processor))
{
processor = new HeartBeatProcessor(heartbeat, _heartbeatValidationInterval,
_heartbeatResponseInterval);
// Register Heartbeat Processor Events
RegisterProcessorEvents(processor);
// Update Heartbeat Processors Map
_heartBeatProcessors.TryAdd(heartbeat.ApplicationId, processor);
// Add MDE-Server Heartbeat Interval
heartbeat.HeartbeatInterval = _heartbeatResponseInterval;
// Send Heartbeat Response
OnProcessorResponse(heartbeat);
}
// Update Heartbeat Processor
processor.Update();
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "Update");
}
}
public async Task SendHeartbeat(HeartbeatMessage message)
{
if (message != null)
{
await OnInputMessageReceived(message);
}
}
/// <summary>
/// Initializes a new instance of the <c>TcpDataProvider</c> class with the remote server's address and credentials to login.
/// </summary>
/// <param name="address">the host name or IP address of the remote server.</param>
/// <param name="port">the port number on the remote server.</param>
/// <param name="username">the username for login.</param>
/// <param name="password">the password for the account.</param>
/// <exception cref="System.ArgumentNullException">The input address or username or password is null.</exception>
/// <exception cref="System.ArgumentException">The input address failed to be resolved.</exception>
public TcpQuoteProvider(string address, int port, string username, string password)
{
if (address == null || username == null || password == null)
{
throw new ArgumentNullException("the input address or username or password is null.");
}
IPAddress[] ipAddresses = Dns.GetHostAddresses(address);
if (ipAddresses.Length == 0)
{
throw new ArgumentException("Unable to resolve the specified host name to an IP address.");
}
m_client = null;
IPAddress ipAddress = ipAddresses[0];
m_remoteEP = new IPEndPoint(ipAddress, port);
m_username = username;
m_password = password;
HeartbeatMessage heartbeat = new HeartbeatMessage(m_username);
m_heartbeatBytes = heartbeat.GetBytes();
m_buffer = new byte[4 * 1024];
m_readIndex = m_writeIndex = 0;
m_lastReception = m_lastHeartbeat = 0;
m_maxHeartbeatInterval = 0;
m_retryTimes = 0;
m_runByState = Create;
}
/// <summary>
/// Generates the heartbeat of the instance ready to be sent to the message bus.
/// </summary>
/// <returns>The heartbeat.</returns>
public HeartbeatMessage GenerateHeartbeat()
{
HeartbeatMessage response = new HeartbeatMessage();
response.Droplets.Add(this.GenerateInstanceHeartbeat().ToJsonIntermediateObject());
return(response);
}
public void HandleMessage(byte[] message, Socket socket, NetworkStream stream)
{
IMessage decodedMessage;
switch ((MessageIds)message[0])
{
case MessageIds.Heartbeat:
decodedMessage = new HeartbeatMessage();
decodedMessage.Unpack(message);
TakeAction((HeartbeatMessage)decodedMessage, socket);
break;
case MessageIds.JoinChatroom:
decodedMessage = new JoinChatroomMessage();
decodedMessage.Unpack(message);
TakeAction((JoinChatroomMessage)decodedMessage, socket, stream);
break;
case MessageIds.SendChat:
decodedMessage = new SendChatMessage();
decodedMessage.Unpack(message);
TakeAction((SendChatMessage)decodedMessage);
break;
default:
break;
}
}
private async void _timer_Elapsed(object sender, ElapsedEventArgs e)
{
var message = new HeartbeatMessage {
elapsed = true
};
await Task.Run(() => { InputMessageReceived?.Invoke(this, message); });
}
private void OnHeartbeatMessage(GameClient client, HeartbeatMessage message)
{
if (this.GameClient != null)
{
this.GameClient.SendMessage(new HeartbeatMessage(), true);
}
//response
}
//public static Person ToModel(this PersonDataMessageQueue source)
//{
// return new Person
// {
// Id = source.Id,
// CertificateNumber = source.CertificateNumber,
// CertificateType = source.CertificateType,
// Email = source.Email,
// Gender = source.Gender,
// GroupId = source.GroupId,
// Name = source.Name,
// PersonId = source.PersonId,
// Phone = source.Phone,
// Userid = source.Userid,
// UpdateTime = source.UpdateTime
// };
//}
//public static Device ToModel(this DeviceDataMessageQueue source)
//{
// return new Device
// {
// Id = source.Id,
// DeviceId = source.DeviceId,
// IPAddress = source.IPAddress,
// IsActive = source.IsActive
// };
//}
//public static PersonImg ToModel(this PersonImgDataMessageQueue source)
//{
// return new PersonImg
// {
// Id = source.Id,
// PersonId = source.PersonId,
// ImgBase64 = source.ImgBase64
// };
//}
#endregion
public static HeartBeatDataStore ToModel(this HeartbeatMessage source)
{
return(new HeartBeatDataStore
{
Status = source.Status,
DeviceId = source.DeviceId,
Timestamp = source.Timestamp
});
}
private async Task OnInputMessageReceived(HeartbeatMessage message)
{
_timer.Stop();
_LastHeartbeat = DateTime.Now;
await Task.Run(() => { InputMessageReceived?.Invoke(this, message); });
_timer.Start();
}
private void TakeAction(HeartbeatMessage message, Socket socket)
{
lock (_userTracker.TrackerLock)
{
if (_userTracker.Users.ContainsKey(socket))
{
_userTracker.Users[socket].MissedHeartbeats = 0;
}
}
}
public HeartBeatDataStore GetHeartBeateRecordByDeviceId(HeartbeatMessage source)
{
if (source != null && source.DeviceId != null)
{
var result = this._thermoDataContext.HeartBeat.Where(x => x.DeviceId.Trim().ToLower() == source.DeviceId.Trim().ToLower()).FirstOrDefault();
return(result);
}
return(null);
}
internal static void SendHeartbeatMessage(object sender, EventArgs eventArgs)
{
HeartbeatMessage heartbeatMessage = new HeartbeatMessage();
heartbeatMessage.CoreAuthKey = Settings.Instance.CoreAuthKey;
heartbeatMessage.PlayerName = Core.Player.Name;
heartbeatMessage.TimeStamp = DateTime.UtcNow.ToString("yyyy'/'MM'/'dd HH':'mm':'ss");
QueueMessage(JsonConvert.SerializeObject(heartbeatMessage));
}
public IEnumerable <HeartbeatMessage> Get()
{
HeartbeatMessage heartbeatMessage = new HeartbeatMessage();
heartbeatMessage.RequestDateTime = DateTime.Now;
heartbeatMessage.ApplicationName = "Birdwatcher Web";
heartbeatMessage.AppVersion = Assembly.GetEntryAssembly().GetName().Version.ToString();
heartbeatMessage.WelcomeMessage = "If you can see this you are successfuly connected to the Bird Watcher API!";
yield return(heartbeatMessage);
}
public override Task <HeartbeatReceivedResponse> ReceiveHeartbeat(
HeartbeatMessage request,
ServerCallContext context)
{
SetHeartbeatCache(request);
return(Task.FromResult(
new HeartbeatReceivedResponse
{
Success = true
}));
}
public Task <HeartbeatMessage> GetEventData(string messageType, string deviceId, string moduleId, Int64 msgId)
{
HeartbeatMessage obj = new HeartbeatMessage
{
MsgType = messageType,
DeviceId = deviceId,
ModuleId = moduleId,
Id = msgId,
HeartbeatCreatedTicksUtc = DateTime.UtcNow.Ticks
};
return(Task.FromResult(obj));
}
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");
}
}
/// <summary>
/// Generates the heartbeat message.
/// </summary>
/// <returns>Return the heartbeat message</returns>
public HeartbeatMessage GenerateHeartbeatMessage()
{
HeartbeatMessage response = new HeartbeatMessage();
ForEach(delegate(DropletInstance instance)
{
if (instance.Properties.State != DropletInstanceState.Stopped)
{
response.Droplets.Add(instance.GenerateInstanceHeartbeat().ToJsonIntermediateObject());
}
});
return(response);
}
public void SendOutHeartbeat(Communicator comm)
{
Log.DebugFormat("Sending heartbeat to game {0} at {1}", Id, PlayerEndPoint);
HeartbeatMessage msg = new HeartbeatMessage(Id);
if (comm.Send(msg, PlayerEndPoint))
{
_lookingForAck = true;
}
else
{
_lastAckTime = DateTime.MinValue;
}
}
private void Heartbeat(object state)
{
lock (_heartbeatTimerLock)
{
if (_heartbeatTimer == null)
{
return;
}
}
var heartbeatMessage = new HeartbeatMessage(_clientHostAddress);
_outputChannel.SendOneWay(heartbeatMessage);
}
public override Task <HeartbeatReceivedResponse> ReceiveHeartbeat(
HeartbeatMessage request,
ServerCallContext context)
{
_logger.LogInformation($"Heartbeat received from {request.HostName} at {request.HostTimeStamp}");
SetHeartbeatCache(request);
return(Task.FromResult(
new HeartbeatReceivedResponse
{
Success = true
}));
}
public Task <int> SaveHeartBeatRecordAsync(HeartbeatMessage source)
{
var instance = GetHeartBeateRecordByDeviceId(source);
if (instance != null)
{
instance.Timestamp = source.Timestamp;
}
else
{
this._thermoDataContext.HeartBeat.Update(source.ToModel());
}
return(this._thermoDataContext.SaveChangesAsync());
}
public void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_HEARTBEAT:
double currentTimestamp = (DateTime.Now - DateTime.MinValue).TotalMilliseconds;
RequestHeartbeatMessage requestMessage = (RequestHeartbeatMessage)message;
HeartbeatMessage heartbeatMessage = new HeartbeatMessage(requestMessage);
heartbeatMessage.serverTimestamp = ((RequestHeartbeatMessage)message).createdTimestamp;
heartbeatMessage.createdTimestamp = currentTimestamp;
sendMessage(heartbeatMessage);
break;
}
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="applicationId">Unique Application ID</param>
/// <param name="asyncClassLogger">Class level logger for order client</param>
/// <param name="heartbeatInterval">Duration between successive Heartbeats in milliseconds</param>
public ClientHeartBeatHandler(string applicationId, AsyncClassLogger asyncClassLogger, int heartbeatInterval = 60000)
{
_asyncClassLogger = asyncClassLogger;
_heartbeatInterval = heartbeatInterval;
// Initialize
_heartbeatTimer = new Timer();
_serverResponseTimer = new Timer();
_heartbeatMessage = new HeartbeatMessage();
_heartbeatMessage.ApplicationId = applicationId;
_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
_serverResponseTimer.Elapsed += OnServerResponseTimerElapsed;
}
public async Task <int> Heartbeat()
{
//Set Timer
heartbeatTimer = heartbeatTimer ?? new Timer(async state =>
{
await Heartbeat().ConfigureAwait(false);
}, null, 10000, 5000);
var heartbeatMessage = new HeartbeatMessage();
var response = await Request(heartbeatMessage).ConfigureAwait(false);
var result =
JsonConvert.DeserializeObject <Dictionary <string, string> >(response, new JsonSerializerSettings());
return(Convert.ToInt32(result["tick"]));
}
public static Task <HeartbeatMessage> ParseIoTHubMessage(this EventData message, ILogger log)
{
var rawMsg = Encoding.UTF8.GetString(message.Body.Array);
HeartbeatMessage msg = new HeartbeatMessage();
try
{
msg = JsonParser.Default.Parse <HeartbeatMessage>(rawMsg);
}
catch (Exception e)
{
log.LogError(e, "Message is not in the format expected by the JSON parser.\n" + rawMsg);
throw;
}
return(Task.FromResult(msg));
}
public Task SendHeartBeatMessagesToAzureServiceBus(TargetDevice targetDevice)
{
var heartbeatMessage = new HeartbeatMessage
{
MessageType = CoreMessageType.HeartBeatMessage,
Status = OnlineMessage,
DeviceId = targetDevice.HostName,
Timestamp = DateTime.UtcNow
};
var messgeInstance = MessageConverter.Serialize(heartbeatMessage);
_messageSender.SendMessagesAsync(messgeInstance);
this._logger.LogInformation($"Sending HeartBeat message {DateTime.Now}");
return(Task.CompletedTask);
}
/// <summary>
/// The main processing state: the client is successfully logged on
/// and we process its requests until Logout.
/// </summary>
public void LoggedOn()
{
// Messages from client
Receive<HeartbeatMessage>(message =>
{
_lastHeartbeatArrivalTime = DateTime.UtcNow; //TODO: The server could timestamp messages as they arrive to avoid checking the time here?
_inboundSequenceNumber = message.MessageSequenceNumber;
});
Receive<LogoutMessage>(message =>
{
_log.Debug("Received Logout message from client.");
_inboundSequenceNumber = message.MessageSequenceNumber;
_fixInterpreterActor.Tell(new LogoutMessage(_serverCompID, _clientCompID, _outboundSequenceNumber++));
BecomeShutDown();
});
Receive<QuoteRequestMessage>(message =>
{
if (_instrumentOfferRates != null &&
_instrumentOfferRates.ContainsKey(message.Symbol))
{
_log.Debug("Responding to RFQ for " + message.Symbol);
string quoteID = "Quote" + _outboundSequenceNumber;
var quote = new QuoteMessage(_serverCompID, _clientCompID,
_outboundSequenceNumber++, message.QuoteReqID, quoteID,
message.Symbol, _instrumentOfferRates[message.Symbol]);
_fixInterpreterActor.Tell(quote);
}
else
{
_log.Error("Unable to quote client for requested instrument: " +
message.Symbol);
//TODO: Implement unable to quote message
}
});
// Exogenous system messages
Receive<Shutdown>(message =>
{
_log.Debug("Shutting down.");
_fixInterpreterActor.Tell(new LogoutMessage(_serverCompID, _clientCompID, _outboundSequenceNumber++));
BecomeWaitingForClientLogout();
});
// Internal messages
Receive<SendHeartbeat>(message =>
{
_log.Debug("Sending heartbeat message.");
var heartbeatMessage = new HeartbeatMessage(_serverCompID, _clientCompID,
_outboundSequenceNumber++);
_fixInterpreterActor.Tell(heartbeatMessage);
});
Receive<PerformAdmin>(message =>
{
// Check a heartbeat was received in the last 2 * heartbeat interval,
// otherwise assume connection is lost and shut down.
// This is the only method employed to check the connection.
if (DateTime.UtcNow - _lastHeartbeatArrivalTime > _heartbeatInterval + _heartbeatInterval)
{
_log.Debug("Heartbeat message has not been received from client.");
_log.Debug("Sending TestRequest to client.");
var testRequest = new TestRequestMessage(_serverCompID, _clientCompID,
_outboundSequenceNumber++, "1");
_fixInterpreterActor.Tell(testRequest);
// We expect to receive a heartbeat with matching TestReqID
BecomeWaitingForTestRequestResponse();
}
});
}
public void ConvertFixObjectToFixMessage_ReturnsCorrectString_ForHeartbeatMessage()
{
var messageObject = new HeartbeatMessage("Client", "Bank", 1);
string result = new FixParser().ConvertFixObjectToFixMessage(messageObject);
string expected = "8=FIXT1.1\u00019=28\u000135=0\u000149=Client\u000156=Bank\u000134=1\u000110=253\u0001";
result.Should().Be(expected);
}
public HeartbeatMessageReceivedEventArgs(HeartbeatMessage heartbeatMessage)
{
HeartbeatMessage = heartbeatMessage;
}
