/// <summary>
/// Adds the binding.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
public void AddBinding(IPEndPoint endpoint)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (Active)
{
throw new InvalidOperationException("Must be called when Active == false");
}
if (Bindings.Any(existed => existed.Endpoint.Equals(endpoint)))
{
return;
}
ListenerBinding binding = new ListenerBinding(Users, endpoint);
binding.ExceptionRaised += (o, args) =>
{
ExceptionRaised?.Invoke(o, args);
};
binding.MessageReceived += (o, args) =>
{
MessageReceived?.Invoke(o, args);
};
Bindings.Add(binding);
}
/// <summary>
/// Waits while the machine pauses or stops
/// </summary>
public async Task WaitForPause()
{
try
{
ExecutionCompletionReason = await _completionTask;
}
catch (TaskCanceledException)
{
// --- Ok, run successfully cancelled
ExecutionCompletionReason = ExecutionCompletionReason.Cancelled;
}
catch (Exception ex)
{
// --- Some other exception raised
ExecutionCompletionReason = ExecutionCompletionReason.Exception;
ExceptionRaised?.Invoke(this, new VmExceptionArgs(ex));
}
if (ExecutionCompletionReason != ExecutionCompletionReason.Cancelled &&
ExecutionCompletionReason != ExecutionCompletionReason.Exception &&
MachineState != VmState.Stopped)
{
MachineState = VmState.Paused;
}
}
/// <summary>
/// Function to actually invoke the delegate, after synchronization is checked.
/// </summary>
/// <param name="param">The parameter.</param>
private void RaiseExceptionRaised(object param)
{
if (param is ExceptionEventArgs paramArgs)
{
// We are in the creator thread, call the base implementation directly
ExceptionRaised?.Invoke(this, paramArgs);
}
}
public void Start()
{
IsRunning = true;
BeforeStart?.Fire(this);
try
{
Run();
}
catch (Exception ex)
{
Debug.Print("Emulator exception when executing {0}. {1}\r\n{2}", CurrentInstruction, ex.Message, ex.StackTrace);
ExceptionRaised?.Invoke(this, new EmulatorExceptionEventArgs(ex));
}
}
private void SocketEvent_Receive(IAsyncResult ar)
{
EndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
try
{
lock (this)
{
var socket = _socket;
int transBytes = socket?.EndReceiveFrom(ar, ref remoteEP) ?? -1;
if (transBytes == -1)
{
return;
}
byte[] dispatchBuffer = new byte[transBytes];
Array.Copy(_receivedBuffer, dispatchBuffer, transBytes);
SpinWorker.Dispatch(() =>
{
EventRead?.Invoke(new IOEventResult(remoteEP, IOEventType.Read, dispatchBuffer, 0, transBytes, 0));
});
WaitForReceive();
}
}
catch (SocketException)
{
SpinWorker.Dispatch(() =>
{
EventClose?.Invoke(new IOEventResult(remoteEP, IOEventType.Close, AegisResult.ClosedByRemote));
});
WaitForReceive();
}
catch (Exception e)
{
if (ExceptionRaised == null)
{
Logger.Err(LogMask.Aegis, e.ToString());
}
else
{
ExceptionRaised.Invoke(e);
}
}
}
/// <summary>
/// Starts the machine in a background thread with the specified options.
/// </summary>
/// <remarks>
/// Reports completion when the machine starts executing its cycles. The machine can
/// go into Paused or Stopped state, if the execution options allow, for example,
/// when it runs to a predefined breakpoint.
/// </remarks>
public void StartWithOptions(ExecuteCycleOptions options)
{
if (MachineState == VmState.Running)
{
return;
}
// --- Prepare the machine to run
IsFirstStart = MachineState == VmState.None || MachineState == VmState.Stopped;
SpectrumVm.DebugInfoProvider?.PrepareBreakpoints();
MachineState = VmState.Starting;
if (IsFirstStart)
{
SpectrumVm.Reset();
SpectrumVm.Cpu.StackDebugSupport.Reset();
SpectrumVm.DebugInfoProvider?.ResetHitCounts();
CpuFrameCount = 0;
RenderFrameCount = 0;
}
// --- Dispose the previous cancellation token, and create a new one
_cancellationTokenSource?.Dispose();
_cancellationTokenSource = new CancellationTokenSource();
// --- Set up the task that runs the machine
MachineState = VmState.Running;
try
{
_completionTask = StartAndRun(_cancellationTokenSource.Token, options);
_completionTask.GetAwaiter().OnCompleted(async() =>
{
await WaitForPause();
});
}
catch (TaskCanceledException)
{
ExecutionCompletionReason = ExecutionCompletionReason.Cancelled;
}
catch (Exception ex)
{
ExceptionRaised?.Invoke(this, new VmExceptionArgs(ex));
}
}
/// <summary>
/// Raise the ExceptionRaised event
/// </summary>
/// <param name="code"></param>
/// <param name="ex"></param>
protected void SetError(Exception ex)
{
try
{
if (Context != null)
{
Context.Post(o => ExceptionRaised?.Invoke(this, ex), null);
}
else
{
ExceptionRaised?.Invoke(this, ex);
}
Logger?.LogErrorAsync(ex);
}
catch (Exception)
{
// This can fail, and at this point we're in a really hard state to effectively report
// what just happened, so we are going to (reluctantly) swallow this.
}
}
private object SafeCapsule <T>(T _action, EventHandler MethodExceptionRaised)
{
object result = null;
try
{
if (_action is Func <Driver, T> funcAction)
{
result = funcAction.Invoke(this);
}
else if (_action is Action <Driver> action)
{
action.Invoke(this);
}
else
{
Log.Write(new NotImplementedException(), "Scenario not implemented in DriverActions.SafeCapsule", Logger.LogEntry.SeverityType.Critical);
}
Sleep();
}
catch (WebDriverException ex)
{
if (MethodExceptionRaised == null && ExceptionRaised == null)
{
Log.Write(ex, "An error occured with the WebDriver (no Driver EventHandler will be raised)", Logger.LogEntry.SeverityType.High);
}
else if (MethodExceptionRaised != null && !IsEmptyEventHandler(MethodExceptionRaised))
{
Log.Write($"An error occured with the WebDriver (Driver's specific EventHandler will be raised)");
MethodExceptionRaised.Invoke(ex, EventArgs.Empty);
}
else if (ExceptionRaised != null && !IsEmptyEventHandler(MethodExceptionRaised))
{
Log.Write($"An error occured with the WebDriver (Driver's generic EventHandler will be raised)");
ExceptionRaised.Invoke(ex, EventArgs.Empty);
}
}
return(result);
}
private void Socket_Send(IAsyncResult ar)
{
try
{
lock (this)
{
var socket = _socket;
socket?.EndSend(ar);
}
}
catch (Exception e)
{
if (ExceptionRaised == null)
{
Logger.Err(LogMask.Aegis, e.ToString());
}
else
{
ExceptionRaised.Invoke(e);
}
};
}
/// <summary>
/// Cancels the execution of the virtual machine.
/// </summary>
/// <param name="cancelledState">Virtual machine state after cancellation</param>
private async Task CancelVmExecution(VmState cancelledState)
{
try
{
// --- Wait for cancellation
_cancellationTokenSource?.Cancel();
ExecutionCompletionReason = await _completionTask;
}
catch (TaskCanceledException)
{
// --- Ok, run successfully cancelled
ExecutionCompletionReason = ExecutionCompletionReason.Cancelled;
}
catch (Exception ex)
{
// --- Some other exception raised
ExceptionRaised?.Invoke(this, new VmExceptionArgs(ex));
}
finally
{
// --- Now, it's cancelled
MachineState = cancelledState;
}
}
private void WaitForReceive()
{
try
{
lock (this)
{
EndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
var socket = _socket;
socket?.BeginReceiveFrom(_receivedBuffer, 0, _receivedBuffer.Length, SocketFlags.None,
ref remoteEP, SocketEvent_Receive, null);
}
}
catch (Exception e)
{
if (ExceptionRaised == null)
{
Logger.Err(LogMask.Aegis, e.ToString());
}
else
{
ExceptionRaised.Invoke(e);
}
}
}
private void HandleException(Exception exception)
{
ExceptionRaised?.Invoke(this, new ExceptionRaisedEventArgs(exception));
}
/// <summary>Raises the<see /// cref="E:MyBlogLister.BusinessLayer.BusinessLayer.BloggingServiceBase.ExceptionRaised" /> /// event.</summary> /// <param name="ex">A <see cref="T:System.Exception" /> that provides /// information on the error that occurred.</param> protected virtual void OnExceptionRaised(Exception ex) => ExceptionRaised?.Invoke(ex);
protected virtual void OnExceptionRaised(EventArgs e)
{
ExceptionRaised?.Invoke(this, e);
}
private void OnExceptionRaised(Exception exception)
{
ExceptionRaised?.Invoke(exception);
}
public void RuntimeInitialize()
{
_runtimeEngine = new RuntimeEngine(ConfigData);
_runtimeEngine.GlobalInfo.ExceptionManager.ExceptionRaised += (exception) => { ExceptionRaised?.Invoke(exception); };
}