public async Task <DeviceVersion> When(HeartbeatReceived command)
{
var heartbeat = command.Heartbeat;
// Create domain model for the device associated with the current context and
// record the received heartbeat information.
var deviceStatus = DeviceStatus.ForExistingDevice(command.DeviceId,
status => status.RecordHeartbeat(
heartbeat.State,
heartbeat.UptimeSeconds,
heartbeat.AgentVersion,
heartbeat.ApplicationVersion,
heartbeat.RootFileSystemVersion));
DeviceVersion deviceVersion = null;
using (_repoContext)
{
// Update the device status and return it's current configuration version.
await _deviceRepo.UpdateDeviceStatus(deviceStatus);
deviceVersion = await _deviceRepo.GetDeviceVersionInfo(deviceStatus.DeviceId);
}
_logger.LogTrace(
"Heartbeat received for device {DeviceId}. Device has been up for {UptimeSeconds} " +
"seconds and is using ConfigurationVersion {ConfigurationVersion} sent.",
deviceStatus.DeviceId, deviceStatus.UptimeSeconds, deviceVersion.ConfigurationVersion);
return(deviceVersion);
}
public Shard(GatewaySettings settings, ShardInfo info, IGatewayRatelimiter ratelimiter, string url, ILogger logger)
{
_jsonSerializerOptions = new JsonSerializerOptions().ConfigureForMyriad();
_settings = settings;
_info = info;
_ratelimiter = ratelimiter;
_url = url;
_logger = logger.ForContext <Shard>().ForContext("ShardId", info.ShardId);
_stateManager = new ShardStateManager(info, _jsonSerializerOptions, logger)
{
HandleEvent = HandleEvent,
SendHeartbeat = SendHeartbeat,
SendIdentify = SendIdentify,
SendResume = SendResume,
Connect = ConnectInner,
Reconnect = Reconnect,
};
_stateManager.OnHeartbeatReceived += latency =>
{
HeartbeatReceived?.Invoke(latency);
};
_conn = new ShardConnection(_jsonSerializerOptions, _logger);
}
public async Task <HeartbeatResponseModel> UpdateDeviceHeartbeat([FromBody] DeviceHeartbeatModel model)
{
var command = HeartbeatReceived.FromDevice(_context.DeviceId, model);
var deviceVersion = await _messagingSrv.SendAsync(command);
return(new HeartbeatResponseModel {
ConfigurationVersion = deviceVersion.ConfigurationVersion
});
}
public void ReceiveHeartbeatSync(long id)
{
if (id <= LastHeartbeatReceived)
{
return;
}
LastHeartbeatReceived = id;
HeartbeatReceived.Raise(this, new HeartbeatSyncReceivedEventArgs(StitchInstanceId, LastHeartbeatReceived));
}
private void WebsocketPacketHandlerOnSocketHeartbeatReceived(DateTime heartbeatTime)
{
var eventArgs = new HeartbeatEventArgs(heartbeatTime);
HeartbeatReceived?.Invoke(this, eventArgs);
}
protected virtual void OnAlphaHeartbeatReceived(HeartbeatReceivedEventArgs e)
{
HeartbeatReceived?.Invoke(this, e);
}
private void OnStitchHeartbeatSyncReceived(object sender, HeartbeatSyncReceivedEventArgs e)
{
HeartbeatReceived.Raise(this, e);
}
private void HandleIncomingMessage(object sender, KrakenMessageEventArgs eventArgs)
{
logger.LogDebug("Handling incoming '{event}' message", eventArgs.Event);
switch (eventArgs.Event)
{
case Heartbeat.EventName:
var heartbeat = serializer.Deserialize <Heartbeat>(eventArgs.RawContent);
logger.LogTrace("Heartbeat received: {heartbeat}", heartbeat);
HeartbeatReceived.InvokeAll(this, heartbeat);
break;
case SystemStatus.EventName:
var systemStatus = serializer.Deserialize <SystemStatus>(eventArgs.RawContent);
logger.LogTrace("System status changed: {systemStatus}", systemStatus);
SystemStatus = systemStatus;
SystemStatusChanged.InvokeAll(this, systemStatus);
break;
case SubscriptionStatus.EventName:
var subscriptionStatus = serializer.Deserialize <SubscriptionStatus>(eventArgs.RawContent);
logger.LogTrace("Subscription status changed: {subscriptionStatus}", subscriptionStatus);
SynchronizeSubscriptions(subscriptionStatus);
SubscriptionStatusChanged.InvokeAll(this, subscriptionStatus);
break;
case "data":
var subscription = Subscriptions.ContainsKey(eventArgs.ChannelId.Value) ? Subscriptions[eventArgs.ChannelId.Value] : null;
if (subscription == null)
{
logger.LogWarning("Didn't find a subscription for channelId {channelId}", eventArgs.ChannelId);
break;
}
var dataType = subscription.Subscription.Name;
if (dataType == SubscribeOptionNames.Ticker)
{
var tickerMessage = TickerMessage.CreateFromString(eventArgs.RawContent, subscription);
TickerReceived.InvokeAll(this, new TickerEventArgs(subscription.ChannelId.Value, subscription.Pair, tickerMessage));
}
if (dataType == SubscribeOptionNames.OHLC)
{
var ohlcMessage = OhlcMessage.CreateFromString(eventArgs.RawContent);
OhlcReceived.InvokeAll(this, new OhlcEventArgs(subscription.ChannelId.Value, subscription.Pair, ohlcMessage));
}
if (dataType == SubscribeOptionNames.Trade)
{
var tradeMessage = TradeMessage.CreateFromString(eventArgs.RawContent);
TradeReceived.InvokeAll(this, new TradeEventArgs(subscription.ChannelId.Value, subscription.Pair, tradeMessage));
}
if (dataType == SubscribeOptionNames.Spread)
{
var spreadMessage = SpreadMessage.CreateFromString(eventArgs.RawContent);
SpreadReceived.InvokeAll(this, new SpreadEventArgs(subscription.ChannelId.Value, subscription.Pair, spreadMessage));
}
if (dataType == SubscribeOptionNames.Book)
{
if (eventArgs.RawContent.Contains(@"""as"":") && eventArgs.RawContent.Contains(@"""bs"":"))
{
var bookSnapshotMessage = BookSnapshotMessage.CreateFromString(eventArgs.RawContent);
BookSnapshotReceived.InvokeAll(this, new KrakenDataEventArgs <BookSnapshotMessage>(eventArgs.ChannelId.Value, subscription.Pair, bookSnapshotMessage));
}
if (eventArgs.RawContent.Contains(@"""a"":") || eventArgs.RawContent.Contains(@"""b"":"))
{
var bookUpdateMessage = BookUpdateMessage.CreateFromString(eventArgs.RawContent);
BookUpdateReceived.InvokeAll(this, new KrakenDataEventArgs <BookUpdateMessage>(eventArgs.ChannelId.Value, subscription.Pair, bookUpdateMessage));
}
}
break;
default:
logger.LogWarning("Could not handle incoming message: {message}", eventArgs.RawContent);
break;
}
}
