src/debugger/client/asyncfile_cdm_dbg.py

   1 #
   2 # -*- coding: utf-8 -*-
   3 #
   4 # codimension - graphics python two-way code editor and analyzer
   5 # Copyright (C) 2010  Sergey Satskiy <sergey.satskiy@gmail.com>
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 # $Id$
  21 #
  22
  23 #
  24 # The file was taken from eric 4 and adopted for codimension.
  25 # Original copyright:
  26 # Copyright (c) 2002 - 2012 Detlev Offenbach <detlev@die-offenbachs.de>
  27 #
  28
  29 """
  30 Module implementing an asynchronous
  31 file like socket interface for the debugger.
  32 """
  33
  34 import socket
  35
  36 from protocol_cdm_dbg import EOT
  37
  38
  39 def AsyncPendingWrite( fileObj ):
  40     """
  41     Checks for data to be written
  42
  43     @param fileObj The file object to be checked (file)
  44     @return Flag indicating if there is data wating (int)
  45     """
  46
  47     try:
  48         pending = fileObj.pendingWrite()
  49     except:
  50         pending = 0
  51     return pending
  52
  53
  54 class AsyncFile( object ):
  55     " Wrapps a socket object with a file interface "
  56
  57     maxtries = 10
  58     maxbuffersize = 1024 * 1024 * 4
  59
  60     def __init__( self, sock, mode, name ):
  61         """
  62         @param sock the socket object being wrapped
  63         @param mode mode of this file (string)
  64         @param name name of this file (string)
  65         """
  66
  67         # Initialise the attributes.
  68         self.closed = 0
  69         self.sock = sock
  70         self.mode = mode
  71         self.name = name
  72         self.nWriteErrors = 0
  73
  74         self.wpending = u''
  75         return
  76
  77     def __checkMode( self, mode ):
  78         """
  79         Checks the mode
  80
  81         This method checks, if an operation is permitted according to
  82         the mode of the file. If it is not, an IOError is raised.
  83
  84         @param mode the mode to be checked (string)
  85         """
  86
  87         if mode != self.mode:
  88             raise IOError, '[Errno 9] Bad file descriptor'
  89         return
  90
  91     def __nWrite( self, n ):
  92         """
  93         Writes a specific number of pending bytes
  94
  95         @param n the number of bytes to be written (int)
  96         """
  97
  98         if n:
  99             try :
 100                 buf = "%s%s" % ( self.wpending[ : n ], EOT )
 101                 try:
 102                     buf = buf.encode( 'utf8' )
 103                 except ( UnicodeEncodeError, UnicodeDecodeError ):
 104                     pass
 105                 self.sock.sendall( buf )
 106                 self.wpending = self.wpending[ n : ]
 107                 self.nWriteErrors = 0
 108             except socket.error:
 109                 self.nWriteErrors += 1
 110                 if self.nWriteErrors > self.maxtries:
 111                     self.wpending = u'' # delete all output
 112         return
 113
 114     def pendingWrite( self ):
 115         """
 116         Returns the number of bytes waiting to be written
 117
 118         @return the number of bytes to be written (int)
 119         """
 120         return len( self.wpending )
 121 #        return self.wpending.rfind( '\n' ) + 1
 122
 123     def close( self, closeit = 0 ):
 124         """
 125         Closes the file
 126
 127         @param closeit flag to indicate a close ordered by
 128                        the debugger code (boolean)
 129         """
 130
 131         if closeit and not self.closed:
 132             self.flush()
 133             self.sock.close()
 134             self.closed = 1
 135         return
 136
 137     def flush( self ):
 138         " Writes all pending bytes "
 139
 140         self.__nWrite( len( self.wpending ) )
 141         return
 142
 143     def isatty( self ):
 144         """
 145         Indicates whether a tty interface is supported.
 146
 147         @return always false
 148         """
 149         return 0
 150
 151     def fileno( self ):
 152         """
 153         Public method returning the file number.
 154
 155         @return file number (int)
 156         """
 157         try:
 158             return self.sock.fileno()
 159         except socket.error:
 160             return -1
 161
 162     def read_p( self, size = -1 ):
 163         """
 164         Reads bytes from this file
 165
 166         @param size maximum number of bytes to be read (int)
 167         @return the bytes read (any)
 168         """
 169         self.__checkMode( 'r' )
 170
 171         if size < 0:
 172             size = 20000
 173
 174         return self.sock.recv(size).decode( 'utf8' )
 175
 176     def read( self, size = -1 ):
 177         """
 178         Reads bytes from this file
 179
 180         @param size maximum number of bytes to be read (int)
 181         @return the bytes read (any)
 182         """
 183         self.__checkMode( 'r' )
 184
 185         buf = raw_input()
 186         if size >= 0:
 187             buf = buf[ : size ]
 188         return buf
 189
 190     def readline_p( self, size = -1 ):
 191         """
 192         Reads a line from this file.
 193
 194         <b>Note</b>: This method will not block and may return
 195         only a part of a line if that is all that is available.
 196
 197         @param size maximum number of bytes to be read (int)
 198         @return one line of text up to size bytes (string)
 199         """
 200         self.__checkMode( 'r' )
 201
 202         if size < 0:
 203             size = 20000
 204
 205         # The integration of the debugger client event loop and the connection
 206         # to the debugger relies on the two lines of the debugger command being
 207         # delivered as two separate events.  Therefore we make sure we only
 208         # read a line at a time.
 209         line = self.sock.recv( size, socket.MSG_PEEK )
 210
 211         eol = line.find( '\n' )
 212
 213         if eol >= 0:
 214             size = eol + 1
 215         else:
 216             size = len( line )
 217
 218         # Now we know how big the line is, read it for real.
 219         return self.sock.recv( size ).decode( 'utf8' )
 220
 221     def readlines( self, sizehint = -1 ):
 222         """
 223         Reads all lines from this file.
 224
 225         @param sizehint hint of the numbers of bytes to be read (int)
 226         @return list of lines read (list of strings)
 227         """
 228         self.__checkMode( 'r' )
 229
 230         lines = []
 231         room = sizehint
 232
 233         line = self.readline_p( room )
 234         linelen = len( line )
 235
 236         while linelen > 0:
 237             lines.append( line )
 238
 239             if sizehint >= 0:
 240                 room = room - linelen
 241
 242                 if room <= 0:
 243                     break
 244
 245             line = self.readline_p( room )
 246             linelen = len( line )
 247
 248         return lines
 249
 250     def readline( self, sizehint = -1 ):
 251         """
 252         Reads one line from this file.
 253
 254         @param sizehint hint of the numbers of bytes to be read (int)
 255         @return one line read (string)
 256         """
 257         self.__checkMode( 'r' )
 258
 259         line = raw_input() + '\n'
 260         if sizehint >= 0:
 261             line = line[ : sizehint ]
 262         return line
 263
 264     def seek( self, offset, whence = 0 ):
 265         """
 266         Moves the filepointer
 267
 268         @exception IOError This method is not supported and always raises an
 269         IOError.
 270         """
 271         raise IOError, '[Errno 29] Illegal seek'
 272
 273     def tell( self ):
 274         """
 275         Provides the filepointer position
 276
 277         @exception IOError This method is not supported and always raises an
 278         IOError.
 279         """
 280         raise IOError, '[Errno 29] Illegal seek'
 281
 282     def truncate( self, size = -1 ):
 283         """
 284         Truncates the file
 285
 286         @exception IOError This method is not supported and always raises an
 287         IOError.
 288         """
 289         raise IOError, '[Errno 29] Illegal seek'
 290
 291     def write( self, s ):
 292         """
 293         Writes a string to the file
 294
 295         @param s bytes to be written (string)
 296         """
 297
 298         self.__checkMode( 'w' )
 299         tries = 0
 300         if not self.wpending:
 301             self.wpending = s
 302         elif type( self.wpending ) != type( s ) or \
 303              len( self.wpending ) + len( s ) > self.maxbuffersize:
 304             # flush wpending so that different string types
 305             # are not concatenated
 306             while self.wpending:
 307                 # if we have a persistent error in sending the data,
 308                 # an exception will be raised in __nWrite
 309                 self.flush()
 310                 tries += 1
 311                 if tries > self.maxtries:
 312                     raise socket.error( "Too many attempts to send data" )
 313             self.wpending = s
 314         else:
 315             self.wpending += s
 316         self.__nWrite( self.pendingWrite() )
 317         return
 318
 319     def writelines( self, lines ):
 320         """
 321         Writes a list of strings to the file.
 322
 323         @param lines the list to be written (list of string)
 324         """
 325         map( self.write, lines )
 326         return