Merge pull request #386 fix conflict
authorElizaveta Shashkova <Elizaveta.Shashkova@jetbrains.com>
Wed, 11 May 2016 11:48:01 +0000 (14:48 +0300)
committerElizaveta Shashkova <Elizaveta.Shashkova@jetbrains.com>
Wed, 11 May 2016 11:48:01 +0000 (14:48 +0300)
python/helpers/pydev/_pydev_bundle/pydev_console_utils.py
python/helpers/pydev/pydevd.py
python/src/com/jetbrains/python/console/PyConsoleDebugProcess.java
python/src/com/jetbrains/python/console/PydevConsoleCommunication.java
python/src/com/jetbrains/python/debugger/PyDebugRunner.java

index 69d68d84ce85731858bc21faa76c50faf7832f6e..d64f84a714f376a3d63426d6480fa7cb9a1e0a05 100644 (file)
@@ -1,3 +1,5 @@
+import os
+
 from _pydev_bundle.pydev_imports import xmlrpclib, _queue, Exec
 import sys
 from _pydevd_bundle.pydevd_constants import IS_JYTHON
@@ -480,11 +482,19 @@ class BaseInterpreterInterface:
         else:
             return self.orig_find_frame(thread_id, frame_id)
 
-    def connectToDebugger(self, debuggerPort):
+    def connectToDebugger(self, debuggerPort, debugger_options = None):
         '''
         Used to show console with variables connection.
         Mainly, monkey-patches things in the debugger structure so that the debugger protocol works.
         '''
+
+        if debugger_options is None:
+            debugger_options = {}
+        env_key = '__extra__envs__'
+        if env_key in debugger_options:
+            for (env_name, value) in debugger_options[env_key].items():
+                os.environ[env_name] = value
+            del debugger_options[env_key]
         def do_connect_to_debugger():
             try:
                 # Try to import the packages needed to attach the debugger
@@ -504,6 +514,7 @@ class BaseInterpreterInterface:
 
             self.debugger = pydevd.PyDB()
             try:
+                pydevd.apply_debugger_options(debugger_options)
                 self.debugger.connect(pydev_localhost.get_localhost(), debuggerPort)
                 self.debugger.prepare_to_run()
                 from _pydevd_bundle import pydevd_tracing
index e25be084dd9d7970b9d2258f80bfc9670b6246fe..168632c05062bca74c7836a0db17de2a42c18459 100644 (file)
@@ -1358,6 +1358,33 @@ class SetupHolder:
     setup = None
 
 
+def apply_debugger_options(setup_options):
+    """
+
+    :type setup_options: dict[str, bool]
+    """
+
+    default_options = {'save-signatures': False, 'save-threading': False, 'save-asyncio': False, 'qt-support': False}
+    default_options.update(setup_options)
+    setup_options = default_options
+
+    debugger = GetGlobalDebugger()
+    if setup_options['save-signatures']:
+        if pydevd_vm_type.get_vm_type() == pydevd_vm_type.PydevdVmType.JYTHON:
+            sys.stderr.write("Collecting run-time type information is not supported for Jython\n")
+        else:
+            # Only import it if we're going to use it!
+            from _pydevd_bundle.pydevd_signature import SignatureFactory
+            debugger.signature_factory = SignatureFactory()
+    if setup_options['qt-support']:
+        enable_qt_support()
+    if setup_options['save-threading']:
+        debugger.thread_analyser = ThreadingLogger()
+    if setup_options['save-asyncio']:
+        if IS_PY34_OLDER:
+            debugger.asyncio_analyser = AsyncioLogger()
+
+
 #=======================================================================================================================
 # main
 #=======================================================================================================================
@@ -1504,20 +1531,7 @@ if __name__ == '__main__':
         # Run the dev_appserver
         debugger.run(setup['file'], None, None, is_module, set_trace=False)
     else:
-        if setup['save-signatures']:
-            if pydevd_vm_type.get_vm_type() == pydevd_vm_type.PydevdVmType.JYTHON:
-                sys.stderr.write("Collecting run-time type information is not supported for Jython\n")
-            else:
-                # Only import it if we're going to use it!
-                from _pydevd_bundle.pydevd_signature import SignatureFactory
-                debugger.signature_factory = SignatureFactory()
-        if setup['qt-support']:
-            enable_qt_support()
-        if setup['save-threading']:
-            debugger.thread_analyser = ThreadingLogger()
-        if setup['save-asyncio']:
-            if IS_PY34_OLDER:
-                debugger.asyncio_analyser = AsyncioLogger()
+        apply_debugger_options(setup)
 
         try:
             debugger.connect(host, port)
index af8529d12d604e607891e0889aa358f7a82b9a9b..71ec989dbc89a58c6c9b11f727da6ceefc8f1690 100644 (file)
  */
 package com.jetbrains.python.console;
 
