Ticket #2157: conio.patch

_pollingfile.py

@@ -6 +6 @@
 
 """
 
+import sys
 from zope.interface import implements
 
 from twisted.internet.interfaces import IConsumer, IPushProducer
@@ -13 +14 @@
 MIN_TIMEOUT = 0.000000001
 MAX_TIMEOUT = 0.1
 
-class _PollableResource:
+
+class _PollableResource(object):
     active = True
 
     def activate(self):
@@ -22 +24 @@
     def deactivate(self):
         self.active = False
 
-class _PollingTimer:
+
+class _PollingTimer(object):
     # Everything is private here because it is really an implementation detail.
 
     def __init__(self, reactor):
@@ -91 +94 @@
 # If we ever (let's hope not) need the above functionality on UNIX, this could
 # be factored into a different module.
 
-import win32pipe
 import win32file
 import win32api
 import pywintypes
 
-class _PollableReadPipe(_PollableResource):
 
+class _PollableReader(_PollableResource):
+
     implements(IPushProducer)
 
-    def __init__(self, pipe, receivedCallback, lostCallback):
-        # security attributes for pipes
-        self.pipe = pipe
+    def __init__(self, handle, receivedCallback, lostCallback):
+        self.handle = handle
         self.receivedCallback = receivedCallback
         self.lostCallback = lostCallback
 
     def checkWork(self):
-        finished = 0
-        fullDataRead = []
+        raise NotImplementedError()
 
-        while 1:
-            try:
-                buffer, bytesToRead, result = win32pipe.PeekNamedPipe(self.pipe, 1)
-                # finished = (result == -1)
-                if not bytesToRead:
-                    break
-                hr, data = win32file.ReadFile(self.pipe, bytesToRead, None)
-                fullDataRead.append(data)
-            except win32api.error:
-                finished = 1
-                break
-
-        dataBuf = ''.join(fullDataRead)
-        if dataBuf:
-            self.receivedCallback(dataBuf)
-        if finished:
-            self.cleanup()
-        return len(dataBuf)
-
     def cleanup(self):
         self.deactivate()
         self.lostCallback()
 
     def close(self):
         try:
-            win32api.CloseHandle(self.pipe)
+            win32api.CloseHandle(self.handle)
         except pywintypes.error:
             # You can't close std handles...?
             pass
@@ -152 +134 @@
 
 FULL_BUFFER_SIZE = 64 * 1024
 
-class _PollableWritePipe(_PollableResource):
+class _PollableWriter(_PollableResource):
 
     implements(IConsumer)
 
-    def __init__(self, writePipe, lostCallback):
+    def __init__(self, handle, lostCallback):
         self.disconnecting = False
         self.producer = None
         self.producerPaused = 0
         self.streamingProducer = 0
         self.outQueue = []
-        self.writePipe = writePipe
+        self.handle = handle
         self.lostCallback = lostCallback
-        try:
-            win32pipe.SetNamedPipeHandleState(writePipe,
-                                              win32pipe.PIPE_NOWAIT,
-                                              None,
-                                              None)
-        except pywintypes.error:
-            # Maybe it's an invalid handle.  Who knows.
-            pass
 
     def close(self):
         self.disconnecting = True
@@ -219 +193 @@
     def writeConnectionLost(self):
         self.deactivate()
         try:
-            win32api.CloseHandle(self.writePipe)
+            win32api.CloseHandle(self.handle)
         except pywintypes.error:
             # OMG what
             pass
@@ -236 +210 @@
             self.bufferFull()
 
     def checkWork(self):
+        raise NotImplementedError()
+
+
+
+#
+# Pipe support (XXX this should go in _dumbwin32proc.py)
+# 
+import win32pipe
+
+
+class _PollableReadPipe(_PollableReader):
+    def __init__(self, pipe, receivedCallback, lostCallback):
+        _PollableReader.__init__(self, pipe, receivedCallback, lostCallback)
+        # security attributes for pipes
+
+    def checkWork(self):
+        finished = 0
+        fullDataRead = []
+
+        while 1:
+            try:
+                buffer, bytesToRead, result = win32pipe.PeekNamedPipe(self.handle, 1)
+                # finished = (result == -1)
+                if not bytesToRead:
+                    break
+                hr, data = win32file.ReadFile(self.handle, bytesToRead, None)
+                fullDataRead.append(data)
+            except win32api.error:
+                finished = 1
+                break
+
+        dataBuf = ''.join(fullDataRead)
+        if dataBuf:
+            self.receivedCallback(dataBuf)
+        if finished:
+            self.cleanup()
+        return len(dataBuf)
+
+
+class _PollableWritePipe(_PollableWriter):
+    def __init__(self, writePipe, lostCallback):
+        _PollableWriter.__init__(self, writePipe, lostCallback)
+
+        try:
+            win32pipe.SetNamedPipeHandleState(writePipe,
+                                              win32pipe.PIPE_NOWAIT,
+                                              None,
+                                              None)
+        except pywintypes.error:
+            # Maybe it's an invalid handle.  Who knows.
+            pass
+
+    def checkWork(self):
         numBytesWritten = 0
         if not self.outQueue:
             if self.disconnecting:
                 self.writeConnectionLost()
                 return 0
             try:
-                win32file.WriteFile(self.writePipe, '', None)
+                win32file.WriteFile(self.handle, '', None)
             except pywintypes.error:
                 self.writeConnectionLost()
                 return numBytesWritten
@@ -250 +277 @@
             data = self.outQueue.pop(0)
             errCode = 0
             try:
-                errCode, nBytesWritten = win32file.WriteFile(self.writePipe,
+                errCode, nBytesWritten = win32file.WriteFile(self.handle,
                                                              data, None)
             except win32api.error:
                 self.writeConnectionLost()
@@ -268 +295 @@
         return numBytesWritten
 
 
+
+#
+# Console support (XXX this should go in _conio.py)
+#
+# Only base support provided.
+#
+import win32console
+
+
+ENABLE_NORMAL_MODE = win32console.ENABLE_ECHO_INPUT | win32console.ENABLE_LINE_INPUT
+ENABLE_WINDOW_INPUT = win32console.ENABLE_WINDOW_INPUT
+
+
+class _PollableReadConsole(_PollableReader):
+    def __init__(self, conIn, conOut, receivedCallback, lostCallback):
+        _PollableReader.__init__(self, conIn, receivedCallback, lostCallback)
+        self.cp = "cp%d" % win32console.GetConsoleCP()
+        self.buf = []
+        
+        # We need this for echoing
+        self._stdout = conOut
+
+        defaultMode = conIn.GetConsoleMode()
+        conIn.SetConsoleMode(defaultMode | ENABLE_WINDOW_INPUT)
+        self._windowChangeCallback = None
+        
+        self.checkWork = self._checkWork
+
+    def enableRawMode(self, enabled=True):
+        """Enable raw mode.
+        """
+
+        mode = self.handle.GetConsoleMode()
+        if enabled:
+            # Flush buffer
+            dataBuf = ''.join(self.buf)
+            self.buf = []
+
+            if dataBuf:
+                self.receivedCallback(dataBuf)
+
+            self.checkWork = self._checkWork_raw
+
+            # Set mode on the system console, too
+            # XXX check me (this seems not to work)
+            self.handle.SetConsoleMode(mode & ~ENABLE_NORMAL_MODE)
+        else:
+            self.checkWork = self._checkWork
+            
+            # Set mode on the system console, too
+            self.handle.SetConsoleMode(mode | ENABLE_NORMAL_MODE)
+
+    def setWindowChandeCallback(self, callback):
+        """callback is called when the console window buffer is
+        changed.
+
+        Note: WINDOW_BUFFER_SIZE_EVENT is only raised when changing
+              the window *buffer* size from the console menu
+        """
+        
+        self._windowChangeCallback = callback
+
+            
+    def _checkWork(self):
+        try:
+            info = self._stdout.GetConsoleScreenBufferInfo()
+        except pywintypes.error:
+            # stdout handle has been closed
+            self.cleanup()
+            return 0
+            
+        rowSize = info["MaximumWindowSize"].X 
+
+        # How much data we read
+        workUnits = 0
+        
+        # Initialize the current cursor position
+        if not self.buf:
+            self.pos = info["CursorPosition"]
+            
+        while 1:
+            n = self.handle.GetNumberOfConsoleInputEvents()
+            if n == 0:
+                break
+                
+            records = self.handle.ReadConsoleInput(n)
+                
+            # Process input
+            for record in records:
+                if record.EventType == win32console.WINDOW_BUFFER_SIZE_EVENT:
+                    rowSize = record.Size.X
+                    if self._windowChangeCallback:
+                        self._windowChangeCallback()
+                if record.EventType != win32console.KEY_EVENT \
+                        or not record.KeyDown:
+                    continue
+
+                char = record.Char
+                n = record.RepeatCount
+                if char == '\b':
+                    pos = self._stdout.GetConsoleScreenBufferInfo()["CursorPosition"]
+                    
+                    # Move the cursor
+                    x = pos.X - n
+                    if x >= 0:
+                        pos.X = x
+                    # XXX assuming |x| < rowSize (I'm lazy)
+                    elif pos.Y > self.pos.Y:
+                        pos.X = rowSize - 1
+                        pos.Y -= 1
+
+                    self._stdout.SetConsoleCursorPosition(pos)
+                    self._stdout.WriteConsoleOutputCharacter(' ' * n, pos)
+                    
+                    self.buf = self.buf[:-n]
+                    continue
+                elif char == '\0':
+                    vCode = record.VirtualKeyCode
+                    # XXX TODO handle keyboard navigation
+                    continue
+                elif char == '\r':
+                    char = '\r\n' * n # XXX check me
+
+                    self.buf.append(char)
+                    self._stdout.WriteConsole(char) # do echo
+                    
+                    dataBuf = ''.join(self.buf)
+                    self.buf = []
+                    self.pos = info["CursorPosition"]
+
+                    self.receivedCallback(dataBuf)
+                    return len(dataBuf)
+
+                char = char * n
+                data = char.encode(self.cp)
+                self._stdout.WriteConsole(data) # do echo
+                
+                self.buf.append(data)
+                workUnits += n
+
+        return workUnits
+
+    def _checkWork_raw(self):
+        # local buffer
+        buf = []
+
+        while 1: # XXX is this loop really needed?
+            n = self.handle.GetNumberOfConsoleInputEvents()
+            if n == 0:
+                break
+                
+            records = self.handle.ReadConsoleInput(n)
+                
+            # Process input
+            for record in records:
+                if record.EventType == win32console.WINDOW_BUFFER_SIZE_EVENT:
+                    if self._windowChangeCallback:
+                        self._windowChangeCallback()
+                if record.EventType != win32console.KEY_EVENT \
+                        or not record.KeyDown:
+                    continue
+
+                char = record.Char
+                n = record.RepeatCount
+                if char == '\0':
+                    continue
+                elif char == '\r':
+                    char = '\r\n' * n # XXX check me
+
+                char = char * n
+                data = char.encode(self.cp)
+                
+                buf.append(data)
+
+
+        dataBuf = ''.join(buf)
+        if dataBuf:
+            self.receivedCallback(dataBuf)
+
+        return len(dataBuf)
+
+
+class _PollableWriteConsole(_PollableWriter):
+    def __init__(self, con, lostCallback):
+        _PollableWriter.__init__(self, con, lostCallback)
+
+        self.cp = "cp%d" % win32console.GetConsoleOutputCP()
+
+
+    def checkWork(self):
+        numBytesWritten = 0
+        if not self.outQueue:
+            if self.disconnecting:
+                self.writeConnectionLost()
+                return 0
+            try:
+                self.handle.WriteConsole('')
+            except pywintypes.error:
+                self.writeConnectionLost()
+                return numBytesWritten
+        while self.outQueue:
+            data = self.outQueue.pop(0)
+            errCode = 0
+            try:
+                # XXX check if this can block
+                nBytesWritten = self.handle.WriteConsole(data)
+            except win32console.error:
+                self.writeConnectionLost()
+                break
+            else:
+                # assert not errCode, "wtf an error code???"
+                numBytesWritten += nBytesWritten
+                if len(data) > nBytesWritten:
+                    self.outQueue.insert(0, data[nBytesWritten:])
+                    break
+        else:
+            resumed = self.bufferEmpty()
+            if not resumed and self.disconnecting:
+                self.writeConnectionLost()
+        return numBytesWritten

_win32stdio.py

@@ -1 +1 @@
 # -*- test-case-name: twisted.test.test_process.ProcessTestCase.testStdio -*-
 
 import win32api
+import win32console
 import os, msvcrt
 
 from zope.interface import implements
 
 from twisted.internet.interfaces import IHalfCloseableProtocol, ITransport, IAddress
 from twisted.internet.interfaces import IConsumer, IPushProducer
+from twisted.internet import main
 
-from twisted.internet import _pollingfile, main
+import _pollingfile
 
+
 class Win32PipeAddress(object):
     implements(IAddress)
 
@@ -35 +38 @@
 
         _pollingfile._PollingTimer.__init__(self, reactor)
         self.proto = proto
+        
+        # Check if we are connected to a console
+        if os.isatty(0):
+            hstdin = win32console.GetStdHandle(win32console.STD_INPUT_HANDLE)
+            hstdout = win32console.GetStdHandle(win32console.STD_OUTPUT_HANDLE)
 
-        hstdin = win32api.GetStdHandle(win32api.STD_INPUT_HANDLE)
-        hstdout = win32api.GetStdHandle(win32api.STD_OUTPUT_HANDLE)
+            self.stdin = _pollingfile._PollableReadConsole(
+                hstdin, hstdout, self.dataReceived, self.readConnectionLost)
 
-        self.stdin = _pollingfile._PollableReadPipe(
-            hstdin, self.dataReceived, self.readConnectionLost)
+            self.stdout = _pollingfile._PollableWriteConsole(
+                hstdout, self.writeConnectionLost)
+        else:
+            hstdin = win32api.GetStdHandle(win32api.STD_INPUT_HANDLE)
+            hstdout = win32api.GetStdHandle(win32api.STD_OUTPUT_HANDLE)
 
-        self.stdout = _pollingfile._PollableWritePipe(
-            hstdout, self.writeConnectionLost)
+            self.stdin = _pollingfile._PollableReadPipe(
+                hstdin, self.dataReceived, self.readConnectionLost)
 
+            self.stdout = _pollingfile._PollableWritePipe(
+                hstdout, self.writeConnectionLost)
+            
         self._addPollableResource(self.stdin)
         self._addPollableResource(self.stdout)
 
@@ -113 +127 @@
 
     def resumeProducing(self):
         self.stdin.resumeProducing()
-