/// <summary>
/// Add token message at header to using NHibernate cache
/// </summary>
/// <param name="request"></param>
/// <param name="channel"></param>
/// <returns></returns>
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
// add trace log for debug and performance tuning
if (null != (request.Headers).MessageId && (request.Headers).MessageId.IsGuid)
{
ServiceStopWatch = Stopwatch.StartNew();
Guid messageId;
(request.Headers).MessageId.TryGetGuid(out messageId);
CurrentTraceInfo = new TraceInfo()
{
SessionId = (HttpContext.Current != null && HttpContext.Current.Session != null) ? HttpContext.Current.Session.SessionID : "",
TraceType = TraceType.WcfActionClientCall,
TraceName = request.Headers.Action,
TraceUniqueId = messageId.ToString()
};
TraceLogger.Instance.TraceServiceStart(CurrentTraceInfo, true);
// Add a message header with sessionid
MessageHeader<string> messageHeader = new MessageHeader<string>(CurrentTraceInfo.SessionId);
MessageHeader untyped = messageHeader.GetUntypedHeader("sessionid", "ns");
request.Headers.Add(untyped);
}
return null;
}
public void JsonSpan()
{
// Arrange
var traceInfo = new TraceInfo("05", "123", true, false, new Uri("http://localhost"), IPAddress.Loopback);
var span = new Span("15", traceInfo);
var annotation = Substitute.For <Annotation>();
var binaryAnnotation = Substitute.For <BinaryAnnotation>();
span.Annotations.Add(annotation);
span.Annotations.Add(annotation);
span.Annotations.Add(binaryAnnotation);
span.Annotations.Add(binaryAnnotation);
// Act
var result = new JsonSpan(span);
// Assert
Assert.AreEqual(span.TraceId, result.TraceId);
Assert.AreEqual(span.Name, result.Name);
Assert.AreEqual(span.Id, result.Id);
Assert.AreEqual(span.ParentId, result.ParentId);
Assert.AreEqual(2, result.Annotations.Count());
Assert.AreEqual(2, result.BinaryAnnotations.Count());
}
OverlayData.Driver[] LatestRunningOrder(DataSample data, TimeSpan relativeTime)
{
var drivers = data.Telemetry.Cars.Where(c => !c.Details.IsPaceCar).Select(c => new OverlayData.Driver
{
UserName = c.Details.UserName,
CarNumber = c.Details.CarNumberDisplay,
Position = c.Position,
CarIdx = c.CarIdx,
PitStopCount = c.PitStopCount
})
.OrderBy(c => c.Position)
.ToArray();
if (lastDrivers != null)
{
foreach (var d in drivers.OrderBy(d => d.Position))
{
var lastPosition = lastDrivers.FirstOrDefault(lp => lp.CarIdx == d.CarIdx);
if (lastPosition != null && lastPosition.Position != d.Position)
{
var position = d.Position != null?d.Position.Value.ToString() : "";
var indicator = d.Position != null?d.Position.Value.Ordinal() : "";
var msg = "{0} in {1}{2}".F(d.UserName, position, indicator);
TraceInfo.WriteLine("{0} {1}", data.Telemetry.SessionTimeSpan, msg);
commentaryMessages.Add(msg, relativeTime.TotalSeconds);
}
}
}
lastDrivers = drivers;
return(drivers);
}
void PrintStackTrace(TraceInfo traceInfo)
{
if (traceInfo != null && traceInfo.stackTrace != null)
{
Console.WriteLine(traceInfo.stackTrace);
}
}
public void Process(DataSample data)
{
if (data.Telemetry.CamCar.TrackSurface == TrackLocation.InPitStall ||
data.Telemetry.CamCar.TrackSurface == TrackLocation.NotInWorld ||
data.Telemetry.CamCar.TrackSurface == TrackLocation.AproachingPits)
{
TraceInfo.WriteLine("{0} Ignoring incident in the pits on lap {1}", data.Telemetry.SessionTimeSpan, data.Telemetry.RaceLaps);
return;
}
var i = new Incident
{
LapNumber = data.Telemetry.RaceLaps,
Car = data.Telemetry.CamCar.Details,
StartSessionTime = data.Telemetry.SessionTimeSpan - 1.Seconds(),
EndSessionTime = data.Telemetry.SessionTimeSpan + 8.Seconds()
};
var lastIncidentForCar = incidents.LastOrDefault(li => li.Car.CarIdx == i.Car.CarIdx);
if (lastIncidentForCar == null || lastIncidentForCar.EndSessionTime + 15.Seconds() < i.StartSessionTime)
{
AddIncident(i);
}
else
{
ExtendIncident(lastIncidentForCar, i.EndSessionTime);
}
}
protected virtual void OnTraceState(TraceInfo traceInfo, ExecuteState state, ExecuteResult result = null)
{
_ = traceInfo ?? throw new ArgumentNullException(nameof(traceInfo));
traceInfo.State = state;
traceInfo.Result = result;
traceService.TraceState(traceInfo);
}
public void Logging_StartTrace_TraceRecorded(string msg, params string[] msgs)
{
var trace = new TraceInfo(msg);
for (var x = 0; x < msgs.Length; x++)
{
trace.Add($"stuff{x}", msgs[x]);
}
using (var ms = new MemoryStream())
{
var w = new StreamWriter(ms);
var logger = new ConsoleInstrumentationClient(w);
logger.StartTrace(trace);
w.Flush();
ms.Seek(0, SeekOrigin.Begin);
var result = new StreamReader(ms).ReadToEnd();
result = result.Trim(Environment.NewLine.ToCharArray());
result.Should().StartWith(msg);
foreach (var m in msgs)
{
result.Should().Contain(m);
}
}
}
public void _AnalyseRace(Action onComplete)
{
var hwnd = Win32.Messages.FindWindow(null, "iRacing.com Simulator");
Win32.Messages.ShowWindow(hwnd, Win32.Messages.SW_SHOWNORMAL);
Win32.Messages.SetForegroundWindow(hwnd);
Thread.Sleep(Settings.Default.PeriodWaitForIRacingSwitch);
var data = iRacing.GetDataFeed()
.WithCorrectedPercentages()
.AtSpeed(16)
.RaceOnly()
.First(d => d.Telemetry.SessionState == SessionState.Racing);
raceStartFrameNumber = data.Telemetry.ReplayFrameNum - (60 * 20);
if (raceStartFrameNumber < 0)
{
TraceInfo.WriteLine("Unable to start capturing at 20 seconds prior to race start. Starting at start of replay file.");
raceStartFrameNumber = 0;
}
TraceDebug.WriteLine(data.Telemetry.ToString());
AnalyseIncidents();
onComplete();
}
internal static void MoveToFile(string filename)
{
if (logFile == null)
{
throw new Exception("Attempt to rename non-existing log file to {0}".F(filename));
}
TraceInfo.WriteLine("Renaming logging to file {0}", filename);
WaitToQueueEmpty(logFile);
Trace.Listeners.Remove(logFile);
logFile.Dispose();
var retryCount = 2;
while (retryCount > 0)
{
try {
File.Move(logFile.FileName, filename);
retryCount = 0;
} catch (IOException) {
retryCount--;
Thread.Sleep(1000);
}
}
logFile = new LogListener(filename);
Trace.Listeners.Add(logFile);
}
public Task <ExecuteResult> Execute(IExecuteContext executeContext)
{
_ = executeContext ?? throw new ArgumentNullException(nameof(executeContext));
var traceInfo = new TraceInfo()
{
ExecuteContext = executeContext
};
this.OnTraceState(traceInfo, ExecuteState.Ready);
return(Task.Run(() =>
{
executeContext.Token.ThrowIfCancellationRequested();
this.OnTraceState(traceInfo, ExecuteState.Running);
var result = this.OnExecute(executeContext, traceInfo);
if (result.IsSuccess)
{
this.OnTraceState(traceInfo, ExecuteState.Success, result);
}
else
{
this.OnTraceState(traceInfo, ExecuteState.Failure, result);
}
return result;
}, executeContext.Token));
}
public void MoveToFrame(int frameNumber, ReplayPositionMode mode = ReplayPositionMode.Begin)
{
DataSample data = null;
Wait();
TraceInfo.WriteLine("Moving to frame {0} with mode {1}", frameNumber, mode);
SendMessage(BroadcastMessage.ReplaySetPlayPosition, (short)mode, frameNumber);
Wait();
if (mode == ReplayPositionMode.Begin)
{
data = WaitAndVerify(d => Math.Abs(d.Telemetry.ReplayFrameNum - frameNumber) > 32, 6000);
}
Wait();
if (data != null)
{
frameNumber = data.Telemetry.ReplayFrameNum;
}
TraceInfo.WriteLine("Moved to frame {0}", frameNumber);
}
public override void OnResultExecuted(ResultExecutedContext filterContext)
{
if (filterContext.HttpContext.Response.IsRequestBeingRedirected)
{
return;
}
if (CheckNeedTrace(filterContext.HttpContext) == false)
{
return;
}
TraceInfo info = filterContext.RequestContext.HttpContext.Items["ibb360_RequestTrace_6742"] as TraceInfo;
if (info != null)
{
info.Stop(filterContext.Exception != null && (filterContext.Exception is BizException) == false);
string urlReferrer = filterContext.RequestContext.HttpContext.Request.UrlReferrer != null?filterContext.RequestContext.HttpContext.Request.UrlReferrer.ToString() : null;
string domainReferrer = filterContext.RequestContext.HttpContext.Request.UrlReferrer != null ? filterContext.RequestContext.HttpContext.Request.UrlReferrer.Host : null;
string url = filterContext.RequestContext.HttpContext.Request.RawUrl;
string clientType = DetectRequestClientType(filterContext.HttpContext);
if (string.IsNullOrWhiteSpace(clientType))
{
clientType = "OT";
}
RequestTraceMessage msg = info.ToMessage(filterContext.HttpContext, url, urlReferrer, domainReferrer, clientType);
SetExtentionData(filterContext.HttpContext, msg.ExtentionData);
TaskPool.Instance.Enqueue(msg);
}
}
private void CaptureNewFileNames(object sender, ElapsedEventArgs e)
{
try
{
var guessedFileName = Directory.GetFiles(workingFolder, "*.avi")
.Concat(Directory.GetFiles(workingFolder, "*.mp4"))
.Select(fn => new { FileName = fn, CreationTime = File.GetCreationTime(fn) })
.Where(f => f.CreationTime >= started)
.OrderByDescending(f => f.CreationTime)
.FirstOrDefault();
if (guessedFileName != null && !captureFileNames.Any(c => c.FileName == guessedFileName.FileName))
{
TraceInfo.WriteLine("Found video file {0}", guessedFileName.FileName);
captureFileNames.Add(new CapturedVideoFile {
FileName = guessedFileName.FileName
});
}
}
catch (Exception ee)
{
TraceError.WriteLine(ee.Message);
TraceError.WriteLine(ee.StackTrace);
}
finally
{
if (timer != null)
{
timer.Start();
}
}
}
public async Task Context()
{
var traceInfo = new TraceInfo
{
Start = new DateTime(2020, 3, 12),
CallApp = "UnitTest"
};
var msg = await MessagePoster.Post(new InlineMessage
{
Service = "UnitService",
Method = "v1/context",
TraceInfo = traceInfo,
Context = new System.Collections.Generic.Dictionary <string, string>
{
{ "User", new UserInfo
{
UserId = "20200312",
NickName = "agebull",
OrganizationId = "20200312"
}.ToJson() }
}
});
msg.OfflineResult();
Console.WriteLine(msg.Result);
var ctx = msg.ResultData;
Assert.IsTrue(ctx != null, msg.Result);
Assert.IsTrue(msg.TraceInfo.CallApp == traceInfo.CallApp, msg.TraceInfo.CallApp);
Assert.IsTrue(msg.TraceInfo.Start == traceInfo.Start, msg.TraceInfo.Start?.ToString());
//Assert.IsTrue(ctx.User.OrganizationId == ZeroTeamJwtClaim.UnknownOrganizationId, ctx.User.OrganizationId.ToString());
}
void UpdateBattleCamera(DataSample data)
{
if (data.Telemetry.SessionTimeSpan <= cameraChangeTime)
{
return;
}
cameraChangeTime = data.Telemetry.SessionTimeSpan + this.battleCameraChangePeriod;
var otherCar = ChangeCarForCamera(data, battleFollower);
var cameraSet = otherCar == null ? new [] { CameraAngle.LookingInfrontOfCar, CameraAngle.LookingAtCar } : new [] { CameraAngle.LookingInfrontOfCar, CameraAngle.LookingBehindCar, CameraAngle.LookingAtCar };
camera = cameraControl.FindACamera(cameraSet, adjustedCamera, 2);
adjustedCamera = null;
if (camera.CameraAngle == CameraAngle.LookingBehindCar)
{
TraceInfo.WriteLine("{0} Changing to forward car, with reverse camera", data.Telemetry.SessionTimeSpan);
car = otherCar;
}
else
{
car = battleFollower;
}
TraceInfo.WriteLine("{0} Changing camera to driver: {1}; camera: {2}", data.Telemetry.SessionTimeSpan, car.UserName, camera.CameraName);
cameraControl.CameraOnDriver(car.CarNumberRaw, camera.CameraNumber);
}
static void Main()
{
if (!Settings.Default.NewSettings)
{
CopyFromOldSettings(Settings.Default);
}
else
{
MakePortable(Settings.Default);
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.ThreadException += Application_ThreadException;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
if (AwsKeys.HaveKeys)
{
using (var awsLogListener = new AwsLogListener())
{
Trace.Listeners.Add(awsLogListener);
TraceInfo.WriteLine("Application Start");
Application.Run(new Main());
TraceInfo.WriteLine("Application End");
}
}
else
{
Application.Run(new Main());
}
}
private static IOrderedEnumerable <OverlayData.RaceEvent> GetInterestingRaceEvents(IEnumerable <OverlayData.RaceEvent> raceEvents)
{
TraceInfo.WriteLine("Highlight Edits: Total Duration Target: {0}", HighlightVideoDuration);
double totalTime, incidentsRatio, restartsRatio, battlesRatio;
var firstAndLastLapRaceEvents = GetAllFirstAndLastLapEvents(raceEvents, out totalTime);
var incidentRaceEvents = GetAllRaceEvents(raceEvents, InterestState.Incident, 1.8, 0, out incidentsRatio);
var restartRaceEvents = GetAllRaceEvents(raceEvents, InterestState.Restart, 1.0, 0, out restartsRatio);
var battleRaceEvents = GetAllRaceEvents(raceEvents, InterestState.Battle, 1.4, 15, out battlesRatio);
battleRaceEvents = NormaliseBattleEvents(battleRaceEvents, Settings.Default.BattleStickyPeriod.TotalSeconds);
var totalRatio = incidentsRatio + restartsRatio + battlesRatio;
var incidentPercentage = incidentsRatio / totalRatio;
var restartPercentage = restartsRatio / totalRatio;
var battlePercentage = battlesRatio / totalRatio;
var incidentsEdited = ExtractEditedEvents(totalTime, incidentPercentage, incidentRaceEvents, InterestState.Incident, byPosition: true);
var restartsEdited = ExtractEditedEvents(totalTime, restartPercentage, restartRaceEvents, InterestState.Restart);
var battlessEdited = ExtractEditedEvents(totalTime, battlePercentage, battleRaceEvents, InterestState.Battle);
var editedEvents = firstAndLastLapRaceEvents.Concat(incidentsEdited).Concat(restartsEdited).Concat(battlessEdited).OrderBy(re => re.StartTime);
TraceInfo.WriteLine("Highlight Edits: Expected duration of highlight video: {0}", editedEvents.Sum(re => re.Duration).Seconds());
return(editedEvents);
}
void TranscodeVideoTest(string filename)
{
using (MFSystem.Start())
{
var details = VideoAttributes.TestFor(filename);
TraceInfo.WriteLine("Frame Rate: {0}, Frame Size: {1}x{2}, Video: {3} @ {4}Mbs, Audio: {5}, {6}Khz @ {7}Kbs, ".F
(details.FrameRate,
details.FrameSize.Width,
details.FrameSize.Height,
details.VideoEncoding,
details.BitRate == 0 ? "-- " : details.BitRate.ToString(),
details.AudioEncoding,
details.AudioSamplesPerSecond / 1000,
details.AudioAverageBytesPerSecond / 1000));
TraceInfo.WriteLine("Begining video re-encoding.");
details.Transcoder.ProcessVideo((readers, saveToSink) =>
{
readers.First().SourceReader.Samples(AVOperations.FadeIn(saveToSink));
});
TraceInfo.WriteLine("Video converted. Review the video file {0} to confirm it looks OK.", details.Transcoder.DestinationFile);
TraceInfo.WriteLine("Success!");
}
}
private void LogTrace(string prefix, TraceInfo info)
{
var sb = new StringBuilder();
if (!string.IsNullOrWhiteSpace(prefix))
{
sb.Append($"{prefix}: ");
}
sb.AppendLine(info.Message);
if (info is HttpTraceInfo httpInfo)
{
if (httpInfo.Url != null)
{
sb.AppendLine($"Url: {httpInfo.Url}");
}
if (httpInfo.StatusCode.HasValue)
{
sb.AppendLine($"Status: {httpInfo.StatusCode.Value}");
}
}
foreach (var keyValuePair in info.Values)
{
sb.AppendLine($"{keyValuePair.Key}: {keyValuePair.Value}");
}
_logger.LogDebug(sb.ToString());
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
// add trace log for debug and performance tuning
if ((request.Headers).MessageId.IsGuid)
{
ServiceStopWatch = Stopwatch.StartNew();
Guid messageId;
(request.Headers).MessageId.TryGetGuid(out messageId);
// retrieve sessionid in message header, then remove it
string sessionId = string.Empty;
if (OperationContext.Current.IncomingMessageHeaders.FindHeader("sessionid", "ns") >= 0)
{
sessionId = OperationContext.Current.IncomingMessageHeaders.GetHeader<string>("sessionid", "ns");
OperationContext.Current.IncomingMessageHeaders.RemoveAt(OperationContext.Current.IncomingMessageHeaders.FindHeader("sessionid", "ns"));
}
CurrentTraceInfo = new TraceInfo()
{
SessionId = sessionId,
TraceType = TraceType.WcfActionServerCall,
TraceName = request.Headers.Action,
TraceUniqueId = messageId.ToString()
};
TraceLogger.Instance.TraceServiceStart(CurrentTraceInfo, false);
}
return null;
}
public void Process(DataSample data, TimeSpan relativeTime)
{
var camDriver = CreateCamDriver(data, relativeTime);
if (camDriver != null)
{
if (lastCamDriver == null ||
lastCamDriver.UserName != camDriver.CurrentDriver.UserName ||
lastCamDriver.Position != camDriver.CurrentDriver.Position)
{
var position = camDriver.CurrentDriver.Position != null?camDriver.CurrentDriver.Position.Value.ToString() : "";
var indicator = camDriver.CurrentDriver.Position != null?camDriver.CurrentDriver.Position.Value.Ordinal() : "";
TraceInfo.WriteLine("{0} Camera on {1} {2} in position {3}{4}",
data.Telemetry.SessionTimeSpan,
camDriver.CurrentDriver.UserName,
camDriver.CurrentDriver.CarNumber,
position, indicator);
lastCamDriver = camDriver.CurrentDriver;
//add camDriver to list only if either drivername or position has changed
overlayData.CamDrivers.Add(camDriver);
}
}
}
private void LogTraceInfo(TraceInfo info)
{
if (info.TraceInfoStep == TraceInfoStep.BeforeExecute)
{
Debug.WriteLine(info.SqlText);
Output?.WriteLine(info.SqlText);
}
}
private void dgTrace_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
m_TraceInfo = dgTrace.SelectedItem as TraceInfo;
if (m_TraceInfo != null)
{
txtName.Text = m_TraceInfo.Name;
}
}
public override void OnSuccess(MethodExecutionArgs args)
{
base.OnSuccess(args);
_stopwatch.Stop();
TraceInfo traceinfo = new TraceInfo(_methodFullName, args.Arguments.ToArray());
Logger.Debug(string.Format("{0} invoke ends in {1}ms", traceinfo.Parameters[0], _stopwatch.Elapsed.Milliseconds));
_traceManager.TraceFinish(traceinfo, args.ReturnValue, _stopwatch.Elapsed);
}
public override void OnEntry(MethodExecutionArgs args)
{
_stopwatch.Restart();
TraceInfo traceInfo = new TraceInfo(_methodFullName, args.Arguments.ToArray());
_traceManager.TraceStart(traceInfo);
Logger.Debug(string.Format("{0} invoked.", traceInfo.Parameters[0]));
base.OnEntry(args);
}
public override void OnException(MethodExecutionArgs args)
{
_stopwatch.Stop();
TraceInfo traceinfo = new TraceInfo(_methodFullName, args.Arguments.ToArray());
_traceManager.TraceException(traceinfo, args.Exception, _stopwatch.Elapsed);
Logger.Error(string.Format("{0} invoke exception {1} in {2}ms", traceinfo.Parameters[0], args.Exception, _stopwatch.Elapsed.Milliseconds));
base.OnException(args);
}
public static void CreateNewTrace()
{
lock (_synclock)
{
CurrentTrace = new TraceInfo();
_traces.Add(CurrentTrace);
}
}
public static void CreateNewTrace()
{
lock (_synclock)
{
CurrentTrace = new TraceInfo();
_traces.Add(CurrentTrace);
}
}
void AddIncident(Incident incident)
{
incidents.Add(incident);
TraceInfo.WriteLine("Noting incident for driver {0} starting on lap {1} from {2}",
incident.Car.UserName,
incident.LapNumber,
incident.StartSessionTime,
incident.EndSessionTime);
}
private void button1_Click(object sender, EventArgs e)
{
Settings.Default.SendUsageData = this.sendUsageData.Checked;
Settings.Default.Save();
TraceInfo.WriteLine(Settings.Default.SendUsageData ? "User has accepted usage data submission" : "user has declined usage data submission");
this.Close();
}
static List <OverlayData.RaceEvent> ExtractEditedEvents(
double totalTime,
double percentage,
List <OverlayData.RaceEvent> raceEvents,
InterestState interest,
bool byPosition = false)
{
TraceInfo.WriteLine("Extracting {0} from a total set of {1}", interest, raceEvents.Count);
if (raceEvents.Count <= 2)
{
return(raceEvents);
}
var duration = 0d;
var targetDuration = totalTime * percentage;
var orderedRaceEvents = raceEvents.OrderBy(r => r.StartTime).ToList();
var firstEvent = orderedRaceEvents.First();
var lastEvent = orderedRaceEvents.Last();
var searchRaceEvents = new List <_RaceEvent>();
searchRaceEvents.Add(new _RaceEvent {
RaceEvent = firstEvent, Level = 0
});
searchRaceEvents.Add(new _RaceEvent {
RaceEvent = lastEvent, Level = 0
});
var result = new List <OverlayData.RaceEvent>();
if (byPosition)
{
foreach (var p in raceEvents.OrderBy(r => r.Position).Select(r => r.Position).Distinct())
{
TraceInfo.WriteLine("Scanning for {0}s for position {1}", interest, p);
duration = ExtractUptoTargetDuration(raceEvents.Where(r => r.Position == p).ToList(), duration, targetDuration, firstEvent, lastEvent, searchRaceEvents, result);
}
}
else
{
TraceInfo.WriteLine("Scanning for {0}s", interest);
duration = ExtractUptoTargetDuration(raceEvents, duration, targetDuration, firstEvent, lastEvent, searchRaceEvents, result);
}
foreach (var r in result.OrderBy(x => x.StartTime))
{
TraceInfo.WriteLine("Highlight edit {0} @ position {4}: {1} - {2}, duration: {3}", r.Interest, r.StartTime.Seconds(), r.EndTime.Seconds(), r.Duration.Seconds(), r.Position);
}
TraceInfo.WriteLine("Highlight Edits: {0}. Target Duration: {1}, Percentage: {2:00}%, Resolved Duration: {3}",
interest.ToString(), targetDuration.Seconds(), (int)(percentage * 100), duration.Seconds());
return(result);
}
protected AbstractBackgroundTask(string taskName)
{
var name = taskName ?? GetType().Name;
m_workerThread = new Thread(new ThreadStart(WorkerThreadWrapper));
m_workerThread.Name = name + "Thread";
m_workerThread.IsBackground = true;
WaitHandle = new ManualResetEvent(false);
TraceInfo = new TraceInfo(new TraceSource(name));
}
void SwitchToIncident(DataSample data)
{
pitBoxStartTime = 0;
var incidentCar = nextIncident.Current.Car;
TraceInfo.WriteLine("{0} Showing incident with {1} starting from {2}", data.Telemetry.SessionTimeSpan, incidentCar.UserName, nextIncident.Current.StartSessionTime);
cameraControl.CameraOnDriver(incidentCar.CarNumberRaw, cameraControl.IncidentCameraNumber);
}
protected override void WriteTrace(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message, Guid? relatedActivityId, object[] data)
{
// Note: References stored, so info could be mutable,
// however (unlike InMemoryTraceListener) this class is only for testing,
// so should not be an issue.
var traceInfo = new TraceInfo()
{
EventCache = eventCache,
Source = source,
EventType = eventType,
Id = id,
Message = message,
RelatedActivityId = relatedActivityId,
Data = data
};
MethodCallInformation.Add(traceInfo);
}
public static string GetStackFrameInfo(StackFrame frame, TraceInfo traceInfo)
{
if (frame != null)
{
switch (traceInfo)
{
case TraceInfo.LineNumber:
return frame.GetFileLineNumber().ToString();
case TraceInfo.FileName:
return frame.GetFileName();
case TraceInfo.Method:
return frame.GetMethod().Name;
case TraceInfo.ColumnNumber:
return frame.GetFileColumnNumber().ToString();
case TraceInfo.Full:
return new StackTrace(frame).ToString();
}
}
return "Error: StackFrame==null";
}
public void TraceFunction(string name, IEnumerable<FunctionCallParameter> parameters, Action<TranslationCPU, uint, string, IEnumerable<object>> callback,
FunctionCallParameter? returnParameter = null, Action<TranslationCPU, uint, string, IEnumerable<object>> returnCallback = null)
{
if(registeredCallbacks.ContainsKey(name))
{
throw new RecoverableException("Function {0} is already being traced.".FormatWith(name));
}
cpu.Log(LogLevel.Info, "Going to trace function '{0}'.", name);
Symbol symbol;
try
{
var address = cpu.Bus.GetSymbolAddress(name);
symbol = cpu.Bus.Lookup.GetSymbolByAddress(address);
}
catch(RecoverableException)
{
cpu.Log(LogLevel.Warning, "Symbol {0} not found, exiting.", name);
throw;
}
var traceInfo = new TraceInfo();
traceInfo.Begin = symbol.Start;
traceInfo.BeginCallback = (pc) => EvaluateTraceCallback(pc, name, parameters, callback);
cpu.AddHook(traceInfo.Begin, traceInfo.BeginCallback);
if(returnCallback != null && returnParameter.HasValue)
{
traceInfo.HasEnd = true;
traceInfo.End = (uint)(symbol.End - (symbol.IsThumbSymbol ? 2 : 4));
traceInfo.EndCallback = (pc) => EvaluateTraceCallback(pc, name, new[] { returnParameter.Value }, returnCallback);
cpu.Log(LogLevel.Debug, "Address is @ 0x{0:X}, end is @ 0x{1:X}.", traceInfo.Begin, traceInfo.End);
cpu.AddHook(traceInfo.End, traceInfo.EndCallback);
}
else
{
cpu.Log(LogLevel.Debug, "Address is @ 0x{0:X}, end is not traced.", traceInfo.Begin);
}
registeredCallbacks[name] = traceInfo;
}
override public void update(float dt)
{
if (pursueCountDown >= 0)
{
pursueCountDown -= dt;
attackVector = new Vector2(owner.hitBox.Center.X - target.hitBox.Center.X, owner.hitBox.Center.Y - target.hitBox.Center.Y);
attackVector.Normalize();
attackVector *= owner.reach;
attackVector.X += target.hitBox.Center.X;
attackVector.Y += target.hitBox.Center.Y;
double distance = Math.Sqrt(Math.Pow(attackVector.X - owner.hitBox.Center.X, 2) + Math.Pow(attackVector.Y - owner.hitBox.Center.Y, 2));
if (distance > owner.reach)
{
attackPos = new Point((int)attackVector.X, (int)attackVector.Y);
movement = new Vector2((float)(attackPos.X - owner.hitBox.Center.X), (float)(attackPos.Y - owner.hitBox.Center.Y));
movement.Normalize();
movement *= owner.maxSpeed;
owner.velocity.X = movement.X;
owner.velocity.Y = movement.Y;
owner.isWalking = true;
owner.setGaze(attackPos);
}
else
{
if (attackCoolDown <= 0)
{
owner.setGaze(target.hitBox.Center);
owner.Light_Attack();
attackCoolDown = (float)(.5f);
}
else
{
attackCoolDown -= dt;
}
}
}
else
{
elapsed = 0;
traceInfo = owner.world.traceWorld(owner.hitBox.Center, target.hitBox.Center);
if (traceInfo.hitWorld)
{
Pursue pursue = new Pursue(ownerList, owner, target);
ownerList.pushFront(pursue);
//onEnd();
}
else
pursueCountDown = 2.5f;
}
}
/// <summary>
/// This function gets the tracing information from the application configuration file
/// </summary>
/// <returns>TraceInfo read from the application configuration file</returns>
#endregion
private static TraceInfo GetTraceInfoFromAppConfig()
{
TraceInfo traceInfo = new TraceInfo();
traceInfo.IsTracingEnabled = (bool)AppConfigHelper.GetValueFromConfig
(LoggingConstants.KEY_TRACING_ENABLED, typeof(bool), traceInfo.IsTracingEnabled);
traceInfo.FileSizeInMB =(float)AppConfigHelper.GetValueFromConfig
(LoggingConstants.KEY_TRACE_FILE_SIZE, typeof(float), traceInfo.FileSizeInMB);
return traceInfo;
}
/// <summary>
/// Static Constructor
/// </summary>
#endregion
static OMETrace()
{
m_TraceInfo = GetTraceInfoFromAppConfig();
}
