def test_sys_exitfunc(): import clr inputScript = testpath.test_inputs_dir + "\\exitFuncRuns.py" ipi = IronPythonInstance(executable, exec_prefix, extraArgs + " \"" + inputScript + "\"") (result, output, output2, exitCode) = ipi.StartAndRunToCompletion() AreEqual(exitCode, 0) AreEqual(output.find('hello world') > -1, True) ipi.End() args = extraArgs if clr.GetCurrentRuntime().Configuration.DebugMode: args = "-D " + args inputScript = testpath.test_inputs_dir + "\\exitFuncRaises.py" ipi = IronPythonInstance(executable, exec_prefix, args + " \"" + inputScript + "\"") (result, output, output2, exitCode) = ipi.StartAndRunToCompletion() AreEqual(exitCode, 0) AreEqual(output2.find('Error in sys.exitfunc:') > -1, True) AreEqual(output2.find('exitFuncRaises.py", line 19, in foo') > -1, True) ipi.End() # verify sys.exit(True) and sys.exit(False) return 1 and 0 ipi = IronPythonInstance(executable, exec_prefix, '-c "import sys; sys.exit(False)"') res = ipi.StartAndRunToCompletion() AreEqual(res[0], True) # should have started AreEqual(res[1], '') # no std out AreEqual(res[2], '') # no std err AreEqual(res[3], 0) # should return 0 ipi = IronPythonInstance(executable, exec_prefix, '-c "import sys; sys.exit(True)"') res = ipi.StartAndRunToCompletion() AreEqual(res[0], True) # should have started AreEqual(res[1], '') # no std out AreEqual(res[2], '') # no std err AreEqual(res[3], 1) # should return 0 # and verify it works at the interactive console as well ipi = IronPythonInstance(executable, exec_prefix, extraArgs) AreEqual(ipi.Start(), True) # parameterless exception ipi.ExecuteLine("import sys") AreEqual(ipi.ExecuteAndExit("sys.exit(False)"), 0) # and verify it works at the interactive console as well ipi = IronPythonInstance(executable, exec_prefix, extraArgs) AreEqual(ipi.Start(), True) # parameterless exception ipi.ExecuteLine("import sys") AreEqual(ipi.ExecuteAndExit("sys.exit(True)"), 1)
def execute_code_work_item(self): _debug_write('Executing: ' + repr(self.current_code)) stripped_code = self.current_code.strip() if sys.platform == 'cli': code_to_send = '' for line in stripped_code.split('\n'): stripped = line.strip() if (stripped.startswith('#') or not stripped) and not code_to_send: continue code_to_send += line + '\n' code = python_context.CreateSnippet(code_to_send, None, SourceCodeKind.InteractiveCode) dispatcher = clr.GetCurrentRuntime().GetLanguage( PythonContext).GetCommandDispatcher() if dispatcher is not None: dispatcher(self.python_executor(code)) else: code.Execute(self.exec_mod) else: code = compile(self.current_code, '<stdin>', 'single', self.code_flags) self.code_flags |= (code.co_flags & BasicReplBackend.future_bits) exec(code, self.exec_mod.__dict__, self.exec_mod.__dict__) self.current_code = None
def parse_text(text): errorSink = MyErrorSink() sourceUnit = SourceUnit( clr.GetCurrentRuntime().GetLanguageByName('python'), MyTextContentProvider(text), 'foo', SourceCodeKind.File) parser = Parser.CreateParser( CompilerContext(sourceUnit, PythonCompilerOptions(), errorSink), PythonOptions()) parser.ParseFile(True) return errorSink
def setUp(self): super(MemoryTest, self).setUp() import clr clr.AddReference("Microsoft.Dynamic") from Microsoft.Scripting.Generation import Snippets self.skipMemoryCheck = Snippets.Shared.SaveSnippets or clr.GetCurrentRuntime().Configuration.DebugMode self.expectedMem = 24000 # account for adaptive compilation if is_cli64: self.expectedMem = int(self.expectedMem*1.25)
def get_dynamic_operations_field(): if ClrClass.dynamic_operations_field: return ClrClass.dynamic_operations_field python_context = clr.GetCurrentRuntime().GetLanguage(PythonContext) dynamic_operations = DynamicOperations(python_context) typegen = Snippets.Shared.DefineType( "DynamicOperationsHolder" + str(hash(python_context)), object, True, False) typebld = typegen.TypeBuilder typebld.DefineField("DynamicOperations", DynamicOperations, FieldAttributes.Public | FieldAttributes.Static) new_type = typebld.CreateType() ClrClass.dynamic_operations_field = new_type.GetField( "DynamicOperations") ClrClass.dynamic_operations_field.SetValue(None, dynamic_operations) return ClrClass.dynamic_operations_field
are.Set() def start(): try: global app app = Application() app.Startup += on_startup app.ShutdownMode = ShutdownMode.OnExplicitShutdown app.Run() finally: clr.SetCommandDispatcher(None) # If dispatcher is set, then assume that UI issues are already taken care of. currentDispatcher = clr.GetCurrentRuntime().GetLanguage( PythonContext).GetCommandDispatcher() if currentDispatcher is None: if Application.Current is None: dispatcher = None else: dispatcher = Application.Current.Dispatcher if dispatcher is None: t = Thread(ThreadStart(start)) t.IsBackground = True t.ApartmentState = ApartmentState.STA t.Start() are.WaitOne() else: clr.SetCommandDispatcher(currentDispatcher) def DispatchConsoleCommand(consoleCommand): if consoleCommand:
def test_engine_access_from_within(): import clr from Microsoft.Scripting.Hosting import ScriptEngine pc = clr.GetCurrentRuntime().GetLanguageByName('python') engine = pc.GetModuleState(clr.GetClrType(ScriptEngine)) Assert(engine is not None)
# # ##################################################################################### from iptest.assert_util import * skiptest("win32") skiptest("silverlight") #no time.clock or GetTotalMemory import clr clr.AddReference("Microsoft.Dynamic") from Microsoft.Scripting.Generation import Snippets import gc skipMemoryCheck = Snippets.Shared.SaveSnippets or clr.GetCurrentRuntime( ).Configuration.DebugMode from time import clock # GetTotalMemory() actually pulls in System def evalLoop(N): for i in range(N): func = compile(code, '<>', 'exec') eval(func) def evalTest(N): startMem = GetTotalMemory() startTime = clock() evalLoop(N)
def enable_attach(secret, address=('0.0.0.0', DEFAULT_PORT), certfile=None, keyfile=None, redirect_output=True): """Enables Python Tools for Visual Studio to attach to this process remotely to debug Python code. Parameters ---------- secret : str Used to validate the clients - only those clients providing the valid secret will be allowed to connect to this server. On client side, the secret is prepended to the Qualifier string, separated from the hostname by ``'@'``, e.g.: ``'[email protected]:5678'``. If secret is ``None``, there's no validation, and any client can connect freely. address : (str, int), optional Specifies the interface and port on which the debugging server should listen for TCP connections. It is in the same format as used for regular sockets of the `socket.AF_INET` family, i.e. a tuple of ``(hostname, port)``. On client side, the server is identified by the Qualifier string in the usual ``'hostname:port'`` format, e.g.: ``'myhost.cloudapp.net:5678'``. Default is ``('0.0.0.0', 5678)``. certfile : str, optional Used to enable SSL. If not specified, or if set to ``None``, the connection between this program and the debugger will be unsecure, and can be intercepted on the wire. If specified, the meaning of this parameter is the same as for `ssl.wrap_socket`. keyfile : str, optional Used together with `certfile` when SSL is enabled. Its meaning is the same as for ``ssl.wrap_socket``. redirect_output : bool, optional Specifies whether any output (on both `stdout` and `stderr`) produced by this program should be sent to the debugger. Default is ``True``. Notes ----- This function returns immediately after setting up the debugging server, and does not block program execution. If you need to block until debugger is attached, call `ptvsd.wait_for_attach`. The debugger can be detached and re-attached multiple times after `enable_attach` is called. This function can only be called once during the lifetime of the process. On a second call, `AttachAlreadyEnabledError` is raised. In circumstances where the caller does not control how many times the function will be called (e.g. when a script with a single call is run more than once by a hosting app or framework), the call should be wrapped in ``try..except``. Only the thread on which this function is called, and any threads that are created after it returns, will be visible in the debugger once it is attached. Any threads that are already running before this function is called will not be visible. """ if not ssl and (certfile or keyfile): raise ValueError( 'could not import the ssl module - SSL is not supported on this version of Python' ) if sys.platform == 'cli': import clr x_tracing = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Tracing x_frames = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Frames if not x_tracing or not x_frames: raise RuntimeError( 'IronPython must be started with -X:Tracing and -X:Frames options to support PTVS remote debugging.' ) global _attach_enabled if _attach_enabled: raise AttachAlreadyEnabledError( 'ptvsd.enable_attach() has already been called in this process.') _attach_enabled = True atexit.register(vspd.detach_process_and_notify_debugger) server = socket.socket(proto=socket.IPPROTO_TCP) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind(address) server.listen(1) def server_thread_func(): while True: client = None raw_client = None try: client, addr = server.accept() if certfile: client = ssl.wrap_socket(client, server_side=True, ssl_version=ssl.PROTOCOL_TLSv1, certfile=certfile, keyfile=keyfile) write_bytes(client, PTVSDBG) write_int(client, PTVSDBG_VER) response = read_bytes(client, 7) if response != PTVSDBG: continue dbg_ver = read_int(client) if dbg_ver != PTVSDBG_VER: continue client_secret = read_string(client) if secret is None or secret == client_secret: write_bytes(client, ACPT) else: write_bytes(client, RJCT) continue response = read_bytes(client, 4) if response == INFO: try: pid = os.getpid() except AttributeError: pid = 0 write_int(client, pid) exe = sys.executable or '' write_string(client, exe) try: username = getpass.getuser() except AttributeError: username = '' write_string(client, username) try: impl = platform.python_implementation() except AttributeError: try: impl = sys.implementation.name except AttributeError: impl = 'Python' major, minor, micro, release_level, serial = sys.version_info os_and_arch = platform.system() if os_and_arch == "": os_and_arch = sys.platform try: if sys.maxsize > 2**32: os_and_arch += ' 64-bit' else: os_and_arch += ' 32-bit' except AttributeError: pass version = '%s %s.%s.%s (%s)' % (impl, major, minor, micro, os_and_arch) write_string(client, version) client.recv(1) elif response == ATCH: debug_options = vspd.parse_debug_options( read_string(client)) debug_options.setdefault('rules', []).append({ 'path': PY_ROOT, 'include': False, }) if redirect_output: debug_options.add('RedirectOutput') if vspd.DETACHED: write_bytes(client, ACPT) try: pid = os.getpid() except AttributeError: pid = 0 write_int(client, pid) major, minor, micro, release_level, serial = sys.version_info write_int(client, major) write_int(client, minor) write_int(client, micro) vspd.attach_process_from_socket(client, debug_options, report=True) vspd.mark_all_threads_for_break( vspd.STEPPING_ATTACH_BREAK) _attached.set() client = None else: write_bytes(client, RJCT) elif response == REPL: if not vspd.DETACHED: write_bytes(client, ACPT) vspd.connect_repl_using_socket(client) client = None else: write_bytes(client, RJCT) except (socket.error, OSError): pass finally: if client is not None: client.close() server_thread = threading.Thread(target=server_thread_func) server_thread.setDaemon(True) server_thread.start() frames = [] f = sys._getframe() while True: f = f.f_back if f is None: break frames.append(f) frames.reverse() cur_thread = vspd.new_thread() for f in frames: cur_thread.push_frame(f) def replace_trace_func(): for f in frames: f.f_trace = cur_thread.trace_func replace_trace_func() sys.settrace(cur_thread.trace_func) vspd.intercept_threads(for_attach=True)
def enable_attach(secret, address=('0.0.0.0', ptvsd.DEFAULT_PORT), certfile=None, keyfile=None, redirect_output=True): if not ssl and (certfile or keyfile): raise ValueError( 'could not import the ssl module - SSL is not supported on this version of Python' ) if sys.platform == 'cli': # Check that IronPython was launched with -X:Frames and -X:Tracing, since we can't register our trace # func on the thread that calls enable_attach otherwise import clr x_tracing = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Tracing x_frames = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Frames if not x_tracing or not x_frames: raise RuntimeError( 'IronPython must be started with -X:Tracing and -X:Frames options to support PTVS remote debugging.' ) global _attach_enabled if _attach_enabled: raise ptvsd.AttachAlreadyEnabledError( 'ptvsd.enable_attach() has already been called in this process.') _attach_enabled = True atexit.register(vspd.detach_process_and_notify_debugger) server = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind(address) server.listen(1) def server_thread_func(): while True: client = None connection = None try: client, addr = server.accept() if certfile: client = ssl.wrap_socket(client, server_side=True, ssl_version=ssl.PROTOCOL_TLSv1, certfile=certfile, keyfile=keyfile) connection = AttachLoop(client, secret, redirect_output, None) connection.send_event( name='legacyRemoteConnected', debuggerName=PTVSDBG, debuggerProtocolVersion=PTVSDBG_VER, ) connection.process_messages() except (socket.error, OSError): pass finally: if connection: connection.close() server_thread = threading.Thread(target=server_thread_func) server_thread.setDaemon(True) server_thread.start() frames = [] f = sys._getframe() while f is not None: frames.append(f) f = f.f_back frames.reverse() cur_thread = vspd.new_thread() for f in frames: cur_thread.push_frame(f) def replace_trace_func(): for f in frames: f.f_trace = cur_thread.trace_func replace_trace_func() sys.settrace(cur_thread.trace_func) vspd.intercept_threads(for_attach=True)
if sys.platform == 'cli': # We need special handling to reset the abort for keyboard interrupt exceptions class ReplAbortException(Exception): pass import clr clr.AddReference('Microsoft.Dynamic') clr.AddReference('Microsoft.Scripting') clr.AddReference('IronPython') from Microsoft.Scripting import KeyboardInterruptException from Microsoft.Scripting import ParamDictionaryAttribute from IronPython.Runtime.Operations import PythonOps from IronPython.Runtime import PythonContext from Microsoft.Scripting import SourceUnit, SourceCodeKind from Microsoft.Scripting.Runtime import Scope python_context = clr.GetCurrentRuntime().GetLanguage(PythonContext) from System import DBNull, ParamArrayAttribute builtin_method_descriptor_type = type(list.append) import System NamespaceType = type(System) class _OldClass: pass _OldClassType = type(_OldClass) _OldInstanceType = type(_OldClass()) class BasicReplBackend(ReplBackend): future_bits = 0x3e010 # code flags used to mark future bits
def enable_attach(secret, address = ('0.0.0.0', DEFAULT_PORT), certfile = None, keyfile = None, redirect_output = True): if not ssl and (certfile or keyfile): raise ValueError('could not import the ssl module - SSL is not supported on this version of Python') if sys.platform == 'cli': # Check that IronPython was launched with -X:Frames and -X:Tracing, since we can't register our trace # func on the thread that calls enable_attach otherwise import clr x_tracing = clr.GetCurrentRuntime().GetLanguageByExtension('py').Options.Tracing x_frames = clr.GetCurrentRuntime().GetLanguageByExtension('py').Options.Frames if not x_tracing or not x_frames: raise RuntimeError('IronPython must be started with -X:Tracing and -X:Frames options to support PTVS remote debugging.') global _attach_enabled if _attach_enabled: raise AttachAlreadyEnabledError('ptvsd.enable_attach() has already been called in this process.') _attach_enabled = True atexit.register(vspd.detach_process_and_notify_debugger) server = socket.socket(proto=socket.IPPROTO_TCP) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind(address) server.listen(1) def server_thread_func(): while True: client = None raw_client = None try: client, addr = server.accept() if certfile: client = ssl.wrap_socket(client, server_side = True, ssl_version = ssl.PROTOCOL_TLSv1, certfile = certfile, keyfile = keyfile) write_bytes(client, PTVSDBG) write_int(client, PTVSDBG_VER) response = read_bytes(client, 7) if response != PTVSDBG: continue dbg_ver = read_int(client) if dbg_ver != PTVSDBG_VER: continue client_secret = read_string(client) if secret is None or secret == client_secret: write_bytes(client, ACPT) else: write_bytes(client, RJCT) continue response = read_bytes(client, 4) if response == INFO: try: pid = os.getpid() except AttributeError: pid = 0 write_int(client, pid) exe = sys.executable or '' write_string(client, exe) try: username = getpass.getuser() except AttributeError: username = '' write_string(client, username) try: impl = platform.python_implementation() except AttributeError: try: impl = sys.implementation.name except AttributeError: impl = 'Python' major, minor, micro, release_level, serial = sys.version_info os_and_arch = platform.system() if os_and_arch == "": os_and_arch = sys.platform try: if sys.maxsize > 2**32: os_and_arch += ' 64-bit' else: os_and_arch += ' 32-bit' except AttributeError: pass version = '%s %s.%s.%s (%s)' % (impl, major, minor, micro, os_and_arch) write_string(client, version) # Don't just drop the connection - let the debugger close it after it finishes reading. client.recv(1) elif response == ATCH: debug_options = vspd.parse_debug_options(read_string(client)) debug_options.setdefault('rules', []).append({ 'path': PY_ROOT, 'include': False, }) if redirect_output: debug_options.add('RedirectOutput') if vspd.DETACHED: write_bytes(client, ACPT) try: pid = os.getpid() except AttributeError: pid = 0 write_int(client, pid) major, minor, micro, release_level, serial = sys.version_info write_int(client, major) write_int(client, minor) write_int(client, micro) vspd.attach_process_from_socket(client, debug_options, report = True) vspd.mark_all_threads_for_break(vspd.STEPPING_ATTACH_BREAK) _attached.set() client = None else: write_bytes(client, RJCT) elif response == REPL: if not vspd.DETACHED: write_bytes(client, ACPT) vspd.connect_repl_using_socket(client) client = None else: write_bytes(client, RJCT) except (socket.error, OSError): pass finally: if client is not None: client.close() server_thread = threading.Thread(target = server_thread_func) server_thread.setDaemon(True) server_thread.start() frames = [] f = sys._getframe() while True: f = f.f_back if f is None: break frames.append(f) frames.reverse() cur_thread = vspd.new_thread() for f in frames: cur_thread.push_frame(f) def replace_trace_func(): for f in frames: f.f_trace = cur_thread.trace_func replace_trace_func() sys.settrace(cur_thread.trace_func) vspd.intercept_threads(for_attach = True)
def enable_attach(secret, address=('0.0.0.0', DEFAULT_PORT), certfile=None, keyfile=None, redirect_output=True): """Enables Visual Studio to attach to this process remotely to debug Python code. Parameters ---------- secret : str Used to validate the clients - only those clients providing the valid secret will be allowed to connect to this server. On client side, the secret is prepended to the Qualifier string, separated from the hostname by ``'@'``, e.g.: ``'[email protected]:5678'``. If secret is ``None``, there's no validation, and any client can connect freely. address : (str, int), optional Specifies the interface and port on which the debugging server should listen for TCP connections. It is in the same format as used for regular sockets of the `socket.AF_INET` family, i.e. a tuple of ``(hostname, port)``. On client side, the server is identified by the Qualifier string in the usual ``'hostname:port'`` format, e.g.: ``'myhost.cloudapp.net:5678'``. Default is ``('0.0.0.0', 5678)``. certfile : str, optional Used to enable SSL. If not specified, or if set to ``None``, the connection between this program and the debugger will be unsecure, and can be intercepted on the wire. If specified, the meaning of this parameter is the same as for `ssl.wrap_socket`. keyfile : str, optional Used together with `certfile` when SSL is enabled. Its meaning is the same as for ``ssl.wrap_socket``. redirect_output : bool, optional Specifies whether any output (on both `stdout` and `stderr`) produced by this program should be sent to the debugger. Default is ``True``. Notes ----- This function returns immediately after setting up the debugging server, and does not block program execution. If you need to block until debugger is attached, call `ptvsd.wait_for_attach`. The debugger can be detached and re-attached multiple times after `enable_attach` is called. This function can only be called once during the lifetime of the process. On a second call, `AttachAlreadyEnabledError` is raised. In circumstances where the caller does not control how many times the function will be called (e.g. when a script with a single call is run more than once by a hosting app or framework), the call should be wrapped in ``try..except``. Only the thread on which this function is called, and any threads that are created after it returns, will be visible in the debugger once it is attached. Any threads that are already running before this function is called will not be visible. """ if not ssl and (certfile or keyfile): raise ValueError( 'could not import the ssl module - SSL is not supported on this version of Python' ) if sys.platform == 'cli': # Check that IronPython was launched with -X:Frames and -X:Tracing, since we can't register our trace # func on the thread that calls enable_attach otherwise import clr x_tracing = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Tracing x_frames = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Frames if not x_tracing or not x_frames: raise RuntimeError( 'IronPython must be started with -X:Tracing and -X:Frames options to support PTVS remote debugging.' ) global _attach_enabled if _attach_enabled: raise AttachAlreadyEnabledError( 'ptvsd.enable_attach() has already been called in this process.') _attach_enabled = True atexit.register(vspd.detach_process_and_notify_debugger) server = socket.socket(proto=socket.IPPROTO_TCP) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind(address) server.listen(1) def server_thread_func(): while True: client = None connection = None try: client, addr = server.accept() if certfile: client = ssl.wrap_socket(client, server_side=True, ssl_version=ssl.PROTOCOL_TLSv1, certfile=certfile, keyfile=keyfile) connection = AttachLoop(client, secret, redirect_output, None) connection.send_event( name='legacyRemoteConnected', debuggerName=PTVSDBG, debuggerProtocolVersion=PTVSDBG_VER, ) connection.process_messages() except (socket.error, OSError): pass finally: if connection: connection.close() server_thread = threading.Thread(target=server_thread_func) server_thread.setDaemon(True) server_thread.start() frames = [] f = sys._getframe() while True: f = f.f_back if f is None: break frames.append(f) frames.reverse() cur_thread = vspd.new_thread() for f in frames: cur_thread.push_frame(f) def replace_trace_func(): for f in frames: f.f_trace = cur_thread.trace_func replace_trace_func() sys.settrace(cur_thread.trace_func) vspd.intercept_threads(for_attach=True)
def enable_attach(secret, address=('0.0.0.0', DEFAULT_PORT), certfile=None, keyfile=None, redirect_output=True): """Enables Python Tools for Visual Studio to attach to this process remotely to debug Python code. The secret parameter is used to validate the clients - only those clients providing the valid secret will be allowed to connect to this server. On client side, the secret is prepended to the Qualifier string, separated from the hostname by '@', e.g.: [email protected]:5678. If secret is None, there's no validation, and any client can connect freely. The address parameter specifies the interface and port on which the debugging server should listen for TCP connections. It is in the same format as used for regular sockets of the AF_INET family, i.e. a tuple of (hostname, port). On client side, the server is identified by the Qualifier string in the usual hostname:port format, e.g.: myhost.cloudapp.net:5678. The certfile parameter is used to enable SSL. If not specified, or if set to None, the connection between this program and the debugger will be unsecure, and can be intercepted on the wire. If specified, the meaning of this parameter is the same as for ssl.wrap_socket. The keyfile parameter is used together with certfile when SSL is enabled. Its meaning is the same as for ssl.wrap_socket. The redirect_output parameter specifies whether any output (on both stdout and stderr) produced by this program should be sent to the debugger. This function returns immediately after setting up the debugging server, and does not block program execution. If you need to block until debugger is attached, call ptvsd.wait_for_attach. The debugger can be detached and re-attached multiple times after enable_attach is called. Only the thread on which this function is called, and any threads that are created after it returns, will be visible in the debugger once it is attached. Any threads that are already running before this function is called will not be visible. """ if not ssl and (certfile or keyfile): raise ValueError( 'could not import the ssl module - SSL is not supported on this version of Python' ) if sys.platform == 'cli': # Check that IronPython was launched with -X:Frames and -X:Tracing, since we can't register our trace # func on the thread that calls enable_attach otherwise import clr x_tracing = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Tracing x_frames = clr.GetCurrentRuntime().GetLanguageByExtension( 'py').Options.Frames if not x_tracing or not x_frames: raise RuntimeError( 'IronPython must be started with -X:Tracing and -X:Frames options to support PTVS remote debugging.' ) if redirect_output: vspd.enable_output_redirection() atexit.register(vspd.detach_process_and_notify_debugger) server = socket.socket() server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.bind(address) server.listen(1) def server_thread_func(): while True: client = None raw_client = None try: client, addr = server.accept() if certfile: client = ssl.wrap_socket(client, server_side=True, ssl_version=ssl.PROTOCOL_TLSv1, certfile=certfile, keyfile=keyfile) write_bytes(client, PTVSDBG) write_int(client, PTVSDBG_VER) response = read_bytes(client, 7) if response != PTVSDBG: continue dbg_ver = read_int(client) if dbg_ver != PTVSDBG_VER: continue client_secret = read_string(client) if secret is None or secret == client_secret: write_bytes(client, ACPT) else: write_bytes(client, RJCT) continue response = read_bytes(client, 4) if response == INFO: try: pid = os.getpid() except AttributeError: pid = 0 write_int(client, pid) exe = sys.executable or '' write_string(client, exe) try: username = getpass.getuser() except AttributeError: username = '' write_string(client, username) try: impl = platform.python_implementation() except AttributeError: try: impl = sys.implementation.name except AttributeError: impl = 'Python' major, minor, micro, release_level, serial = sys.version_info os_and_arch = platform.system() if os_and_arch == "": os_and_arch = sys.platform try: if sys.maxsize > 2**32: os_and_arch += ' 64-bit' else: os_and_arch += ' 32-bit' except AttributeError: pass version = '%s %s.%s.%s (%s)' % (impl, major, minor, micro, os_and_arch) write_string(client, version) elif response == ATCH: if vspd.DETACHED: write_bytes(client, ACPT) try: pid = os.getpid() except AttributeError: pid = 0 write_int(client, pid) major, minor, micro, release_level, serial = sys.version_info write_int(client, major) write_int(client, minor) write_int(client, micro) vspd.attach_process_from_socket(client, report=True) vspd.mark_all_threads_for_break( vspd.STEPPING_ATTACH_BREAK) _attached.set() client = None else: write_bytes(client, RJCT) elif response == REPL: if not vspd.DETACHED: write_bytes(client, ACPT) vspd.connect_repl_using_socket(client) client = None else: write_bytes(client, RJCT) except (socket.error, OSError): pass finally: if client is not None: client.close() server_thread = threading.Thread(target=server_thread_func) server_thread.daemon = True server_thread.start() frames = [] f = sys._getframe() while True: f = f.f_back if f is None: break frames.append(f) frames.reverse() cur_thread = vspd.new_thread() for f in frames: cur_thread.push_frame(f) def replace_trace_func(): for f in frames: f.f_trace = cur_thread.trace_func replace_trace_func() sys.settrace(cur_thread.trace_func) vspd.intercept_threads(for_attach=True)