Wie Anhängen des Debuggers an ein python-subproccess?

Ich Debuggen müssen, ein Kind-Prozess erzeugt, indem multiprocessing.Process(). Die pdb degugger scheint zu sein, nichts von "forking" und nicht in der Lage zu befestigen, in bereits laufende Prozesse.

Gibt es intelligentere python-Debugger, die angeschlossen werden können, um einen Teilprozess?

InformationsquelleAutor grep | 2011-01-17

12

Winpdb ist so ziemlich die definition von intelligenter Python-debugger. Es unterstützt explizit going down Gabel, nicht sicher, es funktioniert gut mit multiprocessing.Process() aber einen Versuch ist es Wert.

Für eine Liste von Kandidaten zu überprüfen, wenn Sie Unterstützung für Ihren Fall finden Sie in der Liste Python-Debugger in der wiki.
- Super!!! Winpdb funktioniert gut mit multiprocessing.Prozess()
- Es sollte angemerkt werden, dass Winpdb ist multi-Plattform, die kostenlos und Freie software.
- Ich konnte es nicht, innerhalb von 20 Minuten der Lesung über und spielen mit winpdb, einen Weg zu finden starten Sie eine interaktive debugging-Sitzung in ein bestehendes Skript über eine import -, a-la -import pdb; pdb.set_trace(). Jedoch, die ForkedPdb Antwort hier arbeitete wie ein Charme!
InformationsquelleAutor TryPyPy
51

Ich habe die Suche nach einer einfachen Lösung für dieses problem und kam mit dieser:
```
import sys
import pdb

class ForkedPdb(pdb.Pdb):
    """A Pdb subclass that may be used
    from a forked multiprocessing child

    """
    def interaction(self, *args, **kwargs):
        _stdin = sys.stdin
        try:
            sys.stdin = open('/dev/stdin')
            pdb.Pdb.interaction(self, *args, **kwargs)
        finally:
            sys.stdin = _stdin
```
Es verwenden die gleiche Weise könnten Sie die klassischen Pdb:
```
ForkedPdb().set_trace()
```
- das ist genial und hat den trick für mich
- Danke, dieser arbeitete für mich auch.
- Netter trick. Ich schlage vor, die Speicherung von sys.stdin, wenn das Programm gestartet wird und mit diesem in die Gabel Prozess anstelle der öffnung /dev/stdin. Ich weiß nicht, wieso, aber readline funktioniert dann. Ich werde die Forschung ein bisschen dazu später.
- Gut, fand ich eine robustere Lösung dafür, dass die fd von stdin zu starten. Ich denke readline ist immer aufgerufen, dass man, Lesen Sie bitte meine Antwort.
- Geist zu erklären ein wenig, wie und warum funktioniert das?
InformationsquelleAutor Romuald Brunet
6

Dies ist eine Ausarbeitung von Romuald Antwort, das wieder die original stdin über Datei-Deskriptor. Dies hält readline arbeiten im debugger. Außerdem pdb speziellen management von KeyboardInterrupt deaktiviert ist, um es nicht zu stören, multiprocessing sigint-handler.
```
class ForkablePdb(pdb.Pdb):

    _original_stdin_fd = sys.stdin.fileno()
    _original_stdin = None

    def __init__(self):
        pdb.Pdb.__init__(self, nosigint=True)

    def _cmdloop(self):
        current_stdin = sys.stdin
        try:
            if not self._original_stdin:
                self._original_stdin = os.fdopen(self._original_stdin_fd)
            sys.stdin = self._original_stdin
            self.cmdloop()
        finally:
            sys.stdin = current_stdin
```
- This keeps readline working inside the debugger was bedeutet das ?
- Er stellt den stream readline befestigt ist, um als stdin des aktuellen Prozesses.
- wie unterscheidet sich das von oben beantworten...ich meine, was macht es für einen Unterschied oder das, was mehr ist, fügt es...sry für naiv....weniger Informationen
- Es funktioniert, wenn Sie Debuggen mehrerer Prozesse, neben der sigint-feature, soweit ich mich erinnern kann.
- so, wie pro Ihre Lösung, pdb funktionieren, auch wenn wir umspannen einen neuen Prozess durch Multiprozess ?
- Das war die Idee.
InformationsquelleAutor memeplex

Gebäude auf @memplex Idee, ich musste es ändern, um es an die Arbeit mit joblib durch die Einstellung der sys.stdin im Konstruktor als auch die übergabe direkt an der via joblib.

import os
import pdb
import signal
import sys
import joblib

_original_stdin_fd = None

class ForkablePdb(pdb.Pdb):
    _original_stdin = None
    _original_pid = os.getpid()

    def __init__(self):
        pdb.Pdb.__init__(self)
        if self._original_pid != os.getpid():
            if _original_stdin_fd is None:
                raise Exception("Must set ForkablePdb._original_stdin_fd to stdin fileno")

            self.current_stdin = sys.stdin
            if not self._original_stdin:
                self._original_stdin = os.fdopen(_original_stdin_fd)
            sys.stdin = self._original_stdin

    def _cmdloop(self):
        try:
            self.cmdloop()
        finally:
            sys.stdin = self.current_stdin

def handle_pdb(sig, frame):
    ForkablePdb().set_trace(frame)

def test(i, fileno):
    global _original_stdin_fd
    _original_stdin_fd = fileno
    while True:
        pass    

if __name__ == '__main__':
    print "PID: %d" % os.getpid()
    signal.signal(signal.SIGUSR2, handle_pdb)
    ForkablePdb().set_trace()
    fileno = sys.stdin.fileno()
    joblib.Parallel(n_jobs=2)(joblib.delayed(test)(i, fileno) for i in range(10))

InformationsquelleAutor brian.keng

Eine Idee, die ich hatte, war die Schaffung von "dummy" - Klassen zu fake die Umsetzung der Methoden, die Sie verwenden, von multiprocessing:

from multiprocessing import Pool


class DummyPool():
    @staticmethod
    def apply_async(func, args, kwds):
        return DummyApplyResult(func(*args, **kwds))

    def close(self): pass
    def join(self): pass


class DummyApplyResult():
    def __init__(self, result):
        self.result = result

    def get(self):
        return self.result


def foo(a, b, switch):
    # set trace when DummyPool is used
    # import ipdb; ipdb.set_trace()
    if switch:
        return b - a
    else:
        return a - b


if __name__ == '__main__':
    xml = etree.parse('C:/Users/anmendoza/Downloads/jim - 8.1/running-config.xml')
    pool = DummyPool()  # switch between Pool() and DummyPool() here
    results = []
    results.append(pool.apply_async(foo, args=(1, 100), kwds={'switch': True}))
    pool.close()
    pool.join()
    results[0].get()

InformationsquelleAutor atm

-1

Wenn Sie auf einer unterstützten Plattform, versuchen DTrace. Die meisten BSD /Solaris /OS-X-Familie Unterstützung von DTrace.

Hier ist ein intro von der Autorin. Sie können verwenden Sie Dtrace zum Debuggen einfach über alles.

Hier ist SO ein post auf das lernen DTrace.

InformationsquelleAutor the wolf

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.