Ejemplo n.º 1
0
def test_bsdsockets():
    """Test write-read packet methods."""
    # socket read/write testing - client and server in one thread
        
    # (techtonik): the stuff below is placed into public domain
    address = ("127.0.0.1", 9999)

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setblocking(0)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind( address )
    server.listen(2)

    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect( address )

    client.send("data to be catched".encode('utf-8'))
    # accepted server socket is the one we can read from
    # note that it is different from server socket
    accsock, addr = server.accept()
    assert accsock.recv(4096) == b'data to be catched'

    # Testing BSD socket write_packet/read_packet
    write_packet(client, "a tiny piece of data")
    read = read_packet(accsock)
    assert read == "a tiny piece of data"

    client.close()
    server.close()
Ejemplo n.º 2
0
 def run(self):
     """Start notification thread"""
     while True:
         if self.notify_socket is None:
             continue
         output = None
         try:
             try:
                 cdict = read_packet(self.notify_socket)
             except:
                 # This except statement is intended to handle a struct.error
                 # (but when writing 'except struct.error', it doesn't work)
                 # Note: struct.error is raised when the communication has
                 # been interrupted and the received data is not a string
                 # of length 8 as required by struct.unpack (see read_packet)
                 break
             if cdict is None:
                 # Another notification thread has just terminated and
                 # then wrote 'None' in the notification socket
                 # (see the 'finally' statement below)
                 continue
             if not isinstance(cdict, dict):
                 raise TypeError("Invalid data type: %r" % cdict)
             command = cdict['command']
             data = cdict.get('data')
             if command == 'pdb_step':
                 fname, lineno = data
                 self.sig_pdb.emit(fname, lineno)
                 self.refresh_namespace_browser.emit()
             elif command == 'refresh':
                 self.refresh_namespace_browser.emit()
             elif command == 'remote_view':
                 self.sig_process_remote_view.emit(data)
             elif command == 'ipykernel':
                 self.new_ipython_kernel.emit(data)
             elif command == 'open_file':
                 fname, lineno = data
                 self.open_file.emit(fname, lineno)
             else:
                 raise RuntimeError('Unsupported command: %r' % command)
             if DEBUG_INTROSPECTION:
                 logging.debug("received command: %r" % command)
         except:
             log_last_error(LOG_FILENAME, "notification thread")
         finally:
             try:
                 write_packet(self.notify_socket, output)
             except:
                 # The only reason why it should fail is that Spyder is
                 # closing while this thread is still alive
                 break
Ejemplo n.º 3
0
 def run(self):
     """Start notification thread"""
     while True:
         if self.notify_socket is None:
             continue
         output = None
         try:
             try:
                 cdict = read_packet(self.notify_socket)
             except:
                 # This except statement is intended to handle a struct.error
                 # (but when writing 'except struct.error', it doesn't work)
                 # Note: struct.error is raised when the communication has 
                 # been interrupted and the received data is not a string 
                 # of length 8 as required by struct.unpack (see read_packet)
                 break
             if cdict is None:
                 # Another notification thread has just terminated and 
                 # then wrote 'None' in the notification socket
                 # (see the 'finally' statement below)
                 continue
             if not isinstance(cdict, dict):
                 raise TypeError("Invalid data type: %r" % cdict)
             command = cdict['command']
             data = cdict.get('data')
             if command == 'pdb_step':
                 fname, lineno = data
                 self.sig_pdb.emit(fname, lineno)
                 self.refresh_namespace_browser.emit()
             elif command == 'refresh':
                 self.refresh_namespace_browser.emit()
             elif command == 'remote_view':
                 self.sig_process_remote_view.emit(data)
             elif command == 'ipykernel':
                 self.new_ipython_kernel.emit(data)
             elif command == 'open_file':
                 fname, lineno = data
                 self.open_file.emit(fname, lineno)
             else:
                 raise RuntimeError('Unsupported command: %r' % command)
             if DEBUG_INTROSPECTION:
                 logging.debug("received command: %r" % command)
         except:
             log_last_error(LOG_FILENAME, "notification thread")
         finally:
             try:
                 write_packet(self.notify_socket, output)
             except:
                 # The only reason why it should fail is that Spyder is 
                 # closing while this thread is still alive
                 break
Ejemplo n.º 4
0
 def quit_monitor(self):
     if self.introspection_socket is not None:
         try:
             write_packet(self.introspection_socket, "thread.exit()")
         except socket.error:
             pass
