public void SetUp()
{
monitor = new Monitor();
commandEater = new CommandInteractionEater();
loggerBackend = new DummyLoggerBackend();
Logger.AddBackend(loggerBackend, "dummy");
}
public static void EnsureBackend()
{
if (instance == null)
{
instance = new LuceneLoggerBackend();
Logger.AddBackend(instance, LuceneLoggerBackendIdentifier);
}
}
private void InnerRun(string path, bool flushAfterEveryWrite)
{
if (Misc.AllocateFile(path, out var counter))
{
Logger.LogAs(null, LogLevel.Warning, "Previous log file detected and renamed to: {0}.{1}", path, counter);
}
Logger.AddBackend(new FileBackend(path, flushAfterEveryWrite), "file", true);
}
private void InnerRun(string path, bool flushAfterEveryWrite)
{
if (Logger.GetBackends().TryGetValue(BackendName, out var backend))
{
// We are explicitly removing existing backend to close
// file opened by it. When using the same path twice,
// this allows for the previous file to be moved by
// SequencedFilePath.
Logger.RemoveBackend(backend);
}
Logger.AddBackend(new FileBackend(path, flushAfterEveryWrite), BackendName, true);
}
private void InnerRun(string path, bool flushAfterEveryWrite)
{
var counter = 0;
var dstName = $"{path}.{counter}";
if (File.Exists(path))
{
while (File.Exists(dstName))
{
counter++;
dstName = $"{path}.{counter}";
}
File.Copy(path, dstName);
Logger.LogAs(null, LogLevel.Warning, "Previous log file detected and renamed to: {0}", dstName);
}
Logger.AddBackend(new FileBackend(path, flushAfterEveryWrite), "file", true);
}
public static void Run(Options options, Action <ObjectCreator.Context> beforeRun = null)
{
AppDomain.CurrentDomain.UnhandledException += (sender, e) => CrashHandler.HandleCrash((Exception)e.ExceptionObject);
if (options.Version)
{
Console.Out.WriteLine(EmulationManager.Instance.VersionString);
return;
}
if (!options.HideLog)
{
Logger.AddBackend(ConsoleBackend.Instance, "console");
}
else
{
Logger.AddBackend(new DummyLoggerBackend(), "dummy");
}
Logger.AddBackend(new MemoryBackend(), "memory");
Emulator.ShowAnalyzers = !options.HideAnalyzers;
XwtProvider xwt = null;
if (options.PidFile != null)
{
var pid = Process.GetCurrentProcess().Id;
File.WriteAllText(options.PidFile, pid.ToString());
}
if (!options.DisableXwt || options.RobotDebug)
{
xwt = XwtProvider.Create(new WindowedUserInterfaceProvider());
}
if (xwt == null && options.RobotFrameworkRemoteServerPort == -1 && !options.Console)
{
if (options.Port == -1)
{
options.Port = 1234;
}
if (!options.DisableXwt)
{
Logger.Log(LogLevel.Warning, "Couldn't start UI - falling back to telnet mode");
}
}
using (var context = ObjectCreator.Instance.OpenContext())
{
var monitor = new Antmicro.Renode.UserInterface.Monitor();
context.RegisterSurrogate(typeof(Antmicro.Renode.UserInterface.Monitor), monitor);
// we must initialize plugins AFTER registering monitor surrogate
// as some plugins might need it for construction
TypeManager.Instance.PluginManager.Init("CLI");
EmulationManager.Instance.ProgressMonitor.Handler = new CLIProgressMonitor();
var uartAnalyzerType = (xwt == null || options.RobotDebug) ? typeof(LoggingUartAnalyzer) : typeof(ConsoleWindowBackendAnalyzer);
var videoAnalyzerType = (xwt == null || options.RobotDebug) ? typeof(DummyVideoAnalyzer) : typeof(VideoAnalyzer);
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), uartAnalyzerType);
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(VideoBackend), videoAnalyzerType);
EmulationManager.Instance.EmulationChanged += () =>
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), uartAnalyzerType);
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(VideoBackend), videoAnalyzerType);
};
var shell = PrepareShell(options, monitor);
new System.Threading.Thread(x => shell.Start(true))
{
IsBackground = true,
Name = "Shell thread"
}.Start();
Emulator.BeforeExit += () =>
{
Emulator.DisposeAll();
xwt?.Dispose();
xwt = null;
};
if (beforeRun != null)
{
beforeRun(context);
}
if (options.RobotDebug)
{
ConsoleWindowBackendAnalyzer terminal = null;
Emulator.EnableGUI += () =>
{
Logger.AddBackend(ConsoleBackend.Instance, "console", true);
terminal = new ConsoleWindowBackendAnalyzer(true);
terminal.Show();
shell.Terminal = new NavigableTerminalEmulator(terminal.IO);
new System.Threading.Thread(x => shell.Start(true))
{
IsBackground = true,
Name = "Shell thread"
}.Start();
};
Emulator.DisableGUI += () =>
{
if (options.HideLog)
{
Logger.RemoveBackend(ConsoleBackend.Instance);
}
terminal?.Hide();
terminal = null;
};
}
Emulator.WaitForExit();
}
}
public void LogToFile(string filePath, bool flushAfterEveryWrite = false)
{
Logger.AddBackend(new FileBackend(filePath, flushAfterEveryWrite), "file", true);
}
public static void Run(Options options, Action <ObjectCreator.Context> beforeRun = null)
{
AppDomain.CurrentDomain.UnhandledException += (sender, e) => CrashHandler.HandleCrash((Exception)e.ExceptionObject);
XwtProvider xwt = null;
try
{
if (!options.DisableXwt)
{
xwt = new XwtProvider(new WindowedUserInterfaceProvider());
}
using (var context = ObjectCreator.Instance.OpenContext())
{
var monitor = new Emul8.UserInterface.Monitor();
context.RegisterSurrogate(typeof(Emul8.UserInterface.Monitor), monitor);
// we must initialize plugins AFTER registering monitor surrogate
// as some plugins might need it for construction
TypeManager.Instance.PluginManager.Init("CLI");
if (!options.HideLog)
{
Logger.AddBackend(ConsoleBackend.Instance, "console");
}
EmulationManager.Instance.ProgressMonitor.Handler = new CLIProgressMonitor();
if (options.Port == -1)
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), typeof(ConsoleWindowBackendAnalyzer));
EmulationManager.Instance.EmulationChanged += () =>
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), typeof(ConsoleWindowBackendAnalyzer));
};
}
var shell = PrepareShell(options, monitor);
new System.Threading.Thread(x => shell.Start(true))
{
IsBackground = true,
Name = "Shell thread"
}.Start();
Emulator.BeforeExit += () =>
{
Emulator.DisposeAll();
};
if (beforeRun != null)
{
beforeRun(context);
}
Emulator.WaitForExit();
}
}
finally
{
if (xwt != null)
{
xwt.Dispose();
}
}
}
public void Run(PathToken path)
{
Logger.AddBackend(new FileBackend(path.Value), "file", true);
}
public static void Run(string[] args)
{
var options = new Options();
var optionsParser = new OptionsParser();
if (!optionsParser.Parse(options, args))
{
return;
}
using (var context = ObjectCreator.OpenContext())
{
var monitor = new Emul8.UserInterface.Monitor();
context.RegisterSurrogate(typeof(Emul8.UserInterface.Monitor), monitor);
// we must initialize plugins AFTER registering monitor surrogate
// as some plugins might need it for construction
TypeManager.Instance.PluginManager.Init("CLI");
Logger.AddBackend(ConsoleBackend.Instance, "console");
EmulationManager.Instance.ProgressMonitor.Handler = new CLIProgressMonitor();
var crashHandler = new CrashHandler();
AppDomain.CurrentDomain.UnhandledException += (sender, e) => crashHandler.HandleCrash(e);
var resetEvent = new ManualResetEventSlim();
if (options.StdInOut)
{
Logger.AddBackend(new FileBackend("logger.log"), "file");
var world = new StreamIOSource(Console.OpenStandardInput(), Console.OpenStandardOutput());
var io = new DetachableIO(world);
monitor.Quitted += resetEvent.Set;
var handler = new StdInOutHandler(io, monitor, options.Plain);
handler.Start();
}
else
{
Shell shell = null;
Type preferredUARTAnalyzer = null;
if (options.Port > 0)
{
var io = new DetachableIO(new SocketIOSource(options.Port));
shell = ShellProvider.GenerateShell(io, monitor, true, false);
shell.Quitted += resetEvent.Set;
}
else if (options.ConsoleMode)
{
preferredUARTAnalyzer = typeof(UARTMultiplexedBackendAnalyzer);
var stream = new PtyUnixStream("/dev/fd/1");
var world = new StreamIOSource(stream, stream.Name);
Logger.AddBackend(new FileBackend("logger.log"), "file");
var consoleTerm = new ConsoleTerminal(world);
UARTMultiplexedBackendAnalyzer.Multiplexer = consoleTerm;
monitor.Console = consoleTerm;
shell = ShellProvider.GenerateShell(monitor);
consoleTerm.AttachTerminal("shell", shell.Terminal);
shell.Quitted += resetEvent.Set;
}
else
{
preferredUARTAnalyzer = typeof(UARTWindowBackendAnalyzer);
var stream = new PtyUnixStream();
var dio = new DetachableIO(new StreamIOSource(stream, stream.Name));
var terminal = new UARTWindowBackendAnalyzer(dio);
shell = ShellProvider.GenerateShell(dio, monitor);
shell.Quitted += resetEvent.Set;
monitor.Quitted += shell.Stop;
try
{
terminal.Show();
}
catch (InvalidOperationException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(ex.Message);
resetEvent.Set();
}
}
if (preferredUARTAnalyzer != null)
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
EmulationManager.Instance.EmulationChanged += () =>
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
};
}
monitor.Interaction = shell.Writer;
monitor.UseConsole = options.ConsoleMode;
monitor.MachineChanged += emu => shell.SetPrompt(emu != null ? new Prompt(string.Format("({0}) ", emu), ConsoleColor.DarkYellow) : null);
if (options.Execute != null)
{
shell.Started += s => s.InjectInput(string.Format("{0}\n", options.Execute));
}
else if (!string.IsNullOrEmpty(options.ScriptPath))
{
shell.Started += s => s.InjectInput(string.Format("i {0}{1}\n", Path.IsPathRooted(options.ScriptPath) ? "@" : "$CWD/", options.ScriptPath));
}
new Thread(x => shell.Start(true))
{
IsBackground = true, Name = "Shell thread"
}.Start();
}
resetEvent.Wait();
EmulationManager.Instance.Clear();
TypeManager.Instance.Dispose();
Logger.Dispose();
}
}
