internal static void SetExternalConfigurationMode(string externalConfigFile)
{
var bForceConfigChange = false;
lock (Lockobject)
{
// if external config mode is true and the last used config file is equal to
// the external config file then we already have it loaded
externalConfigFile = RIUtils.DetermineParameterPath(externalConfigFile.IfNullOrEmptyUseDefault(string.Empty));
if (CurrentConfigurationMode != ConfigurationMode.External || externalConfigFile.ToLower() != LastConfigFullPath.ToLower())
{
ReflectInsightConfig appConfig = ReadAndCreateConfigObject(externalConfigFile);
DisposeAppConfigFileWatcher();
DisposeExternConfigFileWatcher();
CreateExternConfigFileWatcher(externalConfigFile);
CurrentConfigurationMode = ConfigurationMode.External;
LastConfigFullPath = externalConfigFile;
SetAssignedConfig(appConfig);
bForceConfigChange = true;
}
}
if (bForceConfigChange)
{
Control.ForceConfigChange();
}
}
private static ReflectInsightConfig GetActiveApplicationConfig(ReflectInsightConfig appConfig, out string activeFileName)
{
activeFileName = AppConfigFullFileName();
if (appConfig == null)
{
return(null);
}
var externalConfigSource = appConfig.GetAttribute(".", "externalConfigSource", string.Empty);
if (!string.IsNullOrWhiteSpace(externalConfigSource))
{
var fullPathConfigFile = RIUtils.DetermineParameterPath(externalConfigSource);
if (string.IsNullOrWhiteSpace(Path.GetDirectoryName(externalConfigSource)))
{
fullPathConfigFile = string.Format("{0}{1}", AppDomain.CurrentDomain.BaseDirectory, externalConfigSource);
}
// just in case someone is trying to play smart by assigning the external source name
// to the App Config file name, just ignore and assume the app config file only
if (fullPathConfigFile.ToLower() != AppConfigFullFileName().ToLower())
{
appConfig = ReadAndCreateConfigObject(fullPathConfigFile);
activeFileName = fullPathConfigFile;
}
}
return(appConfig);
}
public virtual void UpdateParameterVariables(IListenerInfo listener)
{
FDetails = ListenerFileHelper.DetermineMessageTextFlagParam(listener);
FMessagePattern = ListenerFileHelper.DetermineMessageTextPattern(listener);
FTimePatterns = RIUtils.GetListOfTimePatterns(FMessagePattern);
FColored = listener.Params["colored"].IfNullOrEmptyUseDefault("true").Trim() == "true";
}
private void ForceAutoSave()
{
FControlFileStream.Flush();
FFileStream.Flush();
Stream textStream = (FFileStream as StreamWriter).BaseStream;
String recycleFilePath = FileHelper.RecycleAndGetNextFileName(FFilePath, FAutoSave, FFileHeader);
using (FileStream recycleStream = FileStreamAccess.OpenFileStreamForWriting(recycleFilePath, FileMode.Create))
{
RIUtils.CopyFile(textStream, recycleStream);
}
// truncate text file
textStream.SetLength(0);
textStream.Seek(0, SeekOrigin.End);
FFileStream.Flush();
// trucate control file
FControlFileStream.SetLength(0);
FControlFileStream.Seek(0, SeekOrigin.End);
FControlFileStream.Flush();
FFileHeader = FileHelper.ReadHeader(FControlFileStream, FControlFilePath, null);
FControlFileStream.Seek(0, SeekOrigin.End);
}
public DestinationInfo GetDestination(String name)
{
lock (this)
{
return(GetDestination(RIUtils.GetStringHash(name)));
}
}
internal ListenerInfo(String name, String details, SafeNameValueCollection objParams, IReflectInsightListener listener)
{
Id = RIUtils.GetStringHash(name);
Name = name;
Details = details;
Params = objParams;
Listener = listener;
Disposed = false;
}
public void RemoveDestination(String name)
{
lock (this)
{
Int32 id = RIUtils.GetStringHash(name);
if (FDestinations.ContainsKey(id))
{
RemoveDestination(FDestinations[id]);
}
}
}
//--------------------------------------------------------------------
//private void ExampleHowToExtendTheHeader()
//{
// // The code below shows how to extend the header.
// // In this example, the MyExtraData must implement the IFastSerializer.
// // Extending the header in the context of a text, has very little usage
// // but nonetheless, is supported for those odd rare cases if needed.
// // FFileHeader.FExtraData["MyExtraData"] = new FastSerializerObjectData(new MyExtraData());
//}
/// -------------------------------------------------------------------
private void ProcessMessages(ReflectInsightPackage[] messages)
{
OpenFileStream();
try
{
Stream baseStream = (FFileStream as StreamWriter).BaseStream;
DateTime dt = DateTime.Now.ToUniversalTime();
foreach (ReflectInsightPackage message in messages)
{
if (message.FMessageType == MessageType.PurgeLogFile)
{
PurgeLogFile();
continue;
}
if (message.FMessageType == MessageType.Clear || RIUtils.IsViewerSpecificMessageType(message.FMessageType))
{
continue;
}
message.FDateTime = dt;
message.FSequenceID = FFileHeader.GetNextSequenceId();
String txtMessage = MessageText.Convert(message, FDetails, FMessagePattern, FTimePatterns);
if (FileHelper.ShouldAutoSave(FFileHeader, FAutoSave, baseStream, FOnSize, message.FDateTime, txtMessage.Length))
{
ForceAutoSave();
message.FSequenceID = FFileHeader.GetNextSequenceId();
txtMessage = MessageText.Convert(message, FDetails, FMessagePattern, FTimePatterns);
}
if (FFileHeader.FInitDateTime == DateTime.MinValue)
{
FFileHeader.FInitDateTime = message.FDateTime;
FFileHeader.FFirstDateTime = message.FDateTime;
FFileHeader.FLastDateTime = message.FDateTime;
}
FFileHeader.FMessageCount++;
FFileHeader.FLastDateTime = message.FDateTime;
FFileStream.Write(txtMessage);
DebugManager.Sleep(0);
}
}
finally
{
CloseFileStream(true);
}
}
internal ListenerGroup(String name, Boolean bEnabled, Boolean bMaskIdentities)
{
Id = RIUtils.GetStringHash(name);
Name = name;
Enabled = bEnabled;
MaskIdentities = bMaskIdentities;
FromConfig = false;
Disposed = false;
FDestinations = new Dictionary <Int32, DestinationInfo>();
FDestinationBindingGroups = new Dictionary <Int32, DestinationBindingGroup>();
ReconstructFastDestinationArray();
}
internal DestinationInfo(String name, String details, Boolean bEnabled)
{
Id = RIUtils.GetStringHash(name);
Name = name;
Enabled = bEnabled;
Disposed = false;
BindingGroupIds = new HashSet <Int32>();
FFilter = new RIFilter();
InterimMessageQueue = new List <ReflectInsightPackage>();
Details = details;
FListeners = new List <ListenerInfo>();
DetailParser.AddListenersByDetails(FListeners, details);
}
public virtual void Receive(ReflectInsightPackage[] messages)
{
DateTime dt = DateTime.Now.ToUniversalTime();
foreach (ReflectInsightPackage message in messages)
{
if (message.FMessageType == MessageType.Clear ||
message.FMessageType == MessageType.PurgeLogFile ||
RIUtils.IsViewerSpecificMessageType(message.FMessageType))
{
continue;
}
message.FDateTime = dt;
if (FColored)
{
switch (message.FMessageType)
{
case MessageType.SendDebug: Console.ForegroundColor = ConsoleColor.Green; break;
case MessageType.SendInformation: Console.ForegroundColor = ConsoleColor.White; break;
case MessageType.SendWarning: Console.ForegroundColor = ConsoleColor.Yellow; break;
case MessageType.SendError: Console.ForegroundColor = ConsoleColor.Magenta; break;
case MessageType.SendFatal: Console.ForegroundColor = ConsoleColor.Red; break;
case MessageType.SendMiniDumpFile: Console.ForegroundColor = ConsoleColor.Red; break;
case MessageType.SendException: Console.ForegroundColor = ConsoleColor.Red; break;
}
}
Console.Write(MessageText.Convert(message, FDetails, FMessagePattern, FTimePatterns));
if (FColored)
{
Console.ForegroundColor = ConsoleColor.Gray;
}
DebugManager.Sleep(0);
}
}
public DestinationInfo AddDestination(String name, String details, Boolean bEnabled)
{
lock (this)
{
Int32 id = RIUtils.GetStringHash(name);
DestinationInfo dInfo = GetDestination(id);
if (dInfo != null)
{
return(dInfo);
}
dInfo = new DestinationInfo(name, details, bEnabled);
FDestinations[dInfo.Id] = dInfo;
ReconstructFastDestinationArray();
return(dInfo);
}
}
private void ForceAutoSave()
{
// write header and flush all buffers
FileHelper.WriteHeader(FFileStream, FFileHeader);
FFileStream.Flush();
String recycleFilePath = FileHelper.RecycleAndGetNextFileName(FFilePath, FAutoSave, FFileHeader);
using (FileStream recycleStream = FileStreamAccess.OpenFileStreamForWriting(recycleFilePath, FileMode.Create))
{
RIUtils.CopyFile(FFileStream, recycleStream);
}
// trucate the file
FFileStream.SetLength(0);
FFileStream.Flush();
FFileHeader = FileHelper.ReadHeader(FFileStream, FFilePath, null);
FFileStream.Seek(0, SeekOrigin.End);
}
static internal void ProcessMessages()
{
lock (FDebugLockObject)
{
ListenerGroup activeGroup = RIListenerGroupManager.ActiveGroup;
BoundReflectInsightPackage[] boundPackages = MessageQueue.GetBoundMessages();
if (activeGroup == null || boundPackages.Length == 0)
{
return;
}
DestinationInfo[] destinations = activeGroup.Destinations;
if (destinations.Length == 0)
{
return;
}
// chunk the sending to reduce memory pressure
Int32 at = 0;
Int32 remaining = boundPackages.Length;
Int32 chunk = remaining < FMaxChunking ? remaining : FMaxChunking;
while (remaining > 0)
{
for (Int32 i = at; i < (at + chunk); i++)
{
RIUtils.HandleUnknownMessage(boundPackages[i].Package);
AddToDestinationInterimMessageQueue(destinations, boundPackages[i]);
}
SendPackages(destinations);
Thread.Sleep(0);
at += chunk;
remaining -= chunk;
chunk = remaining < FMaxChunking ? remaining : FMaxChunking;
}
}
}
public void ReadFromGame(NetInfo gameNetInfo)
{
this.name = gameNetInfo.name;
RIUtils.CopyFromGame(gameNetInfo, this.basic);
TrainTrackAI gameRoadAI = (TrainTrackAI)gameNetInfo.m_netAI;
RIUtils.CopyFromGame(gameRoadAI.m_elevatedInfo, this.elevated);
RIUtils.CopyFromGame(gameRoadAI.m_bridgeInfo, this.bridge);
RIUtils.CopyFromGame(gameRoadAI.m_slopeInfo, this.slope);
RIUtils.CopyFromGame(gameRoadAI.m_tunnelInfo, this.tunnel);
RIUtils.CopyFromGame(gameRoadAI, this.basicAI);
RIUtils.CopyFromGame(gameRoadAI.m_elevatedInfo?.GetAI(), this.elevatedAI);
RIUtils.CopyFromGame(gameRoadAI.m_bridgeInfo?.GetAI(), this.bridgeAI);
RIUtils.CopyFromGame(gameRoadAI.m_slopeInfo?.GetAI(), this.slopeAI);
RIUtils.CopyFromGame(gameRoadAI.m_tunnelInfo?.GetAI(), this.tunnelAI);
basicModel.Read(gameNetInfo, "Basic");
elevatedModel.Read(gameRoadAI.m_elevatedInfo, "Elevated");
bridgeModel.Read(gameRoadAI.m_bridgeInfo, "Bridge");
slopeModel.Read(gameRoadAI.m_slopeInfo, "Slope");
tunnelModel.Read(gameRoadAI.m_tunnelInfo, "Tunnel");
}
static private void AddAndProcessMessages(Action addCallback)
{
// The throttle logic was designed to prevent the Message Queue
// from overflowing with too many messages. This usually happens if the
// MessageManager processing the messages becomes too busy and
// cannot keep up with the increase of incoming demand, causing
// an overflow of unprocessed Messages, which inadvertently, caused
// a high usage in memory.
lock (ThrottleLock)
{
Int32 messageCount;
lock (Messages)
{
addCallback();
messageCount = Messages.Count;
}
if (messageCount < MaxThrottleValue)
{
MessageManager.Process();
return;
}
RIUtils.GCCollect();
MessageManager.Process();
while (MessageManager.IsProcessing)
{
Thread.Sleep(100);
}
RIUtils.GCCollect();
}
}
static internal Int32 GetId(String name)
{
return(RIUtils.GetStringHash(name));
}
public Boolean ContainsDestination(String name)
{
return(ContainsDestination(RIUtils.GetStringHash(name)));
}
//--------------------------------------------------------------------
//private void ExampleHowToExtendTheHeader()
//{
// // The code below shows how to extend the header.
// // Keep in mind that when you extend the header, you must rewrite
// // the file. Try to avoid extending the header frequently as this will
// // impact performance.
// //
// // In this example, the MyExtraData must implement the IFastSerializer.
// //RIFileHeader newHeader = (RIFileHeader)FFileHeader.Clone();
// //newHeader.FExtraData["MyExtraData"] = new FastSerializerObjectData(new MyExtraData());
//}
///--------------------------------------------------------------------
private void ProcessMessages(ReflectInsightPackage[] messages)
{
if (FCreateDirectory)
{
Directory.CreateDirectory(Path.GetDirectoryName(FFilePath));
FCreateDirectory = false;
}
OpenFileStream();
try
{
using (var pool = FastFormatterPool.Pool.Container())
{
DateTime dt = DateTime.Now.ToUniversalTime();
foreach (ReflectInsightPackage message in messages)
{
if (message.FMessageType == MessageType.PurgeLogFile)
{
PurgeLogFile();
continue;
}
if (message.FMessageType != MessageType.Clear)
{
if (RIUtils.IsViewerSpecificMessageType(message.FMessageType))
{
continue;
}
// serialize the message
message.FDateTime = dt;
message.FSequenceID = FFileHeader.GetNextSequenceId();
Byte[] bMessage = pool.Instance.Serialize(message);
if (FileHelper.ShouldAutoSave(FFileHeader, FAutoSave, FFileStream, FOnSize, message.FDateTime, bMessage.Length))
{
ForceAutoSave();
// because the previous message was serialized with the previous last sequence id
// we need to re-serialize the message with the new sequence id
message.FSequenceID = FFileHeader.GetNextSequenceId();
bMessage = pool.Instance.Serialize(message);
}
if (FFileHeader.FInitDateTime == DateTime.MinValue)
{
FFileHeader.FInitDateTime = message.FDateTime;
FFileHeader.FFirstDateTime = message.FDateTime;
FFileHeader.FLastDateTime = message.FDateTime;
}
FFileHeader.FMessageCount++;
FFileHeader.FLastDateTime = message.FDateTime;
FFileStream.Write(bMessage, 0, bMessage.Length);
}
else // clear
{
RewriteFileIgnoreRequestor((RIFileHeader)FFileHeader.Clone(), pool.Instance, message.FSessionID, message.FRequestID);
}
DebugManager.Sleep(0);
}
}
}
finally
{
CloseFileStream(true);
}
}
