def ThreadLoop(self, startupEvent): try: hDir = CreateFile( self.path, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE, None, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, 0) if hDir == INVALID_HANDLE_VALUE: self.startException = FormatError() startupEvent.set() return overlapped = OVERLAPPED() overlapped.hEvent = CreateEvent(None, 1, 0, None) buffer = (c_byte * BUFSIZE)() events = (HANDLE * 2)(overlapped.hEvent, self.stopEvent) flags = (FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_SECURITY) includeSubdirs = self.includeSubdirs renamePath = None bytesReturned = DWORD() noneCallback = cast(None, LPOVERLAPPED_COMPLETION_ROUTINE) startupEvent.set() while 1: ReadDirectoryChangesW(hDir, buffer, BUFSIZE, includeSubdirs, flags, byref(bytesReturned), byref(overlapped), noneCallback) rc = MsgWaitForMultipleObjects(2, events, 0, INFINITE, QS_ALLINPUT) if rc == WAIT_OBJECT_0: res = GetOverlappedResult(hDir, byref(overlapped), byref(bytesReturned), 1) address = addressof(buffer) while True: fni = FILE_NOTIFY_INFORMATION.from_address(address) length = fni.FileNameLength / WCHAR_SIZE fileName = wstring_at(address + 12, length) action = fni.Action fullFilename = os.path.join(self.path, fileName) if action == FILE_ACTION_ADDED: self.TriggerEvent("Created", (fullFilename, )) elif action == FILE_ACTION_REMOVED: self.TriggerEvent("Deleted", (fullFilename, )) elif action == FILE_ACTION_MODIFIED: self.TriggerEvent("Updated", (fullFilename, )) elif action == FILE_ACTION_RENAMED_OLD_NAME: renamePath = fullFilename elif action == FILE_ACTION_RENAMED_NEW_NAME: self.TriggerEvent("Renamed", (renamePath, fullFilename)) renamePath = None if fni.NextEntryOffset == 0: break address += fni.NextEntryOffset elif rc == WAIT_OBJECT_0 + 1: break CloseHandle(hDir) except: self.thread = None raise
def StatusCheckLoop(self): hComm = self.hFile waitingOnStatusHandle = False dwCommEvent = DWORD() dwOvRes = DWORD() commMask = ( EV_BREAK | EV_CTS | EV_DSR | EV_ERR | EV_RING | EV_RLSD | EV_RXCHAR | EV_RXFLAG | EV_TXEMPTY ) if not SetCommMask(self.hFile, commMask): raise SerialError("error setting communications mask") osStatus = OVERLAPPED(0) osStatus.hEvent = CreateEvent(None, 1, 0, None) if not osStatus.hEvent: raise SerialError("error creating event") while True: # Issue a status event check if one hasn't been issued already. if not waitingOnStatusHandle: if WaitCommEvent(hComm, byref(dwCommEvent), byref(osStatus)): # WaitCommEvent returned immediately. # Deal with status event as appropriate. self.ReportStatusEvent(dwCommEvent.value) else: if GetLastError() == ERROR_IO_PENDING: waitingOnStatusHandle = True else: raise SerialError("error in WaitCommEvent") # Check on overlapped operation if waitingOnStatusHandle: # Wait a little while for an event to occur. res = WaitForSingleObject(osStatus.hEvent, 1000) if res == WAIT_OBJECT_0: if GetOverlappedResult( hComm, byref(osStatus), byref(dwOvRes), 0 ): # Status event is stored in the event flag # specified in the original WaitCommEvent call. # Deal with the status event as appropriate. self.ReportStatusEvent(dwCommEvent.value) else: # An error occurred in the overlapped operation; # call GetLastError to find out what it was # and abort if it is fatal. raise SerialError() # Set waitingOnStatusHandle flag to indicate that a new # WaitCommEvent is to be issued. waitingOnStatusHandle = True elif res == WAIT_TIMEOUT: print "timeout" else: # This indicates a problem with the OVERLAPPED structure's # event handle. CloseHandle(osStatus.hEvent) raise SerialError("error in the WaitForSingleObject") CloseHandle(osStatus.hEvent)
def ReceiveThreadProc(self): hFile = self.hFile osReader = self.osReader lpBuf = create_string_buffer(1) dwRead = DWORD() pHandles = (HANDLE * 2)(osReader.hEvent, self.stopEvent) waitingOnRead = False while self.keepAlive: #print "ReceiveThreadProc" # if no read is outstanding, then issue another one if not waitingOnRead: #print "ResetEvent" ResetEvent(osReader.hEvent) returnValue = self._ReadFile( hFile, lpBuf, 1, # we want to get notified as soon as a byte is available byref(dwRead), byref(osReader) ) if not returnValue: err = GetLastError() if err != 0 and err != ERROR_IO_PENDING: raise SerialError() waitingOnRead = True else: # read completed immediately if dwRead.value: self.HandleReceive(lpBuf.raw) continue ret = MsgWaitForMultipleObjects( 2, pHandles, 0, 100000, QS_ALLINPUT ) if ret == WAIT_OBJECT_0: returnValue = GetOverlappedResult( hFile, byref(osReader), byref(dwRead), 0 ) #print "GetOverlappedResult", returnValue, dwRead.value waitingOnRead = False if returnValue and dwRead.value: self.HandleReceive(lpBuf.raw) elif ret == WAIT_OBJECT_0 + 1: #print "WAIT_OBJECT_1" # stop event signaled self.readCondition.acquire() self.readCondition.notifyAll() self.readCondition.release() break elif ret == WAIT_TIMEOUT: #print "WAIT_TIMEOUT" pass else: raise SerialError("Unknown message in ReceiveThreadProc")
def Write(self, data): """ Writes a string to the port. """ dwWritten = DWORD(0) returnValue = self._WriteFile(self.hFile, data, len(data), byref(dwWritten), byref(self.osWriter)) if returnValue != 0: return err = GetLastError() if err != 0 and err != ERROR_IO_PENDING: raise SerialError() if not GetOverlappedResult(self.hFile, byref(self.osWriter), byref(dwWritten), 1): raise SerialError() if dwWritten.value != len(data): raise self.SerialError("Write timeout")