protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var logCollector = new LogCollector();
string outputTemplate = "[{Timestamp:HH:mm:ss} {Level:u3}] <{SourceContext}> {Message:lj}{NewLine}{Exception}";
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(outputTemplate: outputTemplate)
.WriteTo.Debug(outputTemplate: outputTemplate)
.WriteTo.File(new RenderedCompactJsonFormatter(), "log.json")
.WriteTo.Sink(logCollector)
.CreateLogger();
var log = Log.ForContext <App>();
log.Information("Cirilla version " + Assembly.GetExecutingAssembly().GetName().Version);
log.Information("Cirilla.Core version " + Assembly.GetAssembly(typeof(Core.Models.GMD))?.GetName().Version ?? "(not found)");
MainWindow = new MainWindow
{
DataContext = new MainWindowViewModel(new FrameworkService(), logCollector)
};
MainWindow.Show();
}
public void TestKillHostingProcess()
{
using (var logCollector = new LogCollector("SharpRemote", Level.Info, Level.Warn, Level.Error, Level.Fatal))
{
int?pid;
using (var silo = new SharpRemote.Hosting.OutOfProcessSilo())
{
silo.Start();
pid = silo.HostProcessId;
var process = Process.GetProcessById(pid.Value);
process.Kill();
Thread.Sleep(TimeSpan.FromMilliseconds(100));
}
var expectedMessage = string.Format("Host '{0}' (PID: {1}) exited unexpectedly with error code -1",
ProcessWatchdog.SharpRemoteHost,
pid);
var @event = logCollector.Events.FirstOrDefault(x => x.RenderedMessage.Contains(expectedMessage));
@event.Should().NotBeNull("because a message should've been logged that the process exited unexpectedly");
@event.Level.Should().Be(Level.Error);
logCollector.Events.Should()
.NotContain(x => x.RenderedMessage.Contains("Caught exception while disposing "));
}
}
public void FilterRemoveIDTest()
{
LogItem message = new LogItem(category, level, msg, ids, GetException());
var qThread = new Mock <IQueued <LogItem> >(MockBehavior.Strict);
var writer = new Mock <ILogWriter>(MockBehavior.Strict);
writer
.Setup(s => s.Write(It.IsAny <LogItem>()));
writer
.Setup(s => s.GetTimeout())
.Returns(timeout);
qThread
.Setup(s => s.SetTimeout(It.IsAny <int>()));
LogCollector target = new LogCollector(qThread.Object, writer.Object);
target.FilterAddID(1);
target.FilterAddID(3);
qThread.Raise(s => s.OnReceive += null, message);
writer
.Verify(s => s.Write(It.Is <LogItem>(a => a.Equals(message))), Times.Once());
target.FilterRemoveID(3);
qThread.Raise(s => s.OnReceive += null, message);
writer
.Verify(s => s.Write(It.Is <LogItem>(a => a.Equals(message))), Times.Once());
}
public void TestFailureDetection10()
{
using (var handle1 = new ManualResetEvent(false))
using (var handle2 = new ManualResetEvent(false))
{
Failure? failure1 = null;
Failure? failure2 = null;
Resolution?resolution = null;
var handler = new Mock <IFailureHandler>();
handler.Setup(x => x.OnFailure(It.IsAny <Failure>()))
.Callback((Failure f) =>
{
failure1 = f;
handle1.Set();
});
handler.Setup(x => x.OnResolutionFinished(It.IsAny <Failure>(), It.IsAny <Decision>(), It.IsAny <Resolution>()))
.Callback((Failure f, Decision d, Resolution r) =>
{
failure2 = f;
resolution = r;
handle2.Set();
});
var settings = new FailureSettings
{
HeartbeatSettings =
{
ReportSkippedHeartbeatsAsFailureWithDebuggerAttached = true,
Interval = TimeSpan.FromMilliseconds(100),
SkippedHeartbeatThreshold = 4
}
};
using (var log = new LogCollector("SharpRemote", Level.Info, Level.Warn, Level.Error))
using (var silo = new SharpRemote.Hosting.OutOfProcessSilo(failureSettings: settings, failureHandler: handler.Object))
{
silo.Start();
int?pid = silo.HostProcessId;
pid.Should().HaveValue();
Process hostProcess = Process.GetProcessById(pid.Value);
hostProcess.Kill();
WaitHandle.WaitAll(new[] { handle1, handle2 }, TimeSpan.FromSeconds(2))
.Should().BeTrue("Because the failure should've been detected as well as handled");
failure1.Should().Be(Failure.HostProcessExited);
failure2.Should().Be(failure1);
resolution.Should().Be(Resolution.Stopped);
var expectedMessage = string.Format("Host '{0}' (PID: {1}) exited unexpectedly with error code -1",
ProcessWatchdog.SharpRemoteHost,
pid.Value);
log.Events.Should().Contain(x => x.Level == Level.Error &&
x.RenderedMessage.Contains(expectedMessage));
}
}
}
public LogStore(ILogRepository repository,
ILogger <LogStore> log, IClock clock)
{
this.repository = repository;
this.log = log;
collector = new LogCollector(repository, clock, 10, 3000);
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
const string key = "loglevel";
if (actionContext.ActionArguments.ContainsKey(key))
{
var loglevel = (int)actionContext.ActionArguments[key];
LogCollector logger = new LogCollector(loglevel);
actionContext.ActionArguments["logger"] = logger;
}
base.OnActionExecuting(actionContext);
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
const string key = "loglevel";
if (actionContext.ControllerContext.RouteData.Values.ContainsKey(key))
{
var loglevel = int.Parse(actionContext.ControllerContext.RouteData.Values[key].ToString());
LogCollector logger = new LogCollector(loglevel);
actionContext.ActionArguments["logger"] = logger;
}
base.OnActionExecuting(actionContext);
}
public void TestDispose4()
{
using (var logCollector = new LogCollector("SharpRemote", Level.Info,
Level.Warn, Level.Error, Level.Fatal))
{
var silo = new SharpRemote.Hosting.OutOfProcessSilo();
new Action(silo.Dispose)
.ShouldNotThrow();
logCollector.Log.Should().NotContain("Caught exception while disposing");
logCollector.Log.Should().NotContain("SharpRemote.NotConnectedException");
}
}
public void OnLogUploaderFlyoutOpenChanged()
{
if (LogUploaderFlyoutOpen)
{
LogsAvailableForUpload.ReplaceAll(LogCollector.GetLogsList());
SelectedLogForUpload = LogsAvailableForUpload.FirstOrDefault();
}
else
{
LogsAvailableForUpload.ClearEx();
SelectedLogForUpload = null;
}
}
public void TestStartStop4()
{
using (var collector = new LogCollector("SharpRemote", Level.Warn, Level.Error, Level.Fatal))
using (var silo = new SharpRemote.Hosting.OutOfProcessSilo())
{
silo.Start();
silo.Stop();
Thread.Sleep(TimeSpan.FromSeconds(1));
collector.Events.Should().NotContain(x => x.RenderedMessage.Contains("exited unexpectedly"));
collector.Events.Should().NotContain(x => x.Level >= Level.Warn);
}
}
private void Report()
{
var str = LogCollector.GetLogString();
var path = Application.temporaryCachePath + "/logs.txt";
File.WriteAllText(path, str);
#if STENCIL_NATIVE_SHARE
if (!Application.isEditor)
{
new NativeShare()
.AddFile(path, "text/plain")
.Share();
}
#endif
Debug.Log($"Share: {path}");
}
public IActionResult Test()
{
var model = InitializeModel(true);
// Test HTTP Data Collector API
var collector = new LogCollector(_settings.WorkspaceId, _settings.WorkspaceKey);
var collectorConfigurationValid = collector.WriteTestData();
// Test Log Search API
var searcher = new LogSearcher(_settings.TenantId, _settings.ApplicationId, _settings.ApplicationKey,
_settings.SubscriptionId, _settings.ResourceGroup, _settings.WorkspaceId, _settings.WorkspaceName);
var searcherConfigurationValid = searcher.SearchTestRecords();
model.IsValid = collectorConfigurationValid && searcherConfigurationValid;
return(View("Index", model));
}
private void handleCommandLine()
{
string[] args = Environment.GetCommandLineArgs();
if (args.Length > 1)
{
var result = Parser.Default.ParseArguments <Options>(args);
if (result is Parsed <Options> parsedCommandLineArgs)
{
//Parsing completed
if (parsedCommandLineArgs.Value.UpdateBoot)
{
//Update unpacked and process was run.
// Exit the process as we have completed the extraction process for single file .net core
Application.Current.Dispatcher.Invoke(Application.Current.Shutdown);
return;
}
if (parsedCommandLineArgs.Value.UpdateRebootDest != null)
{
Log.Logger = LogCollector.CreateLogger();
Log.Information(LogCollector.SessionStartString);
copyAndRebootUpdate(parsedCommandLineArgs.Value.UpdateRebootDest);
return;
}
// Set passthroughs
if (parsedCommandLineArgs.Value.PassthroughME1Path != null)
{
StartupUIController.PassthroughME1Path = parsedCommandLineArgs.Value.PassthroughME1Path;
}
if (parsedCommandLineArgs.Value.PassthroughME2Path != null)
{
StartupUIController.PassthroughME2Path = parsedCommandLineArgs.Value.PassthroughME2Path;
}
if (parsedCommandLineArgs.Value.PassthroughME3Path != null)
{
StartupUIController.PassthroughME3Path = parsedCommandLineArgs.Value.PassthroughME3Path;
}
}
else
{
Log.Error("Could not parse command line arguments! Args: " + string.Join(' ', args));
}
}
}
public static void CoreFunc()
{
while (true)
{
var logs = LogCollector.Fetch();
LogWriter.Flush(logs);
if (LogCollector.Count() >= 1000)
{
Thread.Sleep(1000);
}
else
{
Thread.Sleep(30000); //DEBUG:set to 1000 when debuging so that you can get the result immediately.
}
}
}
protected override void Awake()
{
base.Awake();
Log.SetLogger(new LoggerImpl());
Container.BindSingleton <ILogCollectionService, LogCollectionService>();
Container.BindSingleton <ILogCallbackRegistrar, DefaultLogCallbackRegistrar>();
if (File.Exists(LogFilePath))
{
File.Delete(LogFilePath);
}
var logCollector = new LogCollector();
logCollector.LogFilePath = LogFilePath;
m_LogCollector = logCollector;
}
private static void initAppCenter()
{
#if !DEBUG
if (APIKeys.HasAppCenterKey && !telemetryStarted)
{
Microsoft.AppCenter.Crashes.Crashes.GetErrorAttachments = (ErrorReport report) =>
{
var attachments = new List <ErrorAttachmentLog>();
// Attach some text.
string errorMessage = "ALOT Installer has crashed! This is the exception that caused the crash:\n" + report.StackTrace;
MERLog.Fatal(errorMessage);
Log.Error("Note that this exception may appear to occur in a follow up boot due to how appcenter works");
string log = LogCollector.CollectLatestLog(false);
if (log.Length < 1024 * 1024 * 7)
{
attachments.Add(ErrorAttachmentLog.AttachmentWithText(log, "crashlog.txt"));
}
else
{
//Compress log
var compressedLog = LZMA.CompressToLZMAFile(Encoding.UTF8.GetBytes(log));
attachments.Add(ErrorAttachmentLog.AttachmentWithBinary(compressedLog, "crashlog.txt.lzma", "application/x-lzma"));
}
// Attach binary data.
//var fakeImage = System.Text.Encoding.Default.GetBytes("Fake image");
//ErrorAttachmentLog binaryLog = ErrorAttachmentLog.AttachmentWithBinary(fakeImage, "ic_launcher.jpeg", "image/jpeg");
return(attachments);
};
AppCenter.Start(APIKeys.AppCenterKey, typeof(Analytics), typeof(Crashes));
}
#else
if (!APIKeys.HasAppCenterKey)
{
Debug.WriteLine(" >>> This build is missing an API key for AppCenter!");
}
else
{
Debug.WriteLine("This build has an API key for AppCenter");
}
#endif
telemetryStarted = true;
}
public async Task <IActionResult> Seed(SeedViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var recordString = RecordFactory.GenerateTraceRecords(
model.VehicleId,
model.TotalTransactions,
model.BadTransactions.HasValue ? model.BadTransactions.Value : 0);
var collector = new LogCollector(_settings.WorkspaceId, _settings.WorkspaceKey);
model.IsSuccess = await collector.Collect(Constants.RecordTypeTrace, recordString);
model.IsSeeded = true;
return(View("Index", model));
}
public override void OnFrameworkInitializationCompleted()
{
var logCollector = new LogCollector();
string outputTemplate = "[{Timestamp:HH:mm:ss} {Level:u3}] <{SourceContext}> {Message:lj}{NewLine}{Exception}";
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(outputTemplate: outputTemplate)
.WriteTo.Debug(outputTemplate: outputTemplate)
.WriteTo.File(new RenderedCompactJsonFormatter(), "log.json")
.WriteTo.Sink(logCollector)
.CreateLogger();
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
{
desktop.MainWindow = new MainWindow();
desktop.MainWindow.DataContext = new MainWindowViewModel(desktop.MainWindow);
}
base.OnFrameworkInitializationCompleted();
}
public void ShutDownTest()
{
LogItem message = new LogItem(category, level, msg, ids, GetException());
var qThread = new Mock <IQueued <LogItem> >(MockBehavior.Strict);
var writer = new Mock <ILogWriter>(MockBehavior.Strict);
qThread
.Setup(s => s.Terminate());
writer
.Setup(s => s.GetTimeout())
.Returns(timeout);
qThread
.Setup(s => s.SetTimeout(It.IsAny <int>()));
LogCollector target = new LogCollector(qThread.Object, writer.Object);
target.ShutDown();
qThread
.Verify(s => s.Terminate(), Times.Once());
}
public void TestLogSystemSettings()
{
using (var appender = new LogCollector("SharpRemote.SocketEndPoint", Level.Info))
{
var timedWaitDelay = SocketSettings.TcpTimedWaitDelay;
var ipv4TcpRange = SocketSettings.IPv4.Tcp.EphemeralPortRange;
var ipv6TcpRange = SocketSettings.IPv6.Tcp.EphemeralPortRange;
SocketEndPoint.LogSystemSettings();
var events = appender.Events;
events.Should().HaveCount(1);
var message = events[0].RenderedMessage;
Console.WriteLine(message);
message.Should().Contain(string.Format("TcpTimedWaitDelay: {0} seconds", timedWaitDelay.TotalSeconds));
message.Should().Contain(string.Format("DynamicPort.IPv4.TCP.StartPort: {0}", ipv4TcpRange.StartPort));
message.Should().Contain(string.Format("DynamicPort.IPv4.TCP.NumberOfPorts: {0}", ipv4TcpRange.NumberOfPorts));
message.Should().Contain(string.Format("DynamicPort.IPv6.TCP.StartPort: {0}", ipv6TcpRange.StartPort));
message.Should().Contain(string.Format("DynamicPort.IPv6.TCP.NumberOfPorts: {0}", ipv6TcpRange.NumberOfPorts));
}
}
public void TestUseByReferenceTypeAfterRestart()
{
using (var logCollector = new LogCollector(new [] { "SharpRemote.EndPoints.ProxyStorage" }, new [] { Level.Debug }))
using (var silo = new SharpRemote.Hosting.OutOfProcessSilo(failureHandler: new RestartOnFailureStrategy()))
{
logCollector.AutoPrint(TestContext.Progress);
silo.Start();
var factory = silo.CreateGrain <IAdvancedFactory>(typeof(AdvancedFactory));
var proxyToByReferenceClass = factory.Create(typeof(ByReferenceClass));
var id = GetIdOf(proxyToByReferenceClass);
Console.WriteLine("ObjectId: {0}", id);
RestartHost(silo);
factory = silo.CreateGrain <IAdvancedFactory>(typeof(AdvancedFactory));
var proxyToObject = factory.Create(typeof(Handle));
var otherId = GetIdOf(proxyToObject);
Console.WriteLine("ObjectId: {0}", otherId);
}
}
public MainPage()
{
this.InitializeComponent();
environment = new DefaultEnvironment(new Map(1, 1)); // Did not load the map yet...
EnvironmentTickSource = new EnvironmentTickSource(environment, SimulationCycleLengthMs);
var robot = new LineAndWallDetectorRobot(environment);
Brain = new WallsAndLinesDemoBrain(robot);
var collector = new LogCollector(Brain, this.LogViewModel);
this.RobotViewModel = new RobotViewModel(robot);
RobotImage.Source = RobotViewModel.Image;
this.MapViewModel = new MapViewModel();
FollowLineCommand = new CommandButtonCommand(Brain, new FollowingLineState(5.0));
FollowLeftWallCommand = new CommandButtonCommand(Brain, new FollowingWallOnLeftState());
FollowRightWallCommand = new CommandButtonCommand(Brain, new FollowingWallOnRightState());
}
public void SendTest()
{
LogItem message = new LogItem(category, level, msg, ids, GetException());
var qThread = new Mock <IQueued <LogItem> >(MockBehavior.Strict);
var writer = new Mock <ILogWriter>(MockBehavior.Strict);
qThread
.Setup(s => s.Send(It.IsAny <LogItem>()));
writer
.Setup(s => s.GetTimeout())
.Returns(timeout);
qThread
.Setup(s => s.SetTimeout(It.IsAny <int>()));
LogCollector target = new LogCollector(qThread.Object, writer.Object);
qThread
.Verify(s => s.SetTimeout(It.Is <int>(a => a == timeout)));
target.Send(message);
qThread
.Verify(s => s.Send(It.Is <LogItem>(i => i.Equals(message))), Times.Once());
}
public void GetLog(WebData webData, LogLevel?minLevel = null)
{
LogLevel level = minLevel ?? LogLevel.Verbose;
webData.Result.AddMessage(webData.Method, "Retrieved logging datasets...");
int i = (int)(DateTime.Now.TimeOfDay.Ticks / TimeSpan.TicksPerMillisecond);
var items = new List <LogEntry>();
foreach (var msg in LogCollector.ToArray().Reverse())
{
if (msg.Level > level)
{
continue;
}
if (msg.Exception == null || 0 == LogCollector.ExceptionMode)
{
items.Add(new LogEntry()
{
ID = i--,
Level = msg.Level,
Content = msg.Content,
Source = msg.Source,
DateTime = msg.DateTime,
});
continue;
}
//log stacktrace
bool stackTrace = (0 != (LogCollector.ExceptionMode & LogExceptionMode.StackTrace));
var exceptionMessage = msg.Exception.ToXT(stackTrace);
//with same level ?
if (0 != (LogCollector.ExceptionMode & LogExceptionMode.SameLevel))
{
items.Add(new LogEntry()
{
ID = i--,
Level = msg.Level,
Content = msg.Content + new XT("\n") + exceptionMessage,
Source = msg.Source,
DateTime = msg.DateTime,
});
}
else
{
//two different messages
items.Add(new LogEntry()
{
ID = i--,
Level = msg.Level,
Content = msg.Content,
Source = msg.Source,
DateTime = msg.DateTime,
});
if (level >= LogLevel.Verbose)
{
items.Add(new LogEntry()
{
ID = i--,
Level = LogLevel.Verbose,
Content = exceptionMessage,
Source = msg.Source,
DateTime = msg.DateTime,
});
}
}
}
webData.Result.AddStructs(items);
}
public override IEnumerable<SvnRevision> Log (Repository repo, FilePath path, SvnRevision revStart, SvnRevision revEnd)
{
if (path == FilePath.Null)
throw new ArgumentNullException ();
LibSvnClient.Rev revisionStart = (LibSvnClient.Rev) revStart;
LibSvnClient.Rev revisionEnd = (LibSvnClient.Rev) revEnd;
List<SvnRevision> ret = new List<SvnRevision> ();
IntPtr strptr = IntPtr.Zero;
IntPtr localpool = IntPtr.Zero;
try {
localpool = TryStartOperation (null);
IntPtr array = apr.array_make (localpool, 0, IntPtr.Size);
IntPtr first = apr.array_push (array);
string pathorurl = NormalizePath (path, localpool);
strptr = Marshal.StringToHGlobalAnsi (pathorurl);
Marshal.WriteIntPtr (first, strptr);
LogCollector collector = new LogCollector ((SubversionRepository)repo, ret, ctx);
CheckError (svn.client_log (array, ref revisionStart, ref revisionEnd, true, false,
collector.Func,
IntPtr.Zero, ctx, localpool));
} finally {
if (strptr != IntPtr.Zero)
Marshal.FreeHGlobal (strptr);
TryEndOperation (localpool);
}
return ret;
}
public LogStore(ILogRepository repository, IClock clock)
{
this.repository = repository;
collector = new LogCollector(repository, clock, 10, 3000);
}
private void StartLogUpload(bool isPreviousCrashLog = false)
{
UploadingLog = true;
TopText = M3L.GetString(M3L.string_collectingLogInformation);
NamedBackgroundWorker bw = new NamedBackgroundWorker(@"LogUpload");
bw.DoWork += (a, b) =>
{
void updateStatusCallback(string status)
{
CollectionStatusMessage = status;
}
StringBuilder logUploadText = new StringBuilder();
if (SelectedDiagnosticTarget != null && SelectedDiagnosticTarget.Game > Mod.MEGame.Unknown)
{
Debug.WriteLine(@"Selected game target: " + SelectedDiagnosticTarget.TargetPath);
logUploadText.Append("[MODE]diagnostics\n");
logUploadText.Append(LogCollector.PerformDiagnostic(SelectedDiagnosticTarget, TextureCheck /*&& SelectedDiagnosticTarget.TextureModded*/, updateStatusCallback));
logUploadText.Append("\n");
}
if (SelectedLog != null && SelectedLog.Selectable)
{
Debug.WriteLine(@"Selected log: " + SelectedLog.filepath);
logUploadText.Append("[MODE]logs\n");
logUploadText.AppendLine(LogCollector.CollectLogs(SelectedLog.filepath));
logUploadText.Append("\n");
}
var logtext = logUploadText.ToString();
if (logtext != null)
{
CollectionStatusMessage = "Compressing for upload";
var lzmalog = SevenZipHelper.LZMA.CompressToLZMAFile(Encoding.UTF8.GetBytes(logtext));
try
{
//this doesn't need to technically be async, but library doesn't have non-async method.
//DEBUG ONLY!!!
CollectionStatusMessage = "Uploading to ME3Tweaks";
#if DEBUG
string responseString = @"https://me3tweaks.com/modmanager/logservice/logupload2.php".PostUrlEncodedAsync(new { LogData = Convert.ToBase64String(lzmalog), ModManagerVersion = App.BuildNumber, CrashLog = isPreviousCrashLog }).ReceiveString().Result;
#else
string responseString = @"https://me3tweaks.com/modmanager/logservice/logupload.php".PostUrlEncodedAsync(new { LogData = Convert.ToBase64String(lzmalog), ModManagerVersion = App.BuildNumber, CrashLog = isPreviousCrashLog }).ReceiveString().Result;
#endif
Uri uriResult;
bool result = Uri.TryCreate(responseString, UriKind.Absolute, out uriResult) &&
(uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
if (result)
{
//should be valid URL.
//diagnosticsWorker.ReportProgress(0, new ThreadCommand(SET_DIAGTASK_ICON_GREEN, Image_Upload));
//e.Result = responseString;
Log.Information(@"Result from server for log upload: " + responseString);
b.Result = responseString;
return;
}
else
{
Log.Error(@"Error uploading log. The server responded with: " + responseString);
b.Result = M3L.GetString(M3L.string_interp_serverRejectedTheUpload, responseString);
}
}
catch (AggregateException e)
{
Exception ex = e.InnerException;
string exmessage = ex.Message;
b.Result = M3L.GetString(M3L.string_interp_logWasUnableToUpload, exmessage);
}
catch (FlurlHttpTimeoutException)
{
// FlurlHttpTimeoutException derives from FlurlHttpException; catch here only
// if you want to handle timeouts as a special case
Log.Error(@"Request timed out while uploading log.");
b.Result = M3L.GetString(M3L.string_interp_requestTimedOutUploading);
}
catch (Exception ex)
{
// ex.Message contains rich details, inclulding the URL, verb, response status,
// and request and response bodies (if available)
Log.Error(@"Handled error uploading log: " + App.FlattenException(ex));
string exmessage = ex.Message;
var index = exmessage.IndexOf(@"Request body:");
if (index > 0)
{
exmessage = exmessage.Substring(0, index);
}
b.Result = M3L.GetString(M3L.string_interp_logWasUnableToUpload, exmessage);
}
}
else
{
//Log pull failed
}
};
bw.RunWorkerCompleted += (a, b) =>
{
if (b.Result is string response)
{
if (response.StartsWith(@"http"))
{
Utilities.OpenWebpage(response);
}
else
{
OnClosing(DataEventArgs.Empty);
var res = M3L.ShowDialog(Window.GetWindow(this), response, M3L.GetString(M3L.string_logUploadFailed), MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
OnClosing(DataEventArgs.Empty);
};
bw.RunWorkerAsync();
}
public async Task Collect()
{
var collector = new LogCollector(new FileSystemOperations());
var testDevice = new TestDevice();
await collector.Collect(testDevice, "logs.zip");
}
public override IEnumerable<SvnRevision> Log (Repository repo, FilePath path, SvnRevision revStart, SvnRevision revEnd)
{
if (path == FilePath.Null)
throw new ArgumentNullException ();
LibSvnClient.Rev revisionStart = (LibSvnClient.Rev) revStart;
LibSvnClient.Rev revisionEnd = (LibSvnClient.Rev) revEnd;
List<SvnRevision> ret = new List<SvnRevision> ();
IntPtr localpool = newpool (pool);
IntPtr strptr = IntPtr.Zero;
try {
IntPtr array = apr.array_make (localpool, 0, IntPtr.Size);
IntPtr first = apr.array_push (array);
string pathorurl = NormalizePath (path, localpool);
strptr = Marshal.StringToHGlobalAnsi (pathorurl);
Marshal.WriteIntPtr (first, strptr);
LogCollector collector = new LogCollector (ret);
CheckError (svn.client_log (array, ref revisionStart, ref revisionEnd, 1, 0,
new LibSvnClient.svn_log_message_receiver_t (collector.Func),
IntPtr.Zero, ctx, localpool));
} finally {
if (strptr != IntPtr.Zero)
Marshal.FreeHGlobal (strptr);
apr.pool_destroy (localpool);
}
return ret;
}
private void StartLogUpload(bool isPreviousCrashLog = false)
{
UploadingLog = true;
TopText = M3L.GetString(M3L.string_collectingLogInformation);
NamedBackgroundWorker bw = new NamedBackgroundWorker(@"LogUpload");
bw.DoWork += (a, b) =>
{
string logUploadText = LogCollector.CollectLogs(SelectedLog.filepath);
using (var output = new MemoryStream())
{
var encoder = new LzmaEncodeStream(output);
using (var normalBytes = new MemoryStream(Encoding.UTF8.GetBytes(logUploadText)))
{
int bufSize = 24576, count;
var buf = new byte[bufSize];
while ((count = normalBytes.Read(buf, 0, bufSize)) > 0)
{
encoder.Write(buf, 0, count);
}
}
encoder.Close();
//Upload log to ME3Tweaks
var lzmalog = output.ToArray();
try
{
//this doesn't need to technically be async, but library doesn't have non-async method.
string responseString = @"https://me3tweaks.com/modmanager/logservice/logupload.php".PostUrlEncodedAsync(new { LogData = Convert.ToBase64String(lzmalog), ModManagerVersion = App.BuildNumber, CrashLog = isPreviousCrashLog }).ReceiveString().Result;
Uri uriResult;
bool result = Uri.TryCreate(responseString, UriKind.Absolute, out uriResult) &&
(uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
if (result)
{
//should be valid URL.
//diagnosticsWorker.ReportProgress(0, new ThreadCommand(SET_DIAGTASK_ICON_GREEN, Image_Upload));
//e.Result = responseString;
Log.Information(@"Result from server for log upload: " + responseString);
b.Result = responseString;
return;
}
else
{
Log.Error(@"Error uploading log. The server responded with: " + responseString);
b.Result = M3L.GetString(M3L.string_interp_serverRejectedTheUpload, responseString);
}
}
catch (AggregateException e)
{
Exception ex = e.InnerException;
string exmessage = ex.Message;
b.Result = M3L.GetString(M3L.string_interp_logWasUnableToUpload, exmessage);
}
catch (FlurlHttpTimeoutException)
{
// FlurlHttpTimeoutException derives from FlurlHttpException; catch here only
// if you want to handle timeouts as a special case
Log.Error(@"Request timed out while uploading log.");
b.Result = M3L.GetString(M3L.string_interp_requestTimedOutUploading);
}
catch (Exception ex)
{
// ex.Message contains rich details, inclulding the URL, verb, response status,
// and request and response bodies (if available)
Log.Error(@"Handled error uploading log: " + App.FlattenException(ex));
string exmessage = ex.Message;
var index = exmessage.IndexOf(@"Request body:");
if (index > 0)
{
exmessage = exmessage.Substring(0, index);
}
b.Result = M3L.GetString(M3L.string_interp_logWasUnableToUpload, exmessage);
}
}
};
bw.RunWorkerCompleted += (a, b) =>
{
if (b.Result is string response)
{
if (response.StartsWith(@"http"))
{
Utilities.OpenWebpage(response);
}
else
{
OnClosing(DataEventArgs.Empty);
var res = M3L.ShowDialog(Window.GetWindow(this), response, M3L.GetString(M3L.string_logUploadFailed), MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
OnClosing(DataEventArgs.Empty);
};
bw.RunWorkerAsync();
}
private async void CollectAndUploadLog()
{
var pd = await this.ShowProgressAsync("Uploading log", $"Please wait while the application log is uploaded to the ME3Tweaks Log Viewing Service.");
pd.SetIndeterminate();
NamedBackgroundWorker nbw = new NamedBackgroundWorker("DiagnosticsWorker");
nbw.DoWork += (a, b) =>
{
//ProgressIndeterminate = true;
//GameTarget target = GameChosen != null ? Locations.GetTarget(GameChosen.Value) : null;
StringBuilder logUploadText = new StringBuilder();
string logText = "";
//if (target != null)
//{
// logUploadText.Append("[MODE]diagnostics\n"); //do not localize
// logUploadText.Append(LogCollector.PerformDiagnostic(target, FullDiagChosen,
// x => DiagnosticStatusText = x,
// x =>
// {
// ProgressIndeterminate = false;
// ProgressValue = x;
// },
// () => ProgressIndeterminate = true));
// logUploadText.Append("\n"); //do not localize
//}
if (SelectedLogForUpload != null)
{
logUploadText.Append("[MODE]logs\n"); //do not localize
logUploadText.AppendLine(LogCollector.CollectLogs(SelectedLogForUpload.filepath));
logUploadText.Append("\n"); //do not localize
}
//DiagnosticStatusText = "Uploading to log viewing service";
//ProgressIndeterminate = true;
var response = LogUploader.UploadLog(logUploadText.ToString(), "https://me3tweaks.com/masseffect2randomizer/logservice/logupload");
if (response.uploaded)
{
var DiagnosticResultText = response.result;
if (response.result.StartsWith("http"))
{
Utilities.OpenWebPage(response.result);
}
}
if (!response.uploaded || QuickFixHelper.IsQuickFixEnabled(QuickFixHelper.QuickFixName.ForceSavingLogLocally))
{
// Upload failed.
var GeneratedLogPath = Path.Combine(LogCollector.LogDir, $"FailedLogUpload_{DateTime.Now.ToString("s").Replace(":", ".")}.txt");
File.WriteAllText(GeneratedLogPath, logUploadText.ToString());
}
//DiagnosticComplete = true;
//DiagnosticInProgress = false;
};
nbw.RunWorkerCompleted += async(sender, args) =>
{
CommandManager.InvalidateRequerySuggested();
LogUploaderFlyoutOpen = false;
await pd.CloseAsync();
};
//DiagnosticInProgress = true;
nbw.RunWorkerAsync();
}
public IList Log(string path, Rev revisionStart, Rev revisionEnd)
{
if (path == null) throw new ArgumentException();
ArrayList ret = new ArrayList();
IntPtr localpool = newpool(pool);
IntPtr strptr = IntPtr.Zero;
try {
IntPtr array = apr_array_make(localpool, 0, IntPtr.Size);
IntPtr first = apr_array_push(array);
strptr = Marshal.StringToHGlobalAnsi(path);
Marshal.WriteIntPtr(first, strptr);
LogCollector collector = new LogCollector(ret);
CheckError(svn_client_log (
array,
ref revisionStart, ref revisionEnd,
1,
0,
new svn_log_message_receiver_t(collector.Func),
IntPtr.Zero,
ctx, localpool));
} finally {
if (strptr != IntPtr.Zero)
Marshal.FreeHGlobal(strptr);
apr_pool_destroy(localpool);
}
return ret;
}
// Use this for initialization
void Start()
{
LogCollector.Init();
LogCollector.pInstance.ShowInUI();
StartCoroutine(GenerateLog());
}
