public UdpClientPeer()
{
Available = true;
ackMsgDict = new ConcurrentDictionary <uint, UdpNetworkMessage>();
//TODO Heartbeat 需要能够自定义传入，可扩展；
Heartbeat = new Heartbeat();
}
public IEnumerable <(string, string, string)> GetHeartbeats(IEnumerable <IEnumerable <BidEntry> > orders, ApiConfiguration config, IEnumerable <ConditionSetting> settings)
{
var heartbeats = new List <(string, string, string)>();
// Conditions are in order of priority
var conditions = Registry.GetHeartbeats();
foreach (var conditionEntry in conditions)
{
if (this.IsEnabled(settings, conditionEntry.Name))
{
IHeartbeat condition = (IHeartbeat)Activator.CreateInstance(conditionEntry, args: _serviceProvider);
if (conditionEntry.IsDefined(typeof(GlobalConditionAttribute), false))
{
heartbeats.Add(condition.Status(orders.SelectMany(o => o), config));
}
else
{
foreach (var order in orders)
{
heartbeats.Add(condition.Status(order, config));
}
}
}
}
return(heartbeats);
}
public virtual void LogHeartbeat(String type, String name, String status, String nameValuePairs)
{
IHeartbeat heartbeat = NewHeartbeat(type, name, nameValuePairs);
heartbeat.Status = status;
heartbeat.Complete();
}
public UdpClientPeer()
{
sndMsgDict = new ConcurrentDictionary <uint, UdpNetMessage>();
rcvMsgDict = new ConcurrentDictionary <uint, UdpNetMessage>();
//TODO Heartbeat 需要能够自定义传入，可扩展；
Heartbeat = new Heartbeat();
}
public void Setup()
{
this._logger = A.Fake <ILogger>();
this._exchangeTickInitialiser = A.Fake <IExchangeSeriesInitialiser>();
this._strategy = A.Fake <IEquityDataGeneratorStrategy>();
this._heartbeat = new Heartbeat(TimeSpan.FromMilliseconds(500));
}
public void Unsubscribe(IHeartbeat heartbeat)
{
lock (Heartbeats)
{
Heartbeats.Remove(heartbeat);
}
}
public App(IEnumerable <IGitService> gitServices, IBackupStrategy backupRunner, ILogger logger, IHeartbeat heartbeat, AppSettings settings)
{
this.gitServices = gitServices;
this.backupRunner = backupRunner;
this.logger = logger;
this.heartbeat = heartbeat;
this.settings = settings;
}
public void Subscribe(IHeartbeat heartbeat)
{
lock (Heartbeats)
{
if (!Heartbeats.Contains(heartbeat))
Heartbeats.Add(heartbeat);
}
}
/// <summary>
/// Initializes this heartbeat monitor with the given heartbeat interface and
/// settings that define how often a heartbeat measurement is performed.
/// </summary>
/// <param name="heartbeat"></param>
/// <param name="debugger"></param>
/// <param name="heartBeatInterval"></param>
/// <param name="failureThreshold"></param>
/// <param name="enabledWithAttachedDebugger"></param>
/// <param name="useHeartbeatFailureDetection"></param>
/// <param name="allowRemoteHeartbeatDisable"></param>
/// <param name="connectionId"></param>
/// <param name="endPointName"></param>
/// <param name="locEndPoint"></param>
/// <param name="remoteEndPoint"></param>
public HeartbeatMonitor(IHeartbeat heartbeat,
IDebugger debugger,
TimeSpan heartBeatInterval,
int failureThreshold,
bool enabledWithAttachedDebugger,
bool useHeartbeatFailureDetection,
bool allowRemoteHeartbeatDisable,
ConnectionId connectionId,
string endPointName,
EndPoint locEndPoint,
EndPoint remoteEndPoint)
{
if (heartbeat == null)
{
throw new ArgumentNullException(nameof(heartbeat));
}
if (debugger == null)
{
throw new ArgumentNullException(nameof(debugger));
}
if (heartBeatInterval < TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException(nameof(heartBeatInterval));
}
if (failureThreshold < 1)
{
throw new ArgumentOutOfRangeException(nameof(failureThreshold));
}
if (connectionId == ConnectionId.None)
{
throw new ArgumentException("connectionId");
}
if (remoteEndPoint == null)
{
throw new ArgumentNullException(nameof(remoteEndPoint));
}
_syncRoot = new object();
_heartbeat = heartbeat;
_heartbeat.RemoteDebuggerAttached += OnRemoteDebuggerAttached;
_heartbeat.RemoteDebuggerDetached += OnRemoteDebuggerDetached;
_debugger = debugger;
_interval = heartBeatInterval;
_enabledWithAttachedDebugger = enabledWithAttachedDebugger;
_useHeartbeatFailureDetection = useHeartbeatFailureDetection;
_allowRemoteHeartbeatDisable = allowRemoteHeartbeatDisable;
_connectionId = connectionId;
_endPointName = endPointName;
_localEndPoint = locEndPoint;
_remoteEndPoint = remoteEndPoint;
_failureInterval = heartBeatInterval +
TimeSpan.FromMilliseconds(failureThreshold * heartBeatInterval.TotalMilliseconds);
_thread = new Thread(MeasureHeartbeats)
{
Name = string.Format("{0}: Heartbeat measurement thread", _endPointName)
};
}
public void Unsubscribe(IHeartbeat heartbeat)
{
List <IHeartbeat> heartbeats = this.Heartbeats;
lock (heartbeats)
{
this.Heartbeats.Remove(heartbeat);
}
}
public bool ShouldPass(int channel, IHeartbeat heartbeat)
{
if (heartbeat.SentOnValidChannel(channel) == false)
{
throw new CommandInvalidException($"{heartbeat.GetType()} cannot be sent on channel {channel}.");
}
return(true);
}
public void Subscribe(IHeartbeat heartbeat)
{
lock (Heartbeats)
{
if (!Heartbeats.Contains(heartbeat))
{
Heartbeats.Add(heartbeat);
}
}
}
public virtual void LogHeartbeat(String type, String name, String status, String nameValuePairs, string messageTreeId)
{
IHeartbeat heartbeat = NewHeartbeat(type, name, messageTreeId);
if (!string.IsNullOrEmpty(nameValuePairs))
{
heartbeat.AddData(nameValuePairs);
}
heartbeat.Status = status;
heartbeat.Complete(CallContextManager.MessageTreeId);
}
public virtual void LogHeartbeat(string type, string name, string status, string nameValuePairs)
{
IHeartbeat heartbeat = NewHeartbeat(type, name);
if (!string.IsNullOrEmpty(nameValuePairs))
{
heartbeat.AddData(nameValuePairs);
}
heartbeat.Status = status;
heartbeat.Complete();
}
public void Subscribe(IHeartbeat heartbeat)
{
List <IHeartbeat> heartbeats = this.Heartbeats;
lock (heartbeats)
{
if (!this.Heartbeats.Contains(heartbeat))
{
this.Heartbeats.Add(heartbeat);
}
}
}
public void Unsubscribe(IHeartbeat heartbeat)
{
rwLock.EnterWriteLock();
try
{
Heartbeats.Remove(heartbeat);
}
finally
{
rwLock.ExitWriteLock();
}
}
/// <summary>
/// Creates a new manager that pumps a heartbeat at a specified interval.
/// </summary>
/// <param name="heartbeat">Heartbeat to pump.</param>
/// <param name="interval">Interval to pump at.</param>
/// <param name="server">Server that manages the Heartbeat information.</param>
public HeartbeatManager(IHeartbeat heartbeat, TimeSpan interval, IHeartbeatServer server)
{
Heartbeat = heartbeat;
Server = server;
UpdateTimer = new Timer(interval.TotalMilliseconds);
UpdateTimer.Start();
UpdateTimer.Elapsed += UpdateTimerHandler;
IsRunning = true;
Server.Log("Manager started!");
}
/// <summary>
/// Creates a new manager that pumps a heartbeat at a specified interval.
/// </summary>
/// <param name="heartbeat">Heartbeat to pump.</param>
/// <param name="interval">Interval to pump at.</param>
/// <param name="server">Server that manages the Heartbeat information.</param>
public HeartbeatManager(IHeartbeat heartbeat, TimeSpan interval, IHeartbeatServer server)
{
Heartbeat = heartbeat;
Server = server;
UpdateTimer = new Timer(interval.TotalMilliseconds);
UpdateTimer.Start();
UpdateTimer.Elapsed += UpdateTimerHandler;
IsRunning = true;
Server.Log("Manager started!");
}
public EquitiesMarkovProcess(
IExchangeSeriesInitialiser exchangeTickInitialiser,
IEquityDataGeneratorStrategy dataStrategy,
IHeartbeat heartbeat,
ILogger logger)
{
this._exchangeTickInitialiser = exchangeTickInitialiser
?? throw new ArgumentNullException(nameof(exchangeTickInitialiser));
this._dataStrategy = dataStrategy ?? throw new ArgumentNullException(nameof(dataStrategy));
this._heartBeat = heartbeat ?? throw new ArgumentNullException(nameof(heartbeat));
this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public void Subscribe(IHeartbeat heartbeat)
{
rwLock.EnterWriteLock();
try
{
if (!Heartbeats.Contains(heartbeat))
{
Heartbeats.Add(heartbeat);
}
}
finally
{
rwLock.ExitWriteLock();
}
}
internal Bus(ILogger logger,
ICommandSender commandSender,
IRequestSender requestSender,
IMulticastRequestSender multicastRequestSender,
IEventSender eventSender,
IMessagePumpsManager messagePumpsManager,
IDeadLetterOffice deadLetterOffice,
IHeartbeat heartbeat)
{
_logger = logger;
_commandSender = commandSender;
_requestSender = requestSender;
_multicastRequestSender = multicastRequestSender;
_eventSender = eventSender;
_heartbeat = heartbeat;
_messagePumpsManager = messagePumpsManager;
DeadLetterOffice = deadLetterOffice;
Started += async delegate { await _heartbeat.Start(); };
Stopping += async delegate { await _heartbeat.Stop(); };
}
/// <summary>
/// Initializes this heartbeat monitor with the given heartbeat interface and
/// settings that define how often a heartbeat measurement is performed.
/// </summary>
/// <param name="heartbeat"></param>
/// <param name="debugger"></param>
/// <param name="settings"></param>
/// <param name="connectionId"></param>
/// <param name="endPointName"></param>
/// <param name="localEndPoint"></param>
/// <param name="remoteEndPoint"></param>
public HeartbeatMonitor(IHeartbeat heartbeat,
IDebugger debugger,
HeartbeatSettings settings,
ConnectionId connectionId,
string endPointName,
EndPoint localEndPoint,
EndPoint remoteEndPoint)
: this(
heartbeat,
debugger,
settings.Interval,
settings.SkippedHeartbeatThreshold,
settings.ReportSkippedHeartbeatsAsFailureWithDebuggerAttached,
settings.UseHeartbeatFailureDetection,
settings.AllowRemoteHeartbeatDisable,
connectionId,
endPointName,
localEndPoint,
remoteEndPoint)
{
}
public void Run(object o)
{
while (true)
{
if (!m_nodeInfo.HaveAcessRight)
{
break;
}
m_nodeInfo.Refresh();
var messageTreeId = Jasmine.GetManager().GetMessageIdFactory().GetNextId();
ITransaction t = Jasmine.GetProducer().NewTransaction("System", "Status", messageTreeId);
IHeartbeat h = Jasmine.GetProducer().NewHeartbeat("Heartbeat", domainInfo.Ip, messageTreeId);
var xml = XmlHelper.XmlSerialize(m_nodeInfo, Encoding.UTF8);
h.AddData(xml);
h.Status = "0";
h.Complete(messageTreeId);
t.Status = "0";
t.Complete(messageTreeId);
Thread.Sleep(this.domainInfo.TickTime);
}
}
internal Bus(ILogger logger,
ICommandSender commandSender,
IRequestSender requestSender,
IMulticastRequestSender multicastRequestSender,
IEventSender eventSender,
IMessagePumpsManager messagePumpsManager,
IDeadLetterQueues deadLetterQueues,
INimbusTaskFactory taskFactory,
IHeartbeat heartbeat)
{
_logger = logger;
_commandSender = commandSender;
_requestSender = requestSender;
_multicastRequestSender = multicastRequestSender;
_eventSender = eventSender;
_deadLetterQueues = deadLetterQueues;
_taskFactory = taskFactory;
_heartbeat = heartbeat;
_messagePumpsManager = messagePumpsManager;
Started += async delegate { await _heartbeat.Start(); };
Stopping += async delegate { await _heartbeat.Stop(); };
}
public void Run(object o)
{
try
{
// Get DLL versions
collectComponentVersions();
Random random = new Random();
int initialSleep = random.Next(CatConstants.HEARTBEAT_MIN_INITIAL_SLEEP_MILLISECONDS, CatConstants.HEARTBEAT_MAX_INITIAL_SLEEP_MILLISECONDS);
Console.WriteLine("Heartbeat initial sleep: " + initialSleep + " ms");
Thread.Sleep(initialSleep);
}
catch (Exception ex) { Cat.lastException = ex; return; }
// In Java, try to avoid send heartbeat at 59-01 second, which is missing here in .NET
// In Java, try to build class paths, which is a list of jar file names.
try
{
ITransaction reboot = Cat.NewTransaction("System", "Reboot");
reboot.Status = CatConstants.SUCCESS;
Cat.LogEvent("Reboot", NetworkInterfaceManager.HostIP, CatConstants.SUCCESS);
reboot.Complete();
DateTime lastSendVersionsTimestamp = default(DateTime);
while (true)
{
ITransaction t = Cat.NewTransaction("System", "Status");
t.AddData(CatConstants.DUMP_LOCKED, false);
IHeartbeat h = Cat.NewHeartbeat("Heartbeat", NetworkInterfaceManager.HostIP);
try
{
var now = DateTime.Now;
bool isLongIntevalHeartbeat = false;
if (default(DateTime) == lastSendVersionsTimestamp ||
now.Hour != lastSendVersionsTimestamp.Hour ||
(now - lastSendVersionsTimestamp >= TimeSpan.FromMinutes(LONG_INTERVAL_HEARBEAT_MINUTES)))
{
isLongIntevalHeartbeat = true;
lastSendVersionsTimestamp = now;
}
h.AddData(BuildStatusData(isLongIntevalHeartbeat));
h.Status = CatConstants.SUCCESS;
if (isLongIntevalHeartbeat)
{
string configHeartBeatMessage = config.GetConfigHeartbeatMessage();
if (!String.IsNullOrWhiteSpace(configHeartBeatMessage))
{
Cat.LogEvent("Cat.Client.InconsistentAppId", configHeartBeatMessage);
}
}
}
catch (Exception ex)
{
Cat.lastException = ex;
h.SetStatus(ex);
Cat.LogError(ex);
}
finally
{
h.Complete();
}
if (!String.IsNullOrEmpty(fileVersion))
{
Cat.LogEvent("Cat.Client.Version", fileVersion);
}
t.Status = CatConstants.SUCCESS;
t.Complete();
// Append Cat.lastException if not null
if (null != Cat.lastException)
{
Exception ex = Cat.lastException;
Cat.lastException = null;
Cat.LogEvent("Cat.Client.LastException", ex.GetType().Name, CatConstants.SUCCESS, ex.ToString());
}
// Append Cat.lastMessage if not null
if (!String.IsNullOrWhiteSpace(Cat.lastMessage))
{
Cat.LogEvent("Cat.Client.LastMessage", "msg", CatConstants.SUCCESS, "message=" + Cat.lastMessage);
Cat.lastMessage = null;
}
// Sleep to the 30th second of the next minute, not to the 30th second of the current minute.
var sleepInSeconds = 90 - DateTime.Now.Second;
Thread.Sleep(sleepInSeconds * 1000);
}
}
catch (Exception ex) { Cat.lastException = ex; }
}
public HeartbeatJob(IHeartbeat heartbeat)
{
_heartbeat = heartbeat;
}
public ICompleteSelector Regular(TimeSpan frequency)
{
this._heartbeat = new Heartbeat(frequency);
return(this);
}
public ICompleteSelector Irregular(TimeSpan frequency, int sd)
{
this._heartbeat = new IrregularHeartbeat(frequency, sd);
return(this);
}
public ReportingController(IHeartbeat _heartbeat, AppDataContext _appDataContext)
{
heartbeat = _heartbeat;
dataContext = _appDataContext;
}
// Heartbeat details
public ITradingFactoryVolumeStrategySelector Regular(TimeSpan frequency)
{
this._heartbeat = new Heartbeat(frequency);
return(this);
}
public HeartbeatController(IHeartbeat _heartbeat)
{
heartbeat = _heartbeat;
}
public void Unsubscribe(IHeartbeat heartbeat)
{
lock (Heartbeats)
Heartbeats.Remove(heartbeat);
}
public TradingHeartBeatDrivenProcess(ILogger logger, ITradeStrategy <Order> orderStrategy, IHeartbeat heartbeat)
: base(logger, orderStrategy)
{
this._heartbeat = heartbeat ?? throw new ArgumentNullException(nameof(heartbeat));
}
