private void buttonReset_Click(object sender, RoutedEventArgs e) { try { if (connection.TestWCF()) { new SystemMessage(null, "WCF test", "WCF connection test passed", MemeType.FuckYea).ShowDialog(); } else { throw new Exception("test returned false"); } } catch (Exception ex) { var ae = new ActionException("WCF test failed", ActionType.User, null, ex); new SystemMessage(ae).ShowDialog(); } try { if (connection.TestEF()) { new SystemMessage(null, "EF test", "Enitity Framework connection test passed", MemeType.FuckYea).ShowDialog(); } else { throw new Exception("test returned false"); } } catch (Exception ex) { var ae = new ActionException("EF test failed", ActionType.User, null, ex); new SystemMessage(ae).ShowDialog(); } }
public SystemMessage(ActionException ex, bool toggleOk = true, bool toggleCancel = false, bool toggleHelp = false) : this("FileSync: System message", ex.Title, ex.Message, ex.Image, toggleOk, toggleCancel, toggleHelp) { //nothing needed here }
public override void Report(Core.Actions.ActionBase action, Exception ex) { ActionException aex = CreateActionException(action, ex); ServerApiInvoker.ExceptionReport(aex.ScriptId, aex.ActionId , aex.Message, aex.ActionIndex.ToString(), aex.ActionType, action.Title); }
/// <summary> /// Creates new result of some acition. /// </summary> /// <param name="actionTitle"></param> /// <param name="actionDescription"></param> /// <param name="actionType">type of the action, value from ActionType enum</param> /// <param name="wasSuccessful">indicates whether the action completed successfully</param> /// <param name="resultContext"></param> /// <param name="errorContext"></param> public ActionResult(string actionTitle, string actionDescription, ActionType actionType, bool wasSuccessful = true, ActionResult resultContext = null, ActionException errorContext = null) { title = actionTitle; desc = actionDescription; type = actionType; success = wasSuccessful; context = resultContext; }
public void DisplayActionException(ActionException ex) { io.Error.Write("Exception: {0}", ex.GetType()); io.Error.Write("Message: {0}", ex.Message); io.Error.Write("-----------------------------"); io.Error.Write(ex.ToString()); io.Error.Write("-----------------------------"); if (ex.InnerException != null) { io.Error.Write("Inner Exception: {0}", ex.InnerException.GetType()); io.Error.Write("Inner Message: {0}", ex.InnerException.Message); } io.Error.Write("-----------------------------"); io.Error.Write("FinTS Trace:"); }
protected ActionResult Error(ActionException exception) { if (exception.InnerExceptions.Any()) { var sb = new StringBuilder(TaskStrings.ProductsNotProcessed); foreach (var ex in exception.InnerExceptions.OfType <ProductException>()) { sb.AppendLine(); var exText = ex.Message; var rm = new ResourceManager(typeof(TaskStrings)); var result = ActionTaskResult.FromString(exText); var resource = rm.GetString(exText); if (result != null) { exText = result.ToString(); } else if (resource != null && resource.Contains("{0}")) { exText = string.Format(resource, ex.ProductId); } else { exText = $"{ex.ProductId}: {exText}"; if (ex.InnerException != null) { exText += ". " + ex.InnerException.Message; } } sb.AppendFormat(exText); } return(Error(sb.ToString())); } else { return(Error(exception.Message)); } }
/// <summary> /// Runs until no runnable tasklets left. /// This function is reentrant. /// </summary> public void Run() { int managedThreadId = Thread.CurrentThread.ManagedThreadId; MicroThreadCallbackList callbacks = default(MicroThreadCallbackList); while (true) { SchedulerEntry schedulerEntry; MicroThread microThread; lock (ScheduledEntries) { // Reclaim callbacks of previous microthread MicroThreadCallbackNode callback; while (callbacks.TakeFirst(out callback)) { callback.Clear(); CallbackNodePool.Add(callback); } if (ScheduledEntries.Count == 0) { break; } schedulerEntry = ScheduledEntries.Dequeue(); microThread = schedulerEntry.MicroThread; if (microThread != null) { callbacks = microThread.Callbacks; microThread.Callbacks = default(MicroThreadCallbackList); } } // Since it can be reentrant, it should be restored after running the callback. var previousRunningMicrothread = runningMicroThread.Value; if (previousRunningMicrothread != null) { MicroThreadCallbackEnd?.Invoke(this, new SchedulerThreadEventArgs(previousRunningMicrothread, managedThreadId)); } runningMicroThread.Value = microThread; if (microThread != null) { var previousSyncContext = SynchronizationContext.Current; SynchronizationContext.SetSynchronizationContext(microThread.SynchronizationContext); // TODO: Do we still need to try/catch here? Everything should be caught in the continuation wrapper and put into MicroThread.Exception try { if (microThread.State == MicroThreadState.Starting) { MicroThreadStarted?.Invoke(this, new SchedulerThreadEventArgs(microThread, managedThreadId)); } MicroThreadCallbackStart?.Invoke(this, new SchedulerThreadEventArgs(microThread, managedThreadId)); var profilingKey = microThread.ProfilingKey ?? schedulerEntry.ProfilingKey ?? MicroThreadProfilingKeys.ProfilingKey; using (Profiler.Begin(profilingKey)) { var callback = callbacks.First; while (callback != null) { callback.Invoke(); callback = callback.Next; } } } catch (Exception e) { Log.Error("Unexpected exception while executing a micro-thread", e); microThread.SetException(e); } finally { MicroThreadCallbackEnd?.Invoke(this, new SchedulerThreadEventArgs(microThread, managedThreadId)); SynchronizationContext.SetSynchronizationContext(previousSyncContext); if (microThread.IsOver) { lock (microThread.AllLinkedListNode) { if (microThread.CompletionTask != null) { if (microThread.State == MicroThreadState.Failed || microThread.State == MicroThreadState.Canceled) { microThread.CompletionTask.TrySetException(microThread.Exception); } else { microThread.CompletionTask.TrySetResult(1); } } else if (microThread.State == MicroThreadState.Failed && microThread.Exception != null) { // Nothing was listening on the micro thread and it crashed // Let's treat it as unhandled exception and propagate it // Use ExceptionDispatchInfo.Capture to not overwrite callstack if (PropagateExceptions && (microThread.Flags & MicroThreadFlags.IgnoreExceptions) != MicroThreadFlags.IgnoreExceptions) { ExceptionDispatchInfo.Capture(microThread.Exception).Throw(); } } MicroThreadEnded?.Invoke(this, new SchedulerThreadEventArgs(microThread, managedThreadId)); } } runningMicroThread.Value = previousRunningMicrothread; if (previousRunningMicrothread != null) { MicroThreadCallbackStart?.Invoke(this, new SchedulerThreadEventArgs(previousRunningMicrothread, managedThreadId)); } } } else { try { var profilingKey = schedulerEntry.ProfilingKey ?? MicroThreadProfilingKeys.ProfilingKey; using (Profiler.Begin(profilingKey)) { schedulerEntry.Action(); } } catch (Exception e) { ActionException?.Invoke(this, schedulerEntry, e); } } } while (FrameChannel.Balance < 0) { FrameChannel.Send(0); } }
/// <summary> /// Creates an action result from an action exception. /// </summary> /// <param name="ex">exception to be converted to the result</param> public ActionResult(ActionException ex) : this(ex.Title, ex.Message, ex.Type, ex.Image.Equals(MemeType.FuckYea), null, ex) { //nothing needed here }