public void Abort() { try { tokenSource.Cancel(); AbortImpl(Interlocked.Increment(ref abortCalls) - 1); } catch (OperationCanceledException) { // if CancelImpl throw OCE we shouldn't mute it throw; } catch (Exception e) { DebuggerLoggingService.LogMessage("Exception in CancelImpl(): {0}", e.Message); } }
protected override void OnSetNextStatement(long threadId, string fileName, int line, int column) { var source = new Source { Name = Path.GetFileName(fileName), Path = fileName }; var request = new GotoTargetsRequest(source, line) { Column = column }; GotoTargetsResponse response; GotoTarget target = null; try { response = protocolClient.SendRequestSync(request); } catch (Exception ex) { DebuggerLoggingService.LogError("[VSCodeDebugger] Requesting target locations failed", ex); throw new NotSupportedException(ex.Message); } foreach (var location in response.Targets) { if (location.Line <= line && location.EndLine >= line && location.Column <= column && location.EndColumn >= column) { // exact match for location target = location; break; } if (target == null) { // closest match so far... target = location; } } if (target == null) { throw new NotSupportedException(); } try { protocolClient.SendRequestSync(new GotoRequest((int)threadId, target.Id)); } catch (Exception ex) { DebuggerLoggingService.LogMessage("[VSCodeDebugger] Setting next statement failed", ex); throw new NotSupportedException(ex.Message); } RaiseStopEvent(); }
void HandleResult(string result) { DebuggerLoggingService.LogMessage("Result: {0}", result); var message = JsonConvert.DeserializeObject <V8Message> (result); if (message.type == "event") { HandleEvent(JsonConvert.DeserializeObject <V8Event> (result)); } else if (message.type == "response") { HandleReponse(JsonConvert.DeserializeObject <V8Response> (result)); } }
void DebugAgentProcess_Exited(object sender, EventArgs e) { if (protocolClient != null) { try { HasExited = true; protocolClient.RequestReceived -= OnDebugAdaptorRequestReceived; protocolClient.Stop(); } catch (Exception ex) { DebuggerLoggingService.LogError("[VSCodeDebugger] Stop request failed", ex); } protocolClient = null; } OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited)); }
public void AbortAll() { DebuggerLoggingService.LogMessage("Aborting all the current invocations"); List <IAsyncOperationBase> copy; lock (currentOperations) { if (disposed) { throw new ObjectDisposedException("Already disposed"); } copy = currentOperations.ToList(); currentOperations.Clear(); } CancelOperations(copy, true); }
void ReloadValues() { var frame = DebuggingService.CurrentFrame; if (frame == null) { return; } var locals = frame.GetAllLocals(); DebuggerLoggingService.LogMessage("Begin Local Variables:"); foreach (var local in locals) { DebuggerLoggingService.LogMessage("\t{0}", local.Name); } DebuggerLoggingService.LogMessage("End Local Variables"); if (UseNewTreeView) { controller.ClearValues(); controller.AddValues(locals); //var xx = new System.Collections.Generic.List<ObjectValueNode> (); //xx.Add (new FakeObjectValueNode ("f1")); //xx.Add (new FakeIsImplicitNotSupportedObjectValueNode ()); //xx.Add (new FakeEvaluatingGroupObjectValueNode (1)); //xx.Add (new FakeEvaluatingGroupObjectValueNode (0)); //xx.Add (new FakeEvaluatingGroupObjectValueNode (5)); //xx.Add (new FakeEvaluatingObjectValueNode ()); //xx.Add (new FakeEnumerableObjectValueNode (10)); //xx.Add (new FakeEnumerableObjectValueNode (20)); //xx.Add (new FakeEnumerableObjectValueNode (23)); //controller.AddValues (xx); } else { tree.ClearValues(); tree.AddValues(locals); } }
protected override void AbortImpl(int abortCallTimes) { try { if (abortCallTimes < 10) { DebuggerLoggingService.LogMessage("Calling Abort() for {0} time", abortCallTimes); eval.Abort(); } else { if (abortCallTimes == 20) { // if Abort() and RudeAbort() didn't bring any result let's try to resume all the threads to free possible deadlocks in target process // maybe this can help to abort hanging evaluations DebuggerLoggingService.LogMessage("RudeAbort() didn't stop eval after {0} times", abortCallTimes - 1); DebuggerLoggingService.LogMessage("Calling Stop()"); context.Session.Process.Stop(0); DebuggerLoggingService.LogMessage("Calling SetAllThreadsDebugState(THREAD_RUN)"); context.Session.Process.SetAllThreadsDebugState(CorApi.Portable.CorDebugThreadState.ThreadRun, null); DebuggerLoggingService.LogMessage("Calling Continue()"); context.Session.Process.Continue(false); } DebuggerLoggingService.LogMessage("Calling RudeAbort() for {0} time", abortCallTimes); eval.RudeAbort(); } } catch (COMException e) { var hResult = e.ToHResult <HResult> (); switch (hResult) { case HResult.CORDBG_E_PROCESS_TERMINATED: DebuggerLoggingService.LogMessage("Process was terminated. Set cancelled for eval"); tcs.TrySetCanceled(); return; case HResult.CORDBG_E_OBJECT_NEUTERED: DebuggerLoggingService.LogMessage("Eval object was neutered. Set cancelled for eval"); tcs.TrySetCanceled(); return; } tcs.SetException(e); throw; } }
void DoProcessEvalFinished(CorApi.Portable.EvalEventArgs evalArgs, bool isException) { if (!ComObject.EqualsComObject(evalArgs.Eval, eval)) { return; } context.Session.OnEndEvaluating(); evalArgs.Continue = false; if (Token.IsCancellationRequested) { DebuggerLoggingService.LogMessage("EvalFinished() but evaluation was cancelled"); tcs.TrySetCanceled(); } else { DebuggerLoggingService.LogMessage("EvalFinished(). Setting the result"); tcs.TrySetResult(new OperationResult <CorApi.Portable.Value> (evalArgs.Eval.Result, isException)); } }
void ReloadValues() { var frame = DebuggingService.CurrentFrame; if (frame == null) { return; } var locals = frame.GetAllLocals(); DebuggerLoggingService.LogMessage("Begin Local Variables:"); foreach (var local in locals) { DebuggerLoggingService.LogMessage("\t{0}", local.Name); } DebuggerLoggingService.LogMessage("End Local Variables"); if (UseNewTreeView) { _treeview.BeginUpdates(); try { controller.ClearValues(); controller.AddValues(locals); } finally { _treeview.EndUpdates(); } if (EnableFakeNodes) { AddFakeNodes(); } } else { tree.ClearValues(); tree.AddValues(locals); } }
protected override ThreadInfo [] OnGetThreads(long processId) { ThreadsResponse response; try { response = protocolClient.SendRequestSync(new ThreadsRequest()); } catch (Exception ex) { DebuggerLoggingService.LogError("[VSCodeDebugger] Error getting threads", ex); return(new ThreadInfo[0]); } var threads = new ThreadInfo[response.Threads.Count]; for (int i = 0; i < threads.Length; i++) { var thread = response.Threads[i]; threads[i] = new ThreadInfo(processId, thread.Id, thread.Name, null); } return(threads); }
void WaitAfterCancel(IAsyncOperationBase op) { var desc = op.Description; DebuggerLoggingService.LogMessage(string.Format("Waiting for cancel of invoke {0}", desc)); if (!op.RawTask.Wait(ShortCancelTimeout)) { try { ChangeBusyState(true, desc); while (true) { op.Abort(); if (op.RawTask.Wait(ShortCancelTimeout)) { break; } } } finally { ChangeBusyState(false, desc); } } }
void SendRequest(Request request) { var requestEvent = new ManualResetEvent(false); requestEvents [request.seq] = requestEvent; var jsonString = JsonConvert.SerializeObject(request); var data = string.Format("Content-Length: {0}\r\n\r\n{1}", jsonString.Length, jsonString); DebuggerLoggingService.LogMessage("Request: {0}", jsonString); stdInOutProtocol.WriteStandardInput(data); // Wait for response requestEvent.WaitOne(); if (requestException != null) { var e = requestException; requestException = null; throw e; } }
void CancelOperations(List <IAsyncOperationBase> operations, bool wait) { foreach (var operation in operations) { var taskDescription = operation.Description; try { operation.Abort(); if (wait) { WaitAfterCancel(operation); } } catch (Exception e) { if (IsOperationCancelledException(e)) { DebuggerLoggingService.LogMessage(string.Format("Invocation of {0} cancelled in CancelOperations()", taskDescription)); } else { DebuggerLoggingService.LogError(string.Format("Invocation of {0} thrown an exception in CancelOperations()", taskDescription), e); } } } }
public ObjectValue CreateObjectValue(EvaluationOptions options) { if (!CanEvaluate(options)) { return(DC.ObjectValue.CreateImplicitNotSupported(this, new ObjectPath(Name), Context.Adapter.GetDisplayTypeName(GetContext(options), Type), Flags)); } Connect(); try { return(OnCreateObjectValue(options)); } catch (ImplicitEvaluationDisabledException) { return(DC.ObjectValue.CreateImplicitNotSupported(this, new ObjectPath(Name), Context.Adapter.GetDisplayTypeName(GetContext(options), Type), Flags)); } catch (NotSupportedExpressionException ex) { return(DC.ObjectValue.CreateNotSupported(this, new ObjectPath(Name), Context.Adapter.GetDisplayTypeName(GetContext(options), Type), ex.Message, Flags)); } catch (EvaluatorExceptionThrownException ex) { return(DC.ObjectValue.CreateEvaluationException(Context, Context.ExpressionValueSource, new ObjectPath(Name), ex)); } catch (EvaluatorException ex) { return(DC.ObjectValue.CreateError(this, new ObjectPath(Name), "", ex.Message, Flags)); } catch (Exception ex) { DebuggerLoggingService.LogError("Exception in CreateObjectValue()", ex); return(DC.ObjectValue.CreateUnknown(Name)); } }
public void Error(string message, Exception e) { DebuggerLoggingService.LogError(message, e); }
public void Info(string message) { DebuggerLoggingService.LogMessage(message); }
void ReloadValues(bool frameChanged) { var frame = DebuggingService.CurrentFrame; if (frame == null) { return; } ObjectValue[] locals; TimeSpan elapsed; using (var timer = frame.DebuggerSession.LocalVariableStats.StartTimer()) { try { locals = frame.GetAllLocals(); timer.Stop(true); } catch { locals = new ObjectValue[0]; timer.Stop(false); } elapsed = timer.Elapsed; } if (frameChanged) { var metadata = new Dictionary <string, object> (); metadata["LocalsCount"] = locals.Length; metadata["Elapsed"] = elapsed.TotalMilliseconds; Counters.LocalsPadFrameChanged.Inc(1, null, metadata); } DebuggerLoggingService.LogMessage("Begin Local Variables:"); foreach (var local in locals) { DebuggerLoggingService.LogMessage("\t{0}", local.Name); } DebuggerLoggingService.LogMessage("End Local Variables"); if (UseNewTreeView) { _treeview.BeginUpdates(); try { controller.ClearValues(); controller.AddValues(locals); } finally { _treeview.EndUpdates(); } if (EnableFakeNodes) { AddFakeNodes(); } } else { tree.ClearValues(); tree.AddValues(locals); } }
public OperationResult <TValue> Invoke <TValue> (AsyncOperationBase <TValue> mc, int timeout) { if (timeout <= 0) { throw new ArgumentOutOfRangeException("timeout", timeout, "timeout must be greater than 0"); } Task <OperationResult <TValue> > task; var description = mc.Description; lock (currentOperations) { if (disposed) { throw new ObjectDisposedException("Already disposed"); } DebuggerLoggingService.LogMessage(string.Format("Starting invoke for {0}", description)); task = mc.InvokeAsync(); currentOperations.Add(mc); } bool cancelledAfterTimeout = false; try { if (task.Wait(timeout)) { DebuggerLoggingService.LogMessage(string.Format("Invoke {0} succeeded in {1} ms", description, timeout)); return(task.Result); } DebuggerLoggingService.LogMessage(string.Format("Invoke {0} timed out after {1} ms. Cancelling.", description, timeout)); mc.Abort(); try { WaitAfterCancel(mc); } catch (Exception e) { if (IsOperationCancelledException(e)) { DebuggerLoggingService.LogMessage(string.Format("Invoke {0} was cancelled after timeout", description)); cancelledAfterTimeout = true; } throw; } DebuggerLoggingService.LogMessage(string.Format("{0} cancelling timed out", description)); throw new TimeOutException(); } catch (Exception e) { if (IsOperationCancelledException(e)) { if (cancelledAfterTimeout) { throw new TimeOutException(); } DebuggerLoggingService.LogMessage(string.Format("Invoke {0} was cancelled outside before timeout", description)); throw new EvaluatorAbortedException(); } throw; } finally { lock (currentOperations) { currentOperations.Remove(mc); } } }
protected override void OnNextLine() { protocolClient.SendRequest(new NextRequest(currentThreadId), null, (args, ex) => { DebuggerLoggingService.LogError("[VSCodeDebugger] StepOver request failed", ex); }); }