src/allmydata/windows/inotify.py

   1
   2 # Windows near-equivalent to twisted.internet.inotify
   3 # This should only be imported on Windows.
   4
   5 import os, sys
   6
   7 from twisted.internet import reactor
   8 from twisted.internet.threads import deferToThread
   9
  10 from allmydata.util.fake_inotify import humanReadableMask, \
  11     IN_WATCH_MASK, IN_ACCESS, IN_MODIFY, IN_ATTRIB, IN_CLOSE_NOWRITE, IN_CLOSE_WRITE, \
  12     IN_OPEN, IN_MOVED_FROM, IN_MOVED_TO, IN_CREATE, IN_DELETE, IN_DELETE_SELF, \
  13     IN_MOVE_SELF, IN_UNMOUNT, IN_Q_OVERFLOW, IN_IGNORED, IN_ONLYDIR, IN_DONT_FOLLOW, \
  14     IN_MASK_ADD, IN_ISDIR, IN_ONESHOT, IN_CLOSE, IN_MOVED, IN_CHANGED
  15 [humanReadableMask, \
  16     IN_WATCH_MASK, IN_ACCESS, IN_MODIFY, IN_ATTRIB, IN_CLOSE_NOWRITE, IN_CLOSE_WRITE, \
  17     IN_OPEN, IN_MOVED_FROM, IN_MOVED_TO, IN_CREATE, IN_DELETE, IN_DELETE_SELF, \
  18     IN_MOVE_SELF, IN_UNMOUNT, IN_Q_OVERFLOW, IN_IGNORED, IN_ONLYDIR, IN_DONT_FOLLOW, \
  19     IN_MASK_ADD, IN_ISDIR, IN_ONESHOT, IN_CLOSE, IN_MOVED, IN_CHANGED]
  20
  21 from allmydata.util.assertutil import _assert, precondition
  22 from allmydata.util.encodingutil import quote_output
  23 from allmydata.util import log, fileutil
  24 from allmydata.util.pollmixin import PollMixin
  25
  26 from ctypes import WINFUNCTYPE, WinError, windll, POINTER, byref, create_string_buffer, \
  27     addressof, get_last_error
  28 from ctypes.wintypes import BOOL, HANDLE, DWORD, LPCWSTR, LPVOID
  29
  30 # <http://msdn.microsoft.com/en-us/library/gg258116%28v=vs.85%29.aspx>
  31 FILE_LIST_DIRECTORY              = 1
  32
  33 # <http://msdn.microsoft.com/en-us/library/aa363858%28v=vs.85%29.aspx>
  34 CreateFileW = WINFUNCTYPE(
  35     HANDLE,  LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE,
  36     use_last_error=True
  37 )(("CreateFileW", windll.kernel32))
  38
  39 FILE_SHARE_READ                  = 0x00000001
  40 FILE_SHARE_WRITE                 = 0x00000002
  41 FILE_SHARE_DELETE                = 0x00000004
  42
  43 OPEN_EXISTING                    = 3
  44
  45 FILE_FLAG_BACKUP_SEMANTICS       = 0x02000000
  46
  47 # <http://msdn.microsoft.com/en-us/library/ms724211%28v=vs.85%29.aspx>
  48 CloseHandle = WINFUNCTYPE(
  49     BOOL,  HANDLE,
  50     use_last_error=True
  51 )(("CloseHandle", windll.kernel32))
  52
  53 # <http://msdn.microsoft.com/en-us/library/aa365465%28v=vs.85%29.aspx>
  54 ReadDirectoryChangesW = WINFUNCTYPE(
  55     BOOL,  HANDLE, LPVOID, DWORD, BOOL, DWORD, POINTER(DWORD), LPVOID, LPVOID,
  56     use_last_error=True
  57 )(("ReadDirectoryChangesW", windll.kernel32))
  58
  59 FILE_NOTIFY_CHANGE_FILE_NAME     = 0x00000001
  60 FILE_NOTIFY_CHANGE_DIR_NAME      = 0x00000002
  61 FILE_NOTIFY_CHANGE_ATTRIBUTES    = 0x00000004
  62 #FILE_NOTIFY_CHANGE_SIZE         = 0x00000008
  63 FILE_NOTIFY_CHANGE_LAST_WRITE    = 0x00000010
  64 FILE_NOTIFY_CHANGE_LAST_ACCESS   = 0x00000020
  65 #FILE_NOTIFY_CHANGE_CREATION     = 0x00000040
  66 FILE_NOTIFY_CHANGE_SECURITY      = 0x00000100
  67
  68 # <http://msdn.microsoft.com/en-us/library/aa364391%28v=vs.85%29.aspx>
  69 FILE_ACTION_ADDED                = 0x00000001
  70 FILE_ACTION_REMOVED              = 0x00000002
  71 FILE_ACTION_MODIFIED             = 0x00000003
  72 FILE_ACTION_RENAMED_OLD_NAME     = 0x00000004
  73 FILE_ACTION_RENAMED_NEW_NAME     = 0x00000005
  74
  75 _action_to_string = {
  76     FILE_ACTION_ADDED            : "FILE_ACTION_ADDED",
  77     FILE_ACTION_REMOVED          : "FILE_ACTION_REMOVED",
  78     FILE_ACTION_MODIFIED         : "FILE_ACTION_MODIFIED",
  79     FILE_ACTION_RENAMED_OLD_NAME : "FILE_ACTION_RENAMED_OLD_NAME",
  80     FILE_ACTION_RENAMED_NEW_NAME : "FILE_ACTION_RENAMED_NEW_NAME",
  81 }
  82
  83 _action_to_inotify_mask = {
  84     FILE_ACTION_ADDED            : IN_CREATE,
  85     FILE_ACTION_REMOVED          : IN_DELETE,
  86     FILE_ACTION_MODIFIED         : IN_CHANGED,
  87     FILE_ACTION_RENAMED_OLD_NAME : IN_MOVED_FROM,
  88     FILE_ACTION_RENAMED_NEW_NAME : IN_MOVED_TO,
  89 }
  90
  91 INVALID_HANDLE_VALUE             = 0xFFFFFFFF
  92
  93
  94 class Event(object):
  95     """
  96     * action:   a FILE_ACTION_* constant (not a bit mask)
  97     * filename: a Unicode string, giving the name relative to the watched directory
  98     """
  99     def __init__(self, action, filename):
 100         self.action = action
 101         self.filename = filename
 102
 103     def __repr__(self):
 104         return "Event(%r, %r)" % (_action_to_string.get(self.action, self.action), self.filename)
 105
 106
 107 class FileNotifyInformation(object):
 108     """
 109     I represent a buffer containing FILE_NOTIFY_INFORMATION structures, and can
 110     iterate over those structures, decoding them into Event objects.
 111     """
 112
 113     def __init__(self, size=1024):
 114         self.size = size
 115         self.buffer = create_string_buffer(size)
 116         address = addressof(self.buffer)
 117         _assert(address & 3 == 0, "address 0x%X returned by create_string_buffer is not DWORD-aligned" % (address,))
 118         self.data = None
 119
 120     def read_changes(self, hDirectory, recursive, filter):
 121         bytes_returned = DWORD(0)
 122         r = ReadDirectoryChangesW(hDirectory,
 123                                   self.buffer,
 124                                   self.size,
 125                                   recursive,
 126                                   filter,
 127                                   byref(bytes_returned),
 128                                   None,  # NULL -> no overlapped I/O
 129                                   None   # NULL -> no completion routine
 130                                  )
 131         if r == 0:
 132             raise WinError(get_last_error())
 133         self.data = self.buffer.raw[:bytes_returned.value]
 134
 135     def __iter__(self):
 136         # Iterator implemented as generator: <http://docs.python.org/library/stdtypes.html#generator-types>
 137         pos = 0
 138         while True:
 139             bytes = self._read_dword(pos+8)
 140             s = Event(self._read_dword(pos+4),
 141                       self.data[pos+12 : pos+12+bytes].decode('utf-16-le'))
 142
 143             next_entry_offset = self._read_dword(pos)
 144             yield s
 145             if next_entry_offset == 0:
 146                 break
 147             pos = pos + next_entry_offset
 148
 149     def _read_dword(self, i):
 150         # little-endian
 151         return ( ord(self.data[i])          |
 152                 (ord(self.data[i+1]) <<  8) |
 153                 (ord(self.data[i+2]) << 16) |
 154                 (ord(self.data[i+3]) << 24))
 155
 156
 157 def _open_directory(path_u):
 158     hDirectory = CreateFileW(path_u,
 159                              FILE_LIST_DIRECTORY,         # access rights
 160                              FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 161                                                           # don't prevent other processes from accessing
 162                              None,                        # no security descriptor
 163                              OPEN_EXISTING,               # directory must already exist
 164                              FILE_FLAG_BACKUP_SEMANTICS,  # necessary to open a directory
 165                              None                         # no template file
 166                             )
 167     if hDirectory == INVALID_HANDLE_VALUE:
 168         e = WinError(get_last_error())
 169         raise OSError("Opening directory %s gave WinError: %s" % (quote_output(path_u), e))
 170     return hDirectory
 171
 172
 173 def simple_test():
 174     path_u = u"test"
 175     filter = FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE
 176     recursive = False
 177
 178     hDirectory = _open_directory(path_u)
 179     fni = FileNotifyInformation()
 180     print "Waiting..."
 181     while True:
 182         fni.read_changes(hDirectory, recursive, filter)
 183         print repr(fni.data)
 184         for info in fni:
 185             print info
 186
 187
 188 NOT_STARTED = "NOT_STARTED"
 189 STARTED     = "STARTED"
 190 STOPPING    = "STOPPING"
 191 STOPPED     = "STOPPED"
 192
 193 class INotify(PollMixin):
 194     def __init__(self):
 195         self._state = NOT_STARTED
 196         self._filter = None
 197         self._callbacks = None
 198         self._hDirectory = None
 199         self._path = None
 200         self._pending = set()
 201         self._pending_delay = 1.0
 202
 203     def set_pending_delay(self, delay):
 204         self._pending_delay = delay
 205
 206     def startReading(self):
 207         deferToThread(self._thread)
 208         return self.poll(lambda: self._state != NOT_STARTED)
 209
 210     def stopReading(self):
 211         # FIXME race conditions
 212         if self._state != STOPPED:
 213             self._state = STOPPING
 214
 215     def wait_until_stopped(self):
 216         fileutil.write(os.path.join(self._path.path, u".ignore-me"), "")
 217         return self.poll(lambda: self._state == STOPPED)
 218
 219     def watch(self, path, mask=IN_WATCH_MASK, autoAdd=False, callbacks=None, recursive=False):
 220         precondition(self._state == NOT_STARTED, "watch() can only be called before startReading()", state=self._state)
 221         precondition(self._filter is None, "only one watch is supported")
 222         precondition(isinstance(autoAdd, bool), autoAdd=autoAdd)
 223         precondition(isinstance(recursive, bool), recursive=recursive)
 224         precondition(autoAdd == recursive, "need autoAdd and recursive to be the same", autoAdd=autoAdd, recursive=recursive)
 225
 226         self._path = path
 227         path_u = path.path
 228         if not isinstance(path_u, unicode):
 229             path_u = path_u.decode(sys.getfilesystemencoding())
 230             _assert(isinstance(path_u, unicode), path_u=path_u)
 231
 232         self._filter = FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE
 233
 234         if mask & (IN_ACCESS | IN_CLOSE_NOWRITE | IN_OPEN):
 235             self._filter = self._filter | FILE_NOTIFY_CHANGE_LAST_ACCESS
 236         if mask & IN_ATTRIB:
 237             self._filter = self._filter | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SECURITY
 238
 239         self._recursive = recursive
 240         self._callbacks = callbacks or []
 241         self._hDirectory = _open_directory(path_u)
 242
 243     def _thread(self):
 244         try:
 245             _assert(self._filter is not None, "no watch set")
 246
 247             # To call Twisted or Tahoe APIs, use reactor.callFromThread as described in
 248             # <http://twistedmatrix.com/documents/current/core/howto/threading.html>.
 249
 250             fni = FileNotifyInformation()
 251
 252             while True:
 253                 self._state = STARTED
 254                 fni.read_changes(self._hDirectory, self._recursive, self._filter)
 255                 for info in fni:
 256                     if self._state == STOPPING:
 257                         hDirectory = self._hDirectory
 258                         self._callbacks = None
 259                         self._hDirectory = None
 260                         CloseHandle(hDirectory)
 261                         self._state = STOPPED
 262                         return
 263
 264                     path = self._path.preauthChild(info.filename)  # FilePath with Unicode path
 265                     #mask = _action_to_inotify_mask.get(info.action, IN_CHANGED)
 266
 267                     def _maybe_notify(path):
 268                         if path not in self._pending:
 269                             self._pending.add(path)
 270                             def _do_callbacks():
 271                                 self._pending.remove(path)
 272                                 for cb in self._callbacks:
 273                                     try:
 274                                         cb(None, path, IN_CHANGED)
 275                                     except Exception, e:
 276                                         log.err(e)
 277                             reactor.callLater(self._pending_delay, _do_callbacks)
 278                     reactor.callFromThread(_maybe_notify, path)
 279         except Exception, e:
 280             log.err(e)
 281             self._state = STOPPED
 282             raise