1 import sys

     2 import linecache

     3 import time

     4 import socket

     5 import traceback

     6 import thread

     7 import threading

     8 import Queue

     9 

    10 import CallTips

    11 import AutoComplete

    12 

    13 import RemoteDebugger

    14 import RemoteObjectBrowser

    15 import StackViewer

    16 import rpc

    17 

    18 import __main__

    19 

    20 LOCALHOST = '127.0.0.1'

    21 

    22 try:

    23     import warnings

    24 except ImportError:

    25     pass

    26 else:

    27     def idle_formatwarning_subproc(message, category, filename, lineno,

    28                                    file=None, line=None):

    29         """Format warnings the IDLE way"""

    30         s = "\nWarning (from warnings module):\n"

    31         s += '  File \"%s\", line %s\n' % (filename, lineno)

    32         line = linecache.getline(filename, lineno).strip() \

    33             if line is None else line

    34         if line:

    35             s += "    %s\n" % line

    36         s += "%s: %s\n" % (category.__name__, message)

    37         return s

    38     warnings.formatwarning = idle_formatwarning_subproc

    39 

    40 # Thread shared globals: Establish a queue between a subthread (which handles

    41 # the socket) and the main thread (which runs user code), plus global

    42 # completion, exit and interruptable (the main thread) flags:

    43 

    44 exit_now = False

    45 quitting = False

    46 interruptable = False

    47 

    48 def main(del_exitfunc=False):

    49     """Start the Python execution server in a subprocess

    50 

    51     In the Python subprocess, RPCServer is instantiated with handlerclass

    52     MyHandler, which inherits register/unregister methods from RPCHandler via

    53     the mix-in class SocketIO.

    54 

    55     When the RPCServer 'server' is instantiated, the TCPServer initialization

    56     creates an instance of run.MyHandler and calls its handle() method.

    57     handle() instantiates a run.Executive object, passing it a reference to the

    58     MyHandler object.  That reference is saved as attribute rpchandler of the

    59     Executive instance.  The Executive methods have access to the reference and

    60     can pass it on to entities that they command

    61     (e.g. RemoteDebugger.Debugger.start_debugger()).  The latter, in turn, can

    62     call MyHandler(SocketIO) register/unregister methods via the reference to

    63     register and unregister themselves.

    64 

    65     """

    66     global exit_now

    67     global quitting

    68     global no_exitfunc

    69     no_exitfunc = del_exitfunc

    70     port = 8833

    71     #time.sleep(15) # test subprocess not responding

    72     if sys.argv[1:]:

    73         port = int(sys.argv[1])

    74     sys.argv[:] = [""]

    75     sockthread = threading.Thread(target=manage_socket,

    76                                   name='SockThread',

    77                                   args=((LOCALHOST, port),))

    78     sockthread.setDaemon(True)

    79     sockthread.start()

    80     while 1:

    81         try:

    82             if exit_now:

    83                 try:

    84                     exit()

    85                 except KeyboardInterrupt:

    86                     # exiting but got an extra KBI? Try again!

    87                     continue

    88             try:

    89                 seq, request = rpc.request_queue.get(block=True, timeout=0.05)

    90             except Queue.Empty:

    91                 continue

    92             method, args, kwargs = request

    93             ret = method(*args, **kwargs)

    94             rpc.response_queue.put((seq, ret))

    95         except KeyboardInterrupt:

    96             if quitting:

    97                 exit_now = True

    98             continue

    99         except SystemExit:

   100             raise

   101         except:

   102             type, value, tb = sys.exc_info()

   103             try:

   104                 print_exception()

   105                 rpc.response_queue.put((seq, None))

   106             except:

   107                 # Link didn't work, print same exception to __stderr__

   108                 traceback.print_exception(type, value, tb, file=sys.__stderr__)

   109                 exit()

   110             else:

   111                 continue

   112 

   113 def manage_socket(address):

   114     for i in range(3):

   115         time.sleep(i)

   116         try:

   117             server = MyRPCServer(address, MyHandler)

   118             break

   119         except socket.error, err:

   120             print>>sys.__stderr__,"IDLE Subprocess: socket error: "\

   121                                         + err[1] + ", retrying...."

   122     else:

   123         print>>sys.__stderr__, "IDLE Subprocess: Connection to "\

   124                                "IDLE GUI failed, exiting."

   125         show_socket_error(err, address)

   126         global exit_now

   127         exit_now = True

   128         return

   129     server.handle_request() # A single request only

   130 

   131 def show_socket_error(err, address):

   132     import Tkinter

   133     import tkMessageBox

   134     root = Tkinter.Tk()

   135     root.withdraw()

   136     if err[0] == 61: # connection refused

   137         msg = "IDLE's subprocess can't connect to %s:%d.  This may be due "\

   138               "to your personal firewall configuration.  It is safe to "\

   139               "allow this internal connection because no data is visible on "\

   140               "external ports." % address

   141         tkMessageBox.showerror("IDLE Subprocess Error", msg, parent=root)

   142     else:

   143         tkMessageBox.showerror("IDLE Subprocess Error", "Socket Error: %s" % err[1])

   144     root.destroy()

   145 

   146 def print_exception():

   147     import linecache

   148     linecache.checkcache()

   149     flush_stdout()

   150     efile = sys.stderr

   151     typ, val, tb = excinfo = sys.exc_info()

   152     sys.last_type, sys.last_value, sys.last_traceback = excinfo

   153     tbe = traceback.extract_tb(tb)

   154     print>>efile, '\nTraceback (most recent call last):'

   155     exclude = ("run.py", "rpc.py", "threading.py", "Queue.py",

   156                "RemoteDebugger.py", "bdb.py")

   157     cleanup_traceback(tbe, exclude)

   158     traceback.print_list(tbe, file=efile)

   159     lines = traceback.format_exception_only(typ, val)

   160     for line in lines:

   161         print>>efile, line,

   162 

   163 def cleanup_traceback(tb, exclude):

   164     "Remove excluded traces from beginning/end of tb; get cached lines"

   165     orig_tb = tb[:]

   166     while tb:

   167         for rpcfile in exclude:

   168             if tb[0][0].count(rpcfile):

   169                 break    # found an exclude, break for: and delete tb[0]

   170         else:

   171             break        # no excludes, have left RPC code, break while:

   172         del tb[0]

   173     while tb:

   174         for rpcfile in exclude:

   175             if tb[-1][0].count(rpcfile):

   176                 break

   177         else:

   178             break

   179         del tb[-1]

   180     if len(tb) == 0:

   181         # exception was in IDLE internals, don't prune!

   182         tb[:] = orig_tb[:]

   183         print>>sys.stderr, "** IDLE Internal Exception: "

   184     rpchandler = rpc.objecttable['exec'].rpchandler

   185     for i in range(len(tb)):

   186         fn, ln, nm, line = tb[i]

   187         if nm == '?':

   188             nm = "-toplevel-"

   189         if not line and fn.startswith("<pyshell#"):

   190             line = rpchandler.remotecall('linecache', 'getline',

   191                                               (fn, ln), {})

   192         tb[i] = fn, ln, nm, line

   193 

   194 def flush_stdout():

   195     try:

   196         if sys.stdout.softspace:

   197             sys.stdout.softspace = 0

   198             sys.stdout.write("\n")

   199     except (AttributeError, EOFError):

   200         pass

   201 

   202 def exit():

   203     """Exit subprocess, possibly after first deleting sys.exitfunc

   204 

   205     If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any

   206     sys.exitfunc will be removed before exiting.  (VPython support)

   207 

   208     """

   209     if no_exitfunc:

   210         try:

   211             del sys.exitfunc

   212         except AttributeError:

   213             pass

   214     sys.exit(0)

   215 

   216 class MyRPCServer(rpc.RPCServer):

   217 

   218     def handle_error(self, request, client_address):

   219         """Override RPCServer method for IDLE

   220 

   221         Interrupt the MainThread and exit server if link is dropped.

   222 

   223         """

   224         global quitting

   225         try:

   226             raise

   227         except SystemExit:

   228             raise

   229         except EOFError:

   230             global exit_now

   231             exit_now = True

   232             thread.interrupt_main()

   233         except:

   234             erf = sys.__stderr__

   235             print>>erf, '\n' + '-'*40

   236             print>>erf, 'Unhandled server exception!'

   237             print>>erf, 'Thread: %s' % threading.currentThread().getName()

   238             print>>erf, 'Client Address: ', client_address

   239             print>>erf, 'Request: ', repr(request)

   240             traceback.print_exc(file=erf)

   241             print>>erf, '\n*** Unrecoverable, server exiting!'

   242             print>>erf, '-'*40

   243             quitting = True

   244             thread.interrupt_main()

   245 

   246 

   247 class MyHandler(rpc.RPCHandler):

   248 

   249     def handle(self):

   250         """Override base method"""

   251         executive = Executive(self)

   252         self.register("exec", executive)

   253         sys.stdin = self.console = self.get_remote_proxy("stdin")

   254         sys.stdout = self.get_remote_proxy("stdout")

   255         sys.stderr = self.get_remote_proxy("stderr")

   256         import IOBinding

   257         sys.stdin.encoding = sys.stdout.encoding = \

   258                              sys.stderr.encoding = IOBinding.encoding

   259         self.interp = self.get_remote_proxy("interp")

   260         rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05)

   261 

   262     def exithook(self):

   263         "override SocketIO method - wait for MainThread to shut us down"

   264         time.sleep(10)

   265 

   266     def EOFhook(self):

   267         "Override SocketIO method - terminate wait on callback and exit thread"

   268         global quitting

   269         quitting = True

   270         thread.interrupt_main()

   271 

   272     def decode_interrupthook(self):

   273         "interrupt awakened thread"

   274         global quitting

   275         quitting = True

   276         thread.interrupt_main()

   277 

   278 

   279 class Executive(object):

   280 

   281     def __init__(self, rpchandler):

   282         self.rpchandler = rpchandler

   283         self.locals = __main__.__dict__

   284         self.calltip = CallTips.CallTips()

   285         self.autocomplete = AutoComplete.AutoComplete()

   286 

   287     def runcode(self, code):

   288         global interruptable

   289         try:

   290             self.usr_exc_info = None

   291             interruptable = True

   292             try:

   293                 exec code in self.locals

   294             finally:

   295                 interruptable = False

   296         except:

   297             self.usr_exc_info = sys.exc_info()

   298             if quitting:

   299                 exit()

   300             # even print a user code SystemExit exception, continue

   301             print_exception()

   302             jit = self.rpchandler.console.getvar("<<toggle-jit-stack-viewer>>")

   303             if jit:

   304                 self.rpchandler.interp.open_remote_stack_viewer()

   305         else:

   306             flush_stdout()

   307 

   308     def interrupt_the_server(self):

   309         if interruptable:

   310             thread.interrupt_main()

   311 

   312     def start_the_debugger(self, gui_adap_oid):

   313         return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)

   314 

   315     def stop_the_debugger(self, idb_adap_oid):

   316         "Unregister the Idb Adapter.  Link objects and Idb then subject to GC"

   317         self.rpchandler.unregister(idb_adap_oid)

   318 

   319     def get_the_calltip(self, name):

   320         return self.calltip.fetch_tip(name)

   321 

   322     def get_the_completion_list(self, what, mode):

   323         return self.autocomplete.fetch_completions(what, mode)

   324 

   325     def stackviewer(self, flist_oid=None):

   326         if self.usr_exc_info:

   327             typ, val, tb = self.usr_exc_info

   328         else:

   329             return None

   330         flist = None

   331         if flist_oid is not None:

   332             flist = self.rpchandler.get_remote_proxy(flist_oid)

   333         while tb and tb.tb_frame.f_globals["__name__"] in ["rpc", "run"]:

   334             tb = tb.tb_next

   335         sys.last_type = typ

   336         sys.last_value = val

   337         item = StackViewer.StackTreeItem(flist, tb)

   338         return RemoteObjectBrowser.remote_object_tree_item(item)