public virtual async Task AttachWithOutputRedirection() { var expectedOutput = new[] { "stdout", "stderr" }; string script = TestData.GetPath(@"TestData\DebuggerProject\AttachOutput.py"); var p = Process.Start(Version.InterpreterPath, "\"" + script + "\""); try { using (var dumpWriter = new MiniDumpWriter(p)) { Thread.Sleep(1000); var proc = PythonProcess.Attach(p.Id, PythonDebugOptions.RedirectOutput); try { var attached = new TaskCompletionSource <bool>(); proc.ProcessLoaded += (sender, args) => { Console.WriteLine("Process loaded"); attached.SetResult(true); }; await proc.StartListeningAsync(); await attached.Task.WithTimeout(20000, "Failed to attach within 20s"); await proc.ResumeAsync(TimeoutToken()); var bpHit = new TaskCompletionSource <bool>(); PythonThread thread = null; proc.BreakpointHit += (sender, args) => { thread = args.Thread; bpHit.SetResult(true); }; var bp = proc.AddBreakpoint(script, 5); await bp.AddAsync(TimeoutToken()); await bpHit.Task.WithTimeout(20000, "Failed to hit breakpoint within 20s"); Assert.IsNotNull(thread); var actualOutput = new List <string>(); proc.DebuggerOutput += (sender, e) => { Console.WriteLine("Debugger output: '{0}'", e.Output); actualOutput.Add(e.Output); }; var frame = thread.Frames[0]; Assert.AreEqual("False", (await frame.ExecuteTextAsync("attached", ct: CancellationTokens.After15s)).StringRepr); await frame.ExecuteTextAsync("attached = True", ct : TimeoutToken()); await proc.ResumeAsync(TimeoutToken()); WaitForExit(proc); AssertUtil.ArrayEquals(expectedOutput, actualOutput); } finally { await DetachProcessAsync(proc); } dumpWriter.Cancel(); } } finally { DisposeProcess(p); } }
public void ChangeProcess() { Attach("DebugReplTest4A.py", 3); Attach("DebugReplTest4B.py", 3); PythonProcess proc1 = _processes[0]; PythonProcess proc2 = _processes[1]; // We are broken in process 2 (the last one attached is the current one) string text; text = ExecuteCommand(new DebugReplProcessesCommand(), ""); Assert.AreEqual(String.Format(@" Process id={0}, Language version={2} => Process id={1}, Language version={2}", proc1.Id, proc2.Id, Version.Version), text); // Switch to process 1 Assert.AreEqual(String.Format("Current process changed to {0}", proc1.Id), ExecuteCommand(new DebugReplProcessCommand(), proc1.Id.ToString())); Assert.AreEqual(String.Format("{0}", proc1.Id), ExecuteCommand(new DebugReplProcessCommand(), String.Empty)); Assert.AreEqual("'hello'", ExecuteText("a1")); Assert.AreEqual("30", ExecuteText("b1")); // Switch to process 2 Assert.AreEqual(String.Format("Current process changed to {0}", proc2.Id), ExecuteCommand(new DebugReplProcessCommand(), proc2.Id.ToString())); Assert.AreEqual(String.Format("{0}", proc2.Id), ExecuteCommand(new DebugReplProcessCommand(), String.Empty)); Assert.AreEqual("'world'", ExecuteText("a2")); Assert.AreEqual("60", ExecuteText("b2")); }
public virtual async Task AttachSingleThreadedSleeper() { // http://pytools.codeplex.com/discussions/285741 1/12/2012 6:20 PM Process p = Process.Start(Version.InterpreterPath, "\"" + TestData.GetPath(@"TestData\DebuggerProject\AttachSingleThreadedSleeper.py") + "\""); try { Thread.Sleep(1000); var attached = new TaskCompletionSource <bool>(); var proc = PythonProcess.Attach(p.Id); try { proc.ProcessLoaded += (sender, args) => { attached.SetResult(true); }; await proc.StartListeningAsync(); using (var dumpWriter = new MiniDumpWriter(p)) { await attached.Task.WithTimeout(10000, "Failed to attach within 10s"); await proc.ResumeAsync(TimeoutToken()); Debug.WriteLine("Waiting for exit"); dumpWriter.Cancel(); } } finally { TerminateProcess(proc); } } finally { DisposeProcess(p); } }
public void DateXDecimalYTest() { var xyPair1 = new XyPair <DateTime, decimal>("Some Legend A"); xyPair1.AddX(new DateTime(2018, 11, 20)); xyPair1.AddX(new DateTime(2018, 11, 21)); xyPair1.AddX(new DateTime(2018, 11, 22)); xyPair1.AddY(0.18m); xyPair1.AddY(0.32m); xyPair1.AddY(0.21m); xyPair1.HasScatter = true; IPythonProcess pythonProcess = new PythonProcess(PythonResources.GetPythonPath()); ITitle title = new Title("This is a title", 16); IPlotColor colors = new PlotColor(); colors.OutsideColor = "#979899"; colors.InsideColor = "#d1d1d1"; IDesign <DateTime, decimal> design = new Design <DateTime, decimal>(title, colors, true, 0.5m, "&", "cccc", "dddd"); ITickComposer <DateTime, decimal> tickComposer = new TickComposer <DateTime, decimal>(false, pythonProcess); IGeneralComposer <DateTime, decimal> composer = new GeneralComposer <DateTime, decimal>(pythonProcess, tickComposer); IPlotV3 <DateTime, decimal> plot = new PlotV3 <DateTime, decimal>(pythonProcess, design, composer); plot.AddSource(xyPair1); plot.Show(); }
public virtual async Task AttachSingleThreadedSleeper() { // http://pytools.codeplex.com/discussions/285741 1/12/2012 6:20 PM Process p = Process.Start(Version.InterpreterPath, "\"" + TestData.GetPath(@"TestData\DebuggerProject\AttachSingleThreadedSleeper.py") + "\""); try { Thread.Sleep(1000); AutoResetEvent attached = new AutoResetEvent(false); var proc = PythonProcess.Attach(p.Id); try { proc.ProcessLoaded += (sender, args) => { attached.Set(); }; await proc.StartListeningAsync(); Assert.IsTrue(attached.WaitOne(10000), "Failed to attach within 10s"); await proc.ResumeAsync(TimeoutToken()); Debug.WriteLine("Waiting for exit"); } finally { TerminateProcess(proc); } } finally { DisposeProcess(p); } }
public void DateTimeXPlot() { var xyPair1 = new XyPair <DateTime, long>("AAAAA"); xyPair1.AddX(new DateTime(2018, 11, 20, 2, 0, 0)); xyPair1.AddX(new DateTime(2018, 11, 20, 4, 0, 0)); xyPair1.AddX(new DateTime(2018, 11, 20, 8, 0, 0)); xyPair1.AddY(18); xyPair1.AddY(32); xyPair1.AddY(21); xyPair1.HasScatter = true; IPythonProcess pythonProcess = new PythonProcess(PythonResources.GetPythonPath()); ITitle title = new Title("BBBBB", 32); IPlotColor colors = new PlotColor(); colors.OutsideColor = "#979899"; colors.InsideColor = "#d1d1d1"; IDesign <DateTime, long> design = new Design <DateTime, long>(title, colors, true, 16m, "▬", "CCCCC", "DDDDD"); ITickComposer <DateTime, long> tickComposer = new TickComposer <DateTime, long>(true, pythonProcess); IGeneralComposer <DateTime, long> composer = new GeneralComposer <DateTime, long>(pythonProcess, tickComposer); IPlotV3 <DateTime, long> plot = new PlotV3 <DateTime, long>(pythonProcess, design, composer); plot.AddSource(xyPair1); plot.Show(); }
public virtual async Task AttachReattachInfiniteThreads() { Process p = Process.Start(Version.InterpreterPath, "\"" + TestData.GetPath(@"TestData\DebuggerProject\InfiniteThreads.py") + "\""); try { Thread.Sleep(1000); AutoResetEvent attached = new AutoResetEvent(false); AutoResetEvent detached = new AutoResetEvent(false); for (int i = 0; i < 10; i++) { Console.WriteLine(i); var proc = PythonProcess.Attach(p.Id); proc.ProcessLoaded += (sender, args) => { attached.Set(); }; proc.ProcessExited += (sender, args) => { detached.Set(); }; await proc.StartListeningAsync(); Assert.IsTrue(attached.WaitOne(30000), "Failed to attach within 30s"); await proc.DetachAsync(TimeoutToken()); Assert.IsTrue(detached.WaitOne(30000), "Failed to detach within 30s"); } } finally { DisposeProcess(p); } }
public void DateXDLongYTest() { var xyPair1 = new XyPair <DateTime, long>("Some Legend A"); xyPair1.AddX(new DateTime(2018, 11, 20)); xyPair1.AddX(new DateTime(2018, 11, 21)); xyPair1.AddX(new DateTime(2018, 11, 22)); xyPair1.AddY(18); xyPair1.AddY(32); xyPair1.AddY(21); xyPair1.HasScatter = true; IPythonProcess pythonProcess = new PythonProcess(PythonResources.GetPythonPath()); ITitle title = new Title("This is a title", 32); IPlotColor colors = new PlotColor(); colors.OutsideColor = "#979899"; colors.InsideColor = "#d1d1d1"; IDesign <DateTime, long> design = new Design <DateTime, long>(title, colors, true, 16m, "▬", "aaa", "bbbb"); ITickComposer <DateTime, long> tickComposer = new TickComposer <DateTime, long>(false, pythonProcess); IGeneralComposer <DateTime, long> composer = new GeneralComposer <DateTime, long>(pythonProcess, tickComposer); IPlotV3 <DateTime, long> plot = new PlotV3 <DateTime, long>(pythonProcess, design, composer); plot.AddSource(xyPair1); plot.Show(); }
/// <summary> /// Creates a PythonObject for an expression which raised an exception instead of returning a value. /// </summary> public PythonEvaluationResult(PythonProcess process, string exceptionText, string expression, PythonStackFrame frame) { _process = process; _expression = expression; _frame = frame; _exceptionText = exceptionText; }
internal PythonThread(PythonProcess process, long identity, bool isWorkerThread) { _process = process; _identity = identity; _isWorkerThread = isWorkerThread; _name = ""; }
public PythonBreakpoint( PythonProcess process, string filename, int lineNo, PythonBreakpointConditionKind conditionKind, string condition, PythonBreakpointPassCountKind passCountKind, int passCount, int breakpointId, bool isDjangoBreakpoint = false ) { Debug.Assert(conditionKind != PythonBreakpointConditionKind.Always || string.IsNullOrEmpty(condition)); Debug.Assert(passCountKind != PythonBreakpointPassCountKind.Always || passCount == 0); _process = process; _filename = filename; _lineNo = lineNo; _breakpointId = breakpointId; _conditionKind = conditionKind; _condition = condition; _passCountKind = passCountKind; _passCount = passCount; _isDjangoBreakpoint = isDjangoBreakpoint; }
static void Main(string[] args) { string workDir = ConfigurationManager.AppSettings["WorkDir"]; string tensorBoardLogs = Path.Combine(workDir, "Logs"); List <string> index = new List <string>(); Directory.SetCurrentDirectory("..\\..\\..\\PythonScripts"); if (!Directory.Exists(tensorBoardLogs)) { Directory.CreateDirectory(tensorBoardLogs); } PythonProcess blender = new PythonProcess("Blender"); blender.EnsureCreated(); blender.Connect(); PythonProcess Tf = new PythonProcess("Tf"); Tf.EnsureCreated(); Tf.Connect(); string dir = Directory.GetFiles(workDir, "Checkpoint_*").Where(i => !i.Contains("epoch")).OrderByDescending(i => i).FirstOrDefault(); if (dir != null) { Tf.Call("load", dir); //Tf.Call("dump", "c:\\temp\\b.txt"); } else { Tf.Call("build_model"); } Tf.Call("enable_tensorboard", tensorBoardLogs); while (true) { for (int i = 0; i < 60; i++) { string filePath = Path.Combine(workDir, "image" + i + ".jpg"); blender.Call("renderImage", filePath, i % 6); index.Add((i % 6) + "|" + filePath); } string indexFile = Path.Combine(workDir, "index.txt"); File.WriteAllLines(indexFile, index.ToArray()); Tf.Call("loadDataset", indexFile); Tf.Call("fit"); //Tf.Call("evaluate"); Tf.Call("save", Path.Combine(workDir, "Checkpoint_" + DateTime.Now.ToString("yyyyMMdd_HHmmss"))); //Tf.Call("dump", "c:\\temp\\a.txt"); } }
private async Task AttachTestTimeoutAsync(string hostCode) { var exe = CompileCode(hostCode); // start the test process w/ our handle var eventName = Guid.NewGuid().ToString(); EventWaitHandle handle = new EventWaitHandle(false, EventResetMode.AutoReset, eventName); ProcessStartInfo psi = new ProcessStartInfo(exe, eventName); psi.UseShellExecute = false; psi.RedirectStandardError = psi.RedirectStandardOutput = true; psi.CreateNoWindow = true; // Add Python to PATH so that the host can locate the DLL in case it's not in \Windows\System32 (e.g. for EPD) psi.EnvironmentVariables["PATH"] = Environment.GetEnvironmentVariable("PATH") + ";" + Path.GetDirectoryName(Version.InterpreterPath); Process p = Process.Start(psi); var outRecv = new OutputReceiver(); p.OutputDataReceived += outRecv.OutputDataReceived; p.ErrorDataReceived += outRecv.OutputDataReceived; p.BeginErrorReadLine(); p.BeginOutputReadLine(); try { bool isAttached = false; // start the attach with the GIL held AutoResetEvent attachStarted = new AutoResetEvent(false); AutoResetEvent attachDone = new AutoResetEvent(false); // We run the Attach and StartListeningAsync on a separate thread, // because StartListeningAsync waits until debuggee has connected // back (which it won't do until handle is set). var task = Task.Run(async() => { var proc = PythonProcess.Attach(p.Id); try { proc.ProcessLoaded += (sender, args) => { attachDone.Set(); isAttached = false; }; attachStarted.Set(); await proc.StartListeningAsync(10000); } finally { await DetachProcessAsync(proc); } }); Assert.IsTrue(attachStarted.WaitOne(10000), "Failed to start attaching within 10s"); Assert.IsFalse(isAttached, "should not have attached yet"); // we should be blocked handle.Set(); // let the code start running Assert.IsTrue(attachDone.WaitOne(10000), "Failed to attach within 10s"); } finally { Debug.WriteLine(String.Format("Process output: {0}", outRecv.Output.ToString())); DisposeProcess(p); } }
public async Task RunAsync() { PythonThread thread = await _tests.RunAndBreakAsync(FileName, LineNo, breakFilename : BreakFileName, arguments : Arguments, processLoaded : ProcessLoaded, debugOptions : DebugOptions); PythonProcess process = thread.Process; try { var frames = thread.Frames; var localNamesExpected = Locals.Select(v => v.Expression).ToSet(); var paramNamesExpected = Params.Select(v => v.Expression).ToSet(); string fileNameExpected; if (BreakFileName == null) { fileNameExpected = Path.GetFullPath(_tests.DebuggerTestPath + FileName); } else if (Path.IsPathRooted(BreakFileName)) { fileNameExpected = BreakFileName; } else { fileNameExpected = Path.GetFullPath(_tests.DebuggerTestPath + BreakFileName); } Assert.AreEqual(frames[0].FileName, fileNameExpected, true); if (!IgnoreExtra) { AssertUtil.ContainsExactly(frames[0].Locals.Select(x => x.Expression), localNamesExpected); AssertUtil.ContainsExactly(frames[0].Parameters.Select(x => x.Expression), paramNamesExpected); } foreach (var expectedLocal in Locals) { var actualLocal = frames[0].Locals.First(v => v.Expression == expectedLocal.Expression); expectedLocal.Validate(actualLocal); } foreach (var expectedParam in Params) { var actualParam = frames[0].Parameters.First(v => v.Expression == expectedParam.Expression); expectedParam.Validate(actualParam); } await process.ResumeAsync(TimeoutToken()); if (WaitForExit) { _tests.WaitForExit(process); } } finally { if (!process.HasExited) { process.Terminate(); } } }
internal async Task DetachProcessAsync(PythonProcess p) { try { await p.DetachAsync(TimeoutToken()); } catch (Exception ex) { Console.WriteLine("Failed to detach process"); Console.WriteLine(ex); } }
public PythonBreakpoint(PythonProcess process, string filename, int lineNo, string condition, bool breakWhenChanged, int breakpointId) { _process = process; _filename = filename; _lineNo = lineNo; _breakpointId = breakpointId; _condition = condition; _breakWhenChanged = breakWhenChanged; }
public virtual async Task AttachAndStepWithBlankSysPrefix() { string script = TestData.GetPath(@"TestData\DebuggerProject\InfiniteRunBlankPrefix.py"); var p = Process.Start(Version.InterpreterPath, "\"" + script + "\""); try { using (var dumpWriter = new MiniDumpWriter(p)) { Thread.Sleep(1000); var proc = PythonProcess.Attach(p.Id); try { var attached = new TaskCompletionSource <bool>(); proc.ProcessLoaded += async(sender, args) => { Console.WriteLine("Process loaded"); await proc.ResumeAsync(TimeoutToken()); attached.SetResult(true); }; await proc.StartListeningAsync(); await attached.Task.WithTimeout(20000, "Failed to attach within 20s"); var bpHit = new TaskCompletionSource <bool>(); PythonThread thread = null; PythonStackFrame oldFrame = null; proc.BreakpointHit += (sender, args) => { Console.WriteLine("Breakpoint hit"); thread = args.Thread; oldFrame = args.Thread.Frames[0]; bpHit.SetResult(true); }; var bp = proc.AddBreakpoint(script, 6); await bp.AddAsync(TimeoutToken()); await bpHit.Task.WithTimeout(20000, "Failed to hit breakpoint within 20s"); var stepComplete = new TaskCompletionSource <bool>(); PythonStackFrame newFrame = null; proc.StepComplete += (sender, args) => { newFrame = args.Thread.Frames[0]; stepComplete.SetResult(true); }; await thread.StepOverAsync(TimeoutToken()); await stepComplete.Task.WithTimeout(20000, "Failed to complete the step within 20s"); Assert.AreEqual(oldFrame.FileName, newFrame.FileName); Assert.IsTrue(oldFrame.LineNo + 1 == newFrame.LineNo); } finally { await DetachProcessAsync(proc); } dumpWriter.Cancel(); } } finally { DisposeProcess(p); } }
internal void TerminateProcess(PythonProcess p) { try { p.Terminate(); } catch (Exception ex) { Console.WriteLine("Failed to detach process"); Console.WriteLine(ex); } }
private async Task AttachAsync(string filename, int lineNo) { var debugger = new PythonDebugger(); PythonProcess process = debugger.DebugProcess(Version, DebuggerTestPath + filename, null, async(newproc, newthread) => { var breakPoint = newproc.AddBreakpointByFileExtension(lineNo, filename); await breakPoint.AddAsync(TimeoutToken()); }); _processes.Add(process); long?threadAtBreakpoint = null; using (var brkHit = new AutoResetEvent(false)) using (var procExited = new AutoResetEvent(false)) { EventHandler <BreakpointHitEventArgs> breakpointHitHandler = (s, e) => { threadAtBreakpoint = e.Thread.Id; SafeSetEvent(brkHit); }; EventHandler <ProcessExitedEventArgs> processExitedHandler = (s, e) => SafeSetEvent(procExited); process.BreakpointHit += breakpointHitHandler; process.ProcessExited += processExitedHandler; try { await process.StartAsync(); } catch (Win32Exception ex) { _processes.Remove(process); if (ex.HResult == -2147467259 /*0x80004005*/) { Assert.Inconclusive("Required Python interpreter is not installed"); } else { Assert.Fail("Process start failed:\r\n" + ex.ToString()); } } var handles = new[] { brkHit, procExited }; if (WaitHandle.WaitAny(handles, 25000) != 0) { Assert.Fail("Failed to wait on event"); } process.BreakpointHit -= breakpointHitHandler; process.ProcessExited -= processExitedHandler; } await _evaluator.AttachProcessAsync(process, new MockThreadIdMapper()); // AttachProcessAsync calls InitializeAsync which sets the active // thread by using the DTE (which is null in these tests), so we // adjust it to the correct thread where breakpoint was hit. if (threadAtBreakpoint != null) { _evaluator.ChangeActiveThread(threadAtBreakpoint.Value, false); } }
void Update() { if (pro != null) { if (pro.Update()) { pro = null; } } }
public PythonDebugProcessReplEvaluator(IServiceProvider serviceProvider, PythonProcess process, PythonToolsService pyService, IThreadIdMapper threadIdMapper) : base(serviceProvider, pyService, GetOptions(serviceProvider, pyService)) { _process = process; _threadIdMapper = threadIdMapper; _threadId = process.GetThreads()[0].Id; _languageVersion = process.LanguageVersion; EnsureConnected(); }
public PythonDebugProcessReplEvaluator(IServiceProvider serviceProvider, PythonProcess process, IThreadIdMapper threadIdMapper) : base(serviceProvider) { _process = process; _threadIdMapper = threadIdMapper; _threadId = process.GetThreads()[0].Id; _languageVersion = process.LanguageVersion; _currentScopeName = CurrentFrameScopeFixedName; DisplayName = Strings.DebugReplDisplayName; }
internal static string ReformatStackTrace(PythonProcess process, string data) { var lines = new Stack <IEnumerable <string> >(); var sb = new StringBuilder(); using (var reader = new StringReader(data)) { for (var line = reader.ReadLine(); line != null; line = reader.ReadLine()) { lines.Push(SplitReprs(line).ToArray()); } } foreach (var line in lines) { var filename = line.ElementAtOrDefault(0); var lineNumber = line.ElementAtOrDefault(1); var functionName = line.ElementAtOrDefault(2); //var text = stackLine.ElementAtOrDefault(3); int lineNo; if (process != null && !string.IsNullOrEmpty(filename) && !string.IsNullOrEmpty(lineNumber) && int.TryParse(lineNumber, out lineNo) && !string.IsNullOrEmpty(functionName)) { functionName = PythonStackFrame.GetQualifiedFunctionName(process, filename, lineNo, functionName); } if (string.IsNullOrEmpty(functionName)) { functionName = Strings.DebugUnknownFunctionName; } if (!string.IsNullOrEmpty(filename)) { sb.AppendLine(string.IsNullOrEmpty(lineNumber) ? Strings.DebugPythonExceptionStackTraceFileOnly.FormatUI(filename, functionName) : Strings.DebugPythonExceptionStackTraceFileAndLineNumber.FormatUI(filename, lineNumber, functionName) ); } else { sb.AppendLine(functionName); } } while (sb.Length > 0 && char.IsWhiteSpace(sb[sb.Length - 1])) { sb.Length -= 1; } return(sb.ToString()); }
public PythonDebugProcessReplEvaluator(IServiceProvider serviceProvider, PythonProcess process, IThreadIdMapper threadIdMapper) : base(serviceProvider) { _process = process; _threadIdMapper = threadIdMapper; _threadId = process.GetThreads()[0].Id; _languageVersion = process.LanguageVersion; DisplayName = "Debug"; EnsureConnectedOnCreate(); }
public virtual void AttachWithOutputRedirection() { var expectedOutput = new[] { "stdout", "stderr" }; string script = TestData.GetPath(@"TestData\DebuggerProject\AttachOutput.py"); var p = Process.Start(Version.InterpreterPath, "\"" + script + "\""); try { Thread.Sleep(1000); var proc = PythonProcess.Attach(p.Id, PythonDebugOptions.RedirectOutput); try { var attached = new AutoResetEvent(false); proc.ProcessLoaded += (sender, args) => { Console.WriteLine("Process loaded"); attached.Set(); }; proc.StartListening(); Assert.IsTrue(attached.WaitOne(20000), "Failed to attach within 20s"); proc.Resume(); var bpHit = new AutoResetEvent(false); PythonThread thread = null; proc.BreakpointHit += (sender, args) => { thread = args.Thread; bpHit.Set(); }; var bp = proc.AddBreakPoint(script, 5); bp.Add(); Assert.IsTrue(bpHit.WaitOne(20000), "Failed to hit breakpoint within 20s"); Assert.IsNotNull(thread); var actualOutput = new List <string>(); proc.DebuggerOutput += (sender, e) => { Console.WriteLine("Debugger output: '{0}'", e.Output); actualOutput.Add(e.Output); }; var frame = thread.Frames[0]; Assert.AreEqual("False", frame.ExecuteTextAsync("attached").Result.StringRepr); Assert.IsTrue(frame.ExecuteTextAsync("attached = True").Wait(20000), "Failed to complete evaluation within 20s"); proc.Resume(); WaitForExit(proc); AssertUtil.ArrayEquals(expectedOutput, actualOutput); } finally { DetachProcess(proc); } } finally { DisposeProcess(p); } }
/// <summary> /// Creates a PythonObject for an expression which successfully returned a value. /// </summary> public PythonEvaluationResult(PythonProcess process, string objRepr, string hexRepr, string typeName, long length, string expression, string childName, PythonStackFrame frame, PythonEvaluationResultFlags flags) { _process = process; _objRepr = objRepr; _hexRepr = hexRepr; _typeName = typeName; _length = length; _expression = expression; _childName = childName; _frame = frame; _flags = flags; }
public static void Init() { string pythonPath = $"{Entity.Type.Resource.Instance.Directory}/{PythonProgram}"; string kerasPath = $"{Entity.Type.Resource.Instance.Directory}/{KerasScript}"; if (!IsProcessRunning && File.Exists(kerasPath)) { IsProcessRunning = true; Server = new TcpListener(IPAddress.Loopback, 0); Server.Start(); int port = ((IPEndPoint)Server.LocalEndpoint).Port; Debug.WriteLine($"Running server on port {port}"); PythonProcess.StartInfo.FileName = pythonPath; PythonProcess.StartInfo.Arguments = $"\"{kerasPath}\" -p {port}"; PythonProcess.Start(); DateTime startTime = DateTime.Now; while ((DateTime.Now - startTime).Seconds < 10) { if (Server.Pending()) { Client = Server.AcceptTcpClient(); break; } Thread.Sleep(100); } if (Client == null) { throw new SocketException((int)SocketError.TimedOut); } Input = new StreamWriter(Client.GetStream()) { AutoFlush = false }; Output = new StreamReader(Client.GetStream()); ProcessThread = Task .Run(() => { PythonProcess.WaitForExit(); Server.Stop(); }) .ContinueWith(t => IsProcessRunning = false); } }
internal void WaitForExit(PythonProcess process, bool assert = true) { bool exited = process.WaitForExit(DefaultWaitForExitTimeout); if (!exited) { process.Terminate(); if (assert) { Assert.Fail("Timeout while waiting for Python process to exit."); } } }
internal void SwitchProcess(PythonProcess process, bool verbose) { var newEvaluator = _evaluators[process.Id]; if (newEvaluator != _activeEvaluator) { _activeEvaluator = newEvaluator; ActiveProcessChanged(); if (verbose) { CurrentWindow.WriteLine(Strings.DebugReplSwitchProcessOutput.FormatUI(process.Id)); } } }
internal void SwitchProcess(PythonProcess process, bool verbose) { var newEvaluator = _evaluators[process.Id]; if (newEvaluator != _activeEvaluator) { _activeEvaluator = newEvaluator; ActiveProcessChanged(); if (verbose) { _window.WriteLine(String.Format("Current process changed to {0}", process.Id)); } } }
// Launches a process by means of the debug engine. // Normally, Visual Studio launches a program using the IDebugPortEx2::LaunchSuspended method and then attaches the debugger // to the suspended program. However, there are circumstances in which the debug engine may need to launch a program // (for example, if the debug engine is part of an interpreter and the program being debugged is an interpreted language), // in which case Visual Studio uses the IDebugEngineLaunch2::LaunchSuspended method // The IDebugEngineLaunch2::ResumeProcess method is called to start the process after the process has been successfully launched in a suspended state. int IDebugEngineLaunch2.LaunchSuspended(string pszServer, IDebugPort2 port, string exe, string args, string dir, string env, string options, enum_LAUNCH_FLAGS launchFlags, uint hStdInput, uint hStdOutput, uint hStdError, IDebugEventCallback2 ad7Callback, out IDebugProcess2 process) { process = null; if (_mixedMode) { return VSConstants.E_NOTIMPL; } Debug.WriteLine("--------------------------------------------------------------------------------"); Debug.WriteLine("PythonEngine LaunchSuspended Begin " + launchFlags + " " + GetHashCode()); AssertMainThread(); Debug.Assert(_events == null); Debug.Assert(_process == null); Debug.Assert(_ad7ProgramId == Guid.Empty); _events = ad7Callback; _engineCreated = _programCreated = false; _loadComplete.Reset(); if (options != null) { ParseOptions(options); } Send(new AD7CustomEvent(VsPackageMessage.SetDebugOptions, this), AD7CustomEvent.IID, null, null); // If this is a windowed application, there's no console to wait on, so disable those flags if they were set. if (_debugOptions.HasFlag(PythonDebugOptions.IsWindowsApplication)) { _debugOptions &= ~(PythonDebugOptions.WaitOnNormalExit | PythonDebugOptions.WaitOnAbnormalExit); } Guid processId; if (_debugOptions.HasFlag(PythonDebugOptions.AttachRunning)) { if (!Guid.TryParse(exe, out processId)) { Debug.Fail("When PythonDebugOptions.AttachRunning is used, the 'exe' parameter must be a debug session GUID."); return VSConstants.E_INVALIDARG; } _process = DebugConnectionListener.GetProcess(processId); _attached = true; _pseudoAttach = true; } else { _process = new PythonProcess(_languageVersion, exe, args, dir, env, _interpreterOptions, _debugOptions, _dirMapping); } if (!_debugOptions.HasFlag(PythonDebugOptions.AttachRunning)) { _process.Start(false); } AttachEvents(_process); AD_PROCESS_ID adProcessId = new AD_PROCESS_ID(); adProcessId.ProcessIdType = (uint)enum_AD_PROCESS_ID.AD_PROCESS_ID_SYSTEM; adProcessId.dwProcessId = (uint)_process.Id; EngineUtils.RequireOk(port.GetProcess(adProcessId, out process)); Debug.WriteLine("PythonEngine LaunchSuspended returning S_OK"); Debug.Assert(process != null); Debug.Assert(!_process.HasExited); return VSConstants.S_OK; }
// Called by the SDM to indicate that a synchronous debug event, previously sent by the DE to the SDM, // was received and processed. int IDebugEngine2.ContinueFromSynchronousEvent(IDebugEvent2 eventObject) { if (_mixedMode) { return VSConstants.E_NOTIMPL; } AssertMainThread(); if (eventObject is AD7ProgramDestroyEvent) { var debuggedProcess = _process; _events = null; _process = null; _ad7ProgramId = Guid.Empty; foreach (var thread in _threads.Values) { thread.Dispose(); } _threads.Clear(); _modules.Clear(); debuggedProcess.Dispose(); } else if (eventObject is AD7CustomEvent) { } else { Debug.Fail("Unknown synchronous event"); } return VSConstants.S_OK; }
// Attach the debug engine to a program. int IDebugEngine2.Attach(IDebugProgram2[] rgpPrograms, IDebugProgramNode2[] rgpProgramNodes, uint celtPrograms, IDebugEventCallback2 ad7Callback, enum_ATTACH_REASON dwReason) { Debug.WriteLine("PythonEngine Attach Begin " + GetHashCode()); AssertMainThread(); Debug.Assert(_ad7ProgramId == Guid.Empty); if (celtPrograms != 1) { Debug.Fail("Python debugging only supports one program in a process"); throw new ArgumentException(); } var program = rgpPrograms[0]; int processId = EngineUtils.GetProcessId(program); if (processId == 0) { // engine only supports system processes Debug.WriteLine("PythonEngine failed to get process id during attach"); return VSConstants.E_NOTIMPL; } EngineUtils.RequireOk(program.GetProgramId(out _ad7ProgramId)); // Attach can either be called to attach to a new process, or to complete an attach // to a launched process if (_process == null) { _events = ad7Callback; Send(new AD7CustomEvent(VsPackageMessage.SetDebugOptions, this), AD7CustomEvent.IID, null); // Check whether we're debugging Python alongside something else. If so, let Concord handle everything. if (!IsDebuggingPythonOnly(program)) { _attached = true; _mixedMode = true; AD7EngineCreateEvent.Send(this); AD7ProgramCreateEvent.Send(this); AD7LoadCompleteEvent.Send(this); Debug.WriteLine("PythonEngine Attach bailing out early - mixed-mode debugging"); return VSConstants.S_OK; } // Check if we're attaching remotely using the Python remote debugging transport var remoteProgram = program as PythonRemoteDebugProgram; try { if (remoteProgram != null) { var remotePort = remoteProgram.DebugProcess.DebugPort; var uriBuilder = new UriBuilder(remotePort.Uri); string query = uriBuilder.Query ?? ""; if (query.Length > 0) { // Strip leading "?" - UriBuilder.Query getter returns it as part of the string, but the setter // will automatically prepend it even if it was already there, producing a malformed query. query = query.Substring(1); } query += "&" + DebugOptionsKey + "=" + _debugOptions; uriBuilder.Query = query; _process = PythonRemoteProcess.Attach(uriBuilder.Uri, true); } else { _process = PythonProcess.Attach(processId, _debugOptions); } } catch (ConnectionException ex) { MessageBox.Show("Failed to attach debugger:\r\n" + ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error); return VSConstants.E_FAIL; } AttachEvents(_process); _attached = true; } else { if (processId != _process.Id) { Debug.Fail("Asked to attach to a process while we are debugging"); return VSConstants.E_FAIL; } } AD7EngineCreateEvent.Send(this); lock (_syncLock) { _engineCreated = true; if (_isProgramCreateDelayed) { _isProgramCreateDelayed = false; SendProgramCreate(); } } Debug.WriteLine("PythonEngine Attach returning S_OK"); return VSConstants.S_OK; }
private void AttachEvents(PythonProcess process) { process.Connected += OnConnected; process.ProcessLoaded += OnProcessLoaded; process.ModuleLoaded += OnModuleLoaded; process.ThreadCreated += OnThreadCreated; process.BreakpointBindFailed += OnBreakpointBindFailed; process.BreakpointBindSucceeded += OnBreakpointBindSucceeded; process.BreakpointHit += OnBreakpointHit; process.EntryPointHit += OnEntryPointHit; process.AsyncBreakComplete += OnAsyncBreakComplete; process.ExceptionRaised += OnExceptionRaised; process.ProcessExited += OnProcessExited; process.StepComplete += OnStepComplete; process.ThreadExited += OnThreadExited; process.DebuggerOutput += OnDebuggerOutput; process.StartListening(); }