+import com.google.common.collect.Maps;
 import com.intellij.execution.ui.ConsoleViewContentType;
 import com.intellij.execution.ui.ExecutionConsole;
+import com.intellij.openapi.project.Project;
 import com.intellij.remote.RemoteProcessControl;
 import com.intellij.util.ui.UIUtil;
 import com.intellij.xdebugger.XDebugSession;
 import com.jetbrains.python.debugger.PyDebugProcess;
+import com.jetbrains.python.debugger.PyDebugRunner;
+import com.jetbrains.python.debugger.PyDebuggerOptionsProvider;
 import org.jetbrains.annotations.NotNull;
 
 import java.net.ServerSocket;
+import java.util.Map;
 
 /**
  * @author traff
@@ -81,10 +86,28 @@ public class PyConsoleDebugProcess extends PyDebugProcess {
     if (myConsoleDebugProcessHandler.getConsoleProcessHandler() instanceof RemoteProcessControl) {
       portToConnect = getRemoteTunneledPort(myLocalPort,
                                             ((RemoteProcessControl)myConsoleDebugProcessHandler.getConsoleProcessHandler()));
-    } else {
+    }
+    else {
       portToConnect = myLocalPort;
     }
-    consoleCommunication.connectToDebugger(portToConnect);
+    Map<String, Boolean> optionsMap = makeDebugOptionsMap(getSession());
+    Map<String, String> envs = getDebuggerEnvs(getSession());
+    consoleCommunication.connectToDebugger(portToConnect, optionsMap, envs);
+  }
+
+  private static Map<String, String> getDebuggerEnvs(XDebugSession session) {
+    Map<String, String> env = Maps.newHashMap();
+    PyDebugRunner.configureDebugEnvironment(session.getProject(), env);
+    return env;
+  }
+
+  private static Map<String, Boolean> makeDebugOptionsMap(XDebugSession session) {
+    Project project = session.getProject();
+    PyDebuggerOptionsProvider userOpts = PyDebuggerOptionsProvider.getInstance(project);
+    Map<String, Boolean> dbgOpts = Maps.newHashMap();
+    dbgOpts.put("save-signatures", userOpts.isSaveCallSignatures());
+    dbgOpts.put("qt-support", userOpts.isSupportQtDebugging());
+    return dbgOpts;
   }
 
   public void waitForNextConnection() {
index af61cab907347228388245923243d60da8824036..f599ac116d5b5e3cd4745870e295d7d1a453b59c 100644 (file)
@@ -44,9 +44,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
 import java.net.MalformedURLException;
-import java.util.Collections;
-import java.util.List;
-import java.util.Vector;
+import java.util.*;
 
 /**
  * Communication with Xml-rpc with the client.
@@ -115,7 +113,7 @@ public class PydevConsoleCommunication extends AbstractConsoleCommunication impl
 
     //start the server that'll handle input requests
     myWebServer = new MyWebServer(clientPort);
-    
+
     myWebServer.addHandler("$default", this);
     this.myWebServer.start();
 
@@ -589,13 +587,19 @@ public class PydevConsoleCommunication extends AbstractConsoleCommunication impl
    * Request that pydevconsole connect (with pydevd) to the specified port
    *
    * @param localPort port for pydevd to connect to.
+   * @param dbgOpts   additional debugger options (that are normally passed via command line) to apply
+   * @param extraEnvs
    * @throws Exception if connection fails
    */