Ejemplo n.º 5
0
    def run(self):
        self.ipython_shell = None
        while True:
            output = pickle.dumps(None, PICKLE_HIGHEST_PROTOCOL)
            glbs = self.mglobals()
            try:
                if DEBUG_MONITOR:
                    logging.debug("****** Introspection request /Begin ******")
                command = PACKET_NOT_RECEIVED
                try:
                    timeout = self.timeout if self.auto_refresh else None
                    command = read_packet(self.i_request, timeout=timeout)
                    if command is None:
                        continue
                    timed_out = False
                except socket.timeout:
                    timed_out = True
                except struct.error:
                    # This should mean that Spyder GUI has crashed
                    if DEBUG_MONITOR:
                        logging.debug("struct.error -> quitting monitor")
                    break
                if timed_out:
                    if DEBUG_MONITOR:
                        logging.debug("connection timed out -> updating remote view")
                    self.update_remote_view()
                    if DEBUG_MONITOR:
                        logging.debug("****** Introspection request /End ******")
                    continue
                if DEBUG_MONITOR:
                    logging.debug("command: %r" % command)
                lcls = self.mlocals()
                result = eval(command, glbs, lcls)
                if DEBUG_MONITOR:
                    logging.debug(" result: %r" % result)
                if self.pdb_obj is None:
                    lcls["_"] = result
                # old com implementation: (see solution (1) in Issue 434)
                output = pickle.dumps(result, PICKLE_HIGHEST_PROTOCOL)
#                # new com implementation: (see solution (2) in Issue 434)
#                output = pickle.dumps((command, result),
#                                      PICKLE_HIGHEST_PROTOCOL)
            except SystemExit:
                break
            except:
                if DEBUG_MONITOR:
                    logging.debug("error!")
                log_last_error(LOG_FILENAME, command)
            finally:
                try:
                    if DEBUG_MONITOR:
                        logging.debug("updating remote view")
                    if self.refresh_after_eval:
                        self.update_remote_view()
                        self.refresh_after_eval = False
                    if DEBUG_MONITOR:
                        logging.debug("sending result")
                        logging.debug("****** Introspection request /End ******")
                    if command is not PACKET_NOT_RECEIVED:
                        if write_packet is None:
                            # This may happen during interpreter shutdown
                            break
                        else:
                            write_packet(self.i_request, output,
                                         already_pickled=True)
                except AttributeError as error:
                    if "'NoneType' object has no attribute" in str(error):
                        # This may happen during interpreter shutdown
                        break
                    else:
                        raise
                except TypeError as error:
                    if "'NoneType' object is not subscriptable" in str(error):
                        # This may happen during interpreter shutdown
                        break
                    else:
                        raise

        self.i_request.close()
        self.n_request.close()
Ejemplo n.º 6
0
    def __init__(self, host, introspection_port, notification_port,
                 shell_id, timeout, auto_refresh):
        threading.Thread.__init__(self)
        self.setDaemon(True)

        self.ipykernel = None
        self.ipython_shell = None
        
        self.pdb_obj = None
        
        self.timeout = None
        self.set_timeout(timeout)
        self.auto_refresh = auto_refresh
        self.refresh_after_eval = False
        self.remote_view_settings = None
        
        self.inputhook_flag = False
        self.first_inputhook_call = True
        
        # To grab the IPython internal namespace
        self.ip = None
        
        # Connecting to introspection server
        self.i_request = socket.socket( socket.AF_INET )
        self.i_request.connect( (host, introspection_port) )
        write_packet(self.i_request, shell_id)
        
        # Connecting to notification server
        self.n_request = socket.socket( socket.AF_INET )
        self.n_request.connect( (host, notification_port) )
        write_packet(self.n_request, shell_id)
        
        self._mlocals = {
                       "refresh": self.enable_refresh_after_eval,
                       "setlocal": self.setlocal,
                       "is_array": self.is_array,
                       "is_image": self.is_image,
                       "get_globals_keys": self.get_globals_keys,
                       "getmodcomplist": self.getmodcomplist,
                       "getcdlistdir": _getcdlistdir,
                       "getcwd": self.getcwd,
                       "setcwd": self.setcwd,
                       "getsyspath": self.getsyspath,
                       "getenv": self.getenv,
                       "setenv": self.setenv,
                       "isdefined": self.isdefined,
                       "thread": _thread,
                       "toggle_inputhook_flag": self.toggle_inputhook_flag,
                       "set_monitor_timeout": self.set_timeout,
                       "set_monitor_auto_refresh": self.set_auto_refresh,
                       "set_remote_view_settings":
                                                self.set_remote_view_settings,
                       "set_spyder_breakpoints": self.set_spyder_breakpoints,
                       "__get_dir__": self.get_dir,
                       "__iscallable__": self.iscallable,
                       "__get_arglist__": self.get_arglist,
                       "__get__doc____": self.get__doc__,
                       "__get_doc__": self.get_doc,
                       "__get_source__": self.get_source,
                       "__get_global__": self.getglobal,
                       "__set_global__": self.setglobal,
                       "__del_global__": self.delglobal,
                       "__copy_global__": self.copyglobal,
                       "__save_globals__": self.saveglobals,
                       "__load_globals__": self.loadglobals,
                       "_" : None}
        self._mglobals = None
