private static void LoadingAdjustedTimestamp_OnHighLoad()
{
if (s_lastResetTime.ElapsedSeconds() > 10)
{
s_lastResetTime = ShortTime.Now;
MonitorThreads();
}
}
public bool IsCertificateTrusted(X509Certificate channelCertificate)
{
lock (m_syncRoot)
{
TryAgain:
if (!m_list.TryGetValue(channelCertificate.GetCertHashString(), out var data))
{
if (m_lastCertRefresh.ElapsedSeconds() > 60)//check at most once per minute
{
RebuildCerts();
goto TryAgain;
}
return(false);
}
return(channelCertificate.GetRawCertData().SequenceEqual(data));
}
}
/// <summary>
/// Attempts to take a token from the rate limiter.
/// </summary>
/// <returns>true if token was successfully taken, False if all tokens were consumed.</returns>
public bool TryTakeToken()
{
var currentTime = ShortTime.Now;
var tokensGenerated = m_updateTime.ElapsedSeconds(currentTime) * m_tokenPerSecond;
//To limit rounding errors at high call rates,
//do not add a token until it acumiliates to a relatively large value.
if (tokensGenerated > 0.5)
{
m_tokens = Math.Min(m_tokens + tokensGenerated, m_maxTokens);
m_updateTime = currentTime;
}
if (m_tokens < 0.99)
{
return(false);
}
m_tokens--;
return(true);
}
private bool TryFindCertificate(string thumbprint, out X509Certificate2 cert, out CtpAccount account)
{
lock (m_syncRoot)
{
TryAgain:
if (!m_certificateAccounts.TryGetValue(thumbprint, out var tuple))
{
if (m_lastCertRefresh.ElapsedSeconds() > 60)//check at most once per minute
{
RebuildCerts();
goto TryAgain;
}
cert = null;
account = null;
return(false);
}
cert = new X509Certificate2(tuple.Item2);
account = m_accounts[tuple.Item1];
return(true);
}
}
private unsafe string TestFile(string fileName)
{
ShortTime lastReport = ShortTime.Now;
int errorBlocks = 0;
uint firstBlockWithError = uint.MaxValue;
try
{
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
int blockSize = FileHeaderBlock.SearchForBlockSize(stream);
stream.Position = 0;
byte[] data = new byte[blockSize];
stream.ReadAll(data, 0, blockSize);
var header = FileHeaderBlock.Open(data);
fixed(byte *lp = data)
{
stream.Position = header.HeaderBlockCount * blockSize;
uint startingBlock = header.HeaderBlockCount;
if (m_shouldQuickScan)
{
uint blocksToScan = (uint)Math.Ceiling(m_mbToScan * 1024 * 1024 / blockSize);
if (blocksToScan < header.LastAllocatedBlock)
{
startingBlock = Math.Max(header.HeaderBlockCount, header.LastAllocatedBlock - blocksToScan);
}
}
for (uint x = startingBlock; x <= header.LastAllocatedBlock; x++)
{
long checksum1;
int checksum2;
stream.ReadAll(data, 0, blockSize);
Footer.ComputeChecksum((IntPtr)lp, out checksum1, out checksum2, blockSize - 16);
long checksumInData1 = *(long *)(lp + blockSize - 16);
int checksumInData2 = *(int *)(lp + blockSize - 8);
if (!(checksum1 == checksumInData1 && checksum2 == checksumInData2))
{
firstBlockWithError = Math.Min(firstBlockWithError, x);
errorBlocks++;
}
if (m_quit)
{
if (errorBlocks == 0)
{
return("Quit Early - No Errors Found");
}
return($"Quit Early - Blocks With Errors {errorBlocks} Starting At {firstBlockWithError}");
}
if (lastReport.ElapsedSeconds() > .25)
{
lastReport = ShortTime.Now;
lblProgress.Text = $"Completed {m_filesScanned} of {m_filesToScan} files. Current File: {(stream.Position / (double)stream.Length).ToString("0.0%")}";
Application.DoEvents();
}
}
}
}
if (errorBlocks == 0)
{
return("No Errors Found");
}
return($"Blocks With Errors {errorBlocks} Starting At {firstBlockWithError}");
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
return("Error");
}
}
void m_task_Running(object sender, EventArgs <ScheduledTaskRunningReason> e)
{
if (e.Argument == ScheduledTaskRunningReason.Disposing)
{
return;
}
m_task.Start(m_routeLatency);
m_routeOperations++;
if (m_lastStatusUpdate.ElapsedSeconds() > 15)
{
m_lastStatusUpdate = ShortTime.Now;
Log.Publish(MessageLevel.Info, MessageFlags.None, "Routing Update",
string.Format("Route Operations: {0}, Input Frames: {1}, Input Measurements: {2}, Output Measurements: {3}",
m_routeOperations, m_measurementsRoutedInputFrames,
m_measurementsRoutedInputMeasurements,
m_measurementsRoutedOutput));
}
var map = m_globalCache;
try
{
int measurementsRouted = 0;
List <IMeasurement> measurements;
while (m_inboundQueue.TryDequeue(out measurements))
{
measurementsRouted += measurements.Count;
Interlocked.Add(ref m_pendingMeasurements, -measurements.Count);
//For loops are faster than ForEach for List<T>
//Process Optimized Consumers
for (int x = 0; x < map.RoutingPassthroughAdapters.Count; x++)
{
map.RoutingPassthroughAdapters[x].ProcessMeasurementList(measurements);
}
//Process Broadcast Consumers
for (int x = 0; x < map.BroadcastConsumers.Count; x++)
{
m_measurementsRoutedOutput += measurements.Count;
map.BroadcastConsumers[x].MeasurementsToRoute.AddRange(measurements);
}
m_measurementsRoutedInputFrames++;
m_measurementsRoutedInputMeasurements += measurements.Count;
for (int x = 0; x < measurements.Count; x++)
{
var measurement = measurements[x];
List <Consumer> consumers = map.GlobalSignalLookup[measurement.Key.RuntimeID];
if (consumers != null)
{
for (int i = 0; i < consumers.Count; i++)
{
m_measurementsRoutedOutput++;
consumers[i].MeasurementsToRoute.Add(measurement);
}
}
}
//If any adapter has too many measurements on their batch
//Route all adapter's measurements
if (measurementsRouted > m_batchSize)
{
measurementsRouted = 0;
foreach (var consumer in map.NormalDestinationAdapters)
{
measurementsRouted = Math.Max(measurementsRouted, consumer.MeasurementsToRoute.Count);
if (consumer.MeasurementsToRoute.Count > m_batchSize)
{
foreach (var c2 in map.NormalDestinationAdapters)
{
c2.RoutingComplete();
}
measurementsRouted = 0;
break;
}
}
}
}
}
finally
{
foreach (var consumer in map.NormalDestinationAdapters)
{
consumer.RoutingComplete();
}
}
}