-  public void connectToDebugger(int localPort) throws Exception {
+  public void connectToDebugger(int localPort, @NotNull Map<String, Boolean> dbgOpts, @NotNull Map<String, String> extraEnvs)
+    throws Exception {
     if (waitingForInput) {
       throw new Exception("Can't connect debugger now, waiting for input");
     }
-    Object result = myClient.execute(CONNECT_TO_DEBUGGER, new Object[]{localPort});
+    /* argument needs to be hashtable type for compatability with the RPC library */
+    Hashtable<String, Object> opts = new Hashtable<>(dbgOpts);
+    opts.put("__extra__envs__", new Hashtable<>(extraEnvs));
+    Object result = myClient.execute(CONNECT_TO_DEBUGGER, new Object[]{localPort, opts});
     Exception exception = null;
     if (result instanceof Vector) {
       Vector resultarray = (Vector)result;
@@ -627,21 +631,21 @@ public class PydevConsoleCommunication extends AbstractConsoleCommunication impl
   public PythonDebugConsoleCommunication getDebugCommunication() {
     return myDebugCommunication;
   }
-  
-  
+
+
   public boolean waitForTerminate() {
     if (myWebServer != null) {
       return myWebServer.waitForTerminate();
     }
-    
+
     return true;
   }
-  
+
   private static final class MyWebServer extends WebServer {
     public MyWebServer(int port) {
       super(port);
     }
-    
+
     @Override
     public synchronized void shutdown() {
       try {
@@ -654,10 +658,10 @@ public class PydevConsoleCommunication extends AbstractConsoleCommunication impl
       }
       super.shutdown();
     }
-    
+
     public boolean waitForTerminate() {
       if (listener != null) {
-        return new WaitFor(10000){
+        return new WaitFor(10000) {
           @Override
           protected boolean condition() {
             return !listener.isAlive();
index 9792c06af3a5c486a593a3e6fcc65e6f7a02ca00..24c225e838a42f2fbc3c851b94cf743b2298bebe 100644 (file)
@@ -54,6 +54,7 @@ import org.jetbrains.annotations.Nullable;
 import java.io.File;
 import java.net.ServerSocket;
 import java.util.List;
+import java.util.Map;
 
 /**
  * @author yole
@@ -289,20 +290,8 @@ public class PyDebugRunner extends GenericProgramRunner {
 
     configureDebugParameters(project, debugParams, pyState, cmd);
 
-    if (PyDebuggerOptionsProvider.getInstance(project).isSupportGeventDebugging()) {
-      cmd.getEnvironment().put(GEVENT_SUPPORT, "True");
-    }
-
-    PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance();
-    if (debuggerSettings.isSteppingFiltersEnabled()) {
-      cmd.getEnvironment().put(PYDEVD_FILTERS, debuggerSettings.getSteppingFiltersForProject(project));
-    }
-    if (debuggerSettings.isLibrariesFilterEnabled()) {
-      cmd.getEnvironment().put(PYDEVD_FILTER_LIBRARIES, "True");
-    }
 
-    addProjectRootsToEnv(project, cmd);
-    addSdkRootsToEnv(project, cmd);
+    configureDebugEnvironment(project, cmd.getEnvironment());
 
     final String[] debuggerArgs = new String[]{
       CLIENT_PARAM, "127.0.0.1",
@@ -314,6 +303,23 @@ public class PyDebugRunner extends GenericProgramRunner {
     }
   }
 
+  public static void configureDebugEnvironment(@NotNull Project project, Map<String, String> environment) {
+    if (PyDebuggerOptionsProvider.getInstance(project).isSupportGeventDebugging()) {
+      environment.put(GEVENT_SUPPORT, "True");
+    }
+
+    PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance();
+    if (debuggerSettings.isSteppingFiltersEnabled()) {
+      environment.put(PYDEVD_FILTERS, debuggerSettings.getSteppingFiltersForProject(project));
+    }
+    if (debuggerSettings.isLibrariesFilterEnabled()) {
+      environment.put(PYDEVD_FILTER_LIBRARIES, "True");
+    }
+
+    addProjectRootsToEnv(project, environment);
+    addSdkRootsToEnv(project, environment);
+  }
+
   protected void configureDebugParameters(@NotNull Project project,
                                         @NotNull ParamsGroup debugParams,
                                         @NotNull PythonCommandLineState pyState,
@@ -340,17 +346,17 @@ public class PyDebugRunner extends GenericProgramRunner {
     }
   }
 
-  private static void addProjectRootsToEnv(@NotNull Project project, @NotNull GeneralCommandLine commandLine) {
+  private static void addProjectRootsToEnv(@NotNull Project project, @NotNull Map<String, String> environment) {
 
     List<String> roots = Lists.newArrayList();
     for (VirtualFile contentRoot : ProjectRootManager.getInstance(project).getContentRoots()) {
       roots.add(contentRoot.getPath());
     }
 
-    commandLine.getEnvironment().put(IDE_PROJECT_ROOTS, StringUtil.join(roots, File.pathSeparator));
+    environment.put(IDE_PROJECT_ROOTS, StringUtil.join(roots, File.pathSeparator));
   }
 
-  private static void addSdkRootsToEnv(@NotNull Project project, @NotNull GeneralCommandLine commandLine) {
+  private static void addSdkRootsToEnv(@NotNull Project project, @NotNull Map<String, String> environment) {
     final RunManager runManager = RunManager.getInstance(project);
     final RunnerAndConfigurationSettings selectedConfiguration = runManager.getSelectedConfiguration();
     if (selectedConfiguration != null) {
@@ -363,7 +369,7 @@ public class PyDebugRunner extends GenericProgramRunner {
           for (VirtualFile contentRoot : sdk.getSdkModificator().getRoots(OrderRootType.CLASSES)) {
             roots.add(contentRoot.getPath());
           }
-          commandLine.getEnvironment().put(LIBRARY_ROOTS, StringUtil.join(roots, File.pathSeparator));
+          environment.put(LIBRARY_ROOTS, StringUtil.join(roots, File.pathSeparator));
         }
       }
     }