Ejemplo n.º 7
0
    def run(self):
        self.ipython_shell = None
        while True:
            output = pickle.dumps(None, PICKLE_HIGHEST_PROTOCOL)
            glbs = self.mglobals()
            try:
                if DEBUG_MONITOR:
                    logging.debug("****** Introspection request /Begin ******")
                command = PACKET_NOT_RECEIVED
                try:
                    timeout = self.timeout if self.auto_refresh else None
                    command = read_packet(self.i_request, timeout=timeout)
                    if command is None:
                        continue
                    timed_out = False
                except socket.timeout:
                    timed_out = True
                except struct.error:
                    # This should mean that Spyder GUI has crashed
                    if DEBUG_MONITOR:
                        logging.debug("struct.error -> quitting monitor")
                    break
                if timed_out:
                    if DEBUG_MONITOR:
                        logging.debug(
                            "connection timed out -> updating remote view")
                    self.update_remote_view()
                    if DEBUG_MONITOR:
                        logging.debug(
                            "****** Introspection request /End ******")
                    continue
                if DEBUG_MONITOR:
                    logging.debug("command: %r" % command)
                lcls = self.mlocals()
                result = eval(command, glbs, lcls)
                if DEBUG_MONITOR:
                    logging.debug(" result: %r" % result)
                if self.pdb_obj is None:
                    lcls["_"] = result
                # old com implementation: (see solution (1) in Issue 434)
                output = pickle.dumps(result, PICKLE_HIGHEST_PROTOCOL)
#                # new com implementation: (see solution (2) in Issue 434)
#                output = pickle.dumps((command, result),
#                                      PICKLE_HIGHEST_PROTOCOL)
            except SystemExit:
                break
            except:
                if DEBUG_MONITOR:
                    logging.debug("error!")
                log_last_error(LOG_FILENAME, command)
            finally:
                try:
                    if DEBUG_MONITOR:
                        logging.debug("updating remote view")
                    if self.refresh_after_eval:
                        self.update_remote_view()
                        self.refresh_after_eval = False
                    if DEBUG_MONITOR:
                        logging.debug("sending result")
                        logging.debug(
                            "****** Introspection request /End ******")
                    if command is not PACKET_NOT_RECEIVED:
                        if write_packet is None:
                            # This may happen during interpreter shutdown
                            break
                        else:
                            write_packet(self.i_request,
                                         output,
                                         already_pickled=True)
                except AttributeError as error:
                    if "'NoneType' object has no attribute" in str(error):
                        # This may happen during interpreter shutdown
                        break
                    else:
                        raise
                except TypeError as error:
                    if "'NoneType' object is not subscriptable" in str(error):
                        # This may happen during interpreter shutdown
                        break
                    else:
                        raise

        self.i_request.close()
        self.n_request.close()
Ejemplo n.º 8
0
    def __init__(self, host, introspection_port, notification_port, shell_id,
                 timeout, auto_refresh):
        threading.Thread.__init__(self)
        self.setDaemon(True)

        self.ipykernel = None
        self.ipython_shell = None

        self.pdb_obj = None

        self.timeout = None
        self.set_timeout(timeout)
        self.auto_refresh = auto_refresh
        self.refresh_after_eval = False
        self.remote_view_settings = None

        self.inputhook_flag = False
        self.first_inputhook_call = True

        # To grab the IPython internal namespace
        self.ip = None

        # Connecting to introspection server
        self.i_request = socket.socket(socket.AF_INET)
        self.i_request.connect((host, introspection_port))
        write_packet(self.i_request, shell_id)

        # Connecting to notification server
        self.n_request = socket.socket(socket.AF_INET)
        self.n_request.connect((host, notification_port))
        write_packet(self.n_request, shell_id)

        self._mlocals = {
            "refresh": self.enable_refresh_after_eval,
            "setlocal": self.setlocal,
            "is_array": self.is_array,
            "is_image": self.is_image,
            "get_globals_keys": self.get_globals_keys,
            "getmodcomplist": self.getmodcomplist,
            "getcdlistdir": _getcdlistdir,
            "getcwd": self.getcwd,
            "setcwd": self.setcwd,
            "getsyspath": self.getsyspath,
            "getenv": self.getenv,
            "setenv": self.setenv,
            "isdefined": self.isdefined,
            "thread": _thread,
            "toggle_inputhook_flag": self.toggle_inputhook_flag,
            "set_monitor_timeout": self.set_timeout,
            "set_monitor_auto_refresh": self.set_auto_refresh,
            "set_remote_view_settings": self.set_remote_view_settings,
            "set_spyder_breakpoints": self.set_spyder_breakpoints,
            "__get_dir__": self.get_dir,
            "__iscallable__": self.iscallable,
            "__get_arglist__": self.get_arglist,
            "__get__doc____": self.get__doc__,
            "__get_doc__": self.get_doc,
            "__get_source__": self.get_source,
            "__get_global__": self.getglobal,
            "__set_global__": self.setglobal,
            "__del_global__": self.delglobal,
            "__copy_global__": self.copyglobal,
            "__save_globals__": self.saveglobals,
            "__load_globals__": self.loadglobals,
            "_": None
        }
        self._mglobals = None
Ejemplo n.º 9
0
 def quit_monitor(self):
     if self.introspection_socket is not None:
         try:
             write_packet(self.introspection_socket, "thread.exit()")
         except socket.error:
             pass