149 lines
4.8 KiB
Python
149 lines
4.8 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright 2011 Yesudeep Mangalapilly <yesudeep@gmail.com>
|
|
# Copyright 2012 Google, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
|
|
"""
|
|
:module: watchdog.observers.polling
|
|
:synopsis: Polling emitter implementation.
|
|
:author: yesudeep@google.com (Yesudeep Mangalapilly)
|
|
|
|
Classes
|
|
-------
|
|
.. autoclass:: PollingObserver
|
|
:members:
|
|
:show-inheritance:
|
|
|
|
.. autoclass:: PollingObserverVFS
|
|
:members:
|
|
:show-inheritance:
|
|
:special-members:
|
|
"""
|
|
|
|
from __future__ import with_statement
|
|
import os
|
|
import threading
|
|
from functools import partial
|
|
from ..utils import stat as default_stat
|
|
from ..utils.dirsnapshot import DirectorySnapshot, \
|
|
DirectorySnapshotDiff
|
|
from ..observers.api import (
|
|
EventEmitter,
|
|
BaseObserver,
|
|
DEFAULT_OBSERVER_TIMEOUT,
|
|
DEFAULT_EMITTER_TIMEOUT
|
|
)
|
|
|
|
from ..events import (
|
|
DirMovedEvent,
|
|
DirDeletedEvent,
|
|
DirCreatedEvent,
|
|
DirModifiedEvent,
|
|
FileMovedEvent,
|
|
FileDeletedEvent,
|
|
FileCreatedEvent,
|
|
FileModifiedEvent
|
|
)
|
|
|
|
|
|
class PollingEmitter(EventEmitter):
|
|
"""
|
|
Platform-independent emitter that polls a directory to detect file
|
|
system changes.
|
|
"""
|
|
|
|
def __init__(self, event_queue, watch, timeout=DEFAULT_EMITTER_TIMEOUT,
|
|
stat=default_stat, listdir=os.listdir):
|
|
EventEmitter.__init__(self, event_queue, watch, timeout)
|
|
self._snapshot = None
|
|
self._lock = threading.Lock()
|
|
self._take_snapshot = lambda: DirectorySnapshot(
|
|
self.watch.path, self.watch.is_recursive, stat=stat, listdir=listdir)
|
|
|
|
def on_thread_start(self):
|
|
self._snapshot = self._take_snapshot()
|
|
|
|
def queue_events(self, timeout):
|
|
# We don't want to hit the disk continuously.
|
|
# timeout behaves like an interval for polling emitters.
|
|
if self.stopped_event.wait(timeout):
|
|
return
|
|
|
|
with self._lock:
|
|
if not self.should_keep_running():
|
|
return
|
|
|
|
# Get event diff between fresh snapshot and previous snapshot.
|
|
# Update snapshot.
|
|
try:
|
|
new_snapshot = self._take_snapshot()
|
|
except OSError as e:
|
|
self.queue_event(DirDeletedEvent(self.watch.path))
|
|
self.stop()
|
|
return
|
|
except Exception as e:
|
|
raise e
|
|
|
|
events = DirectorySnapshotDiff(self._snapshot, new_snapshot)
|
|
self._snapshot = new_snapshot
|
|
|
|
# Files.
|
|
for src_path in events.files_deleted:
|
|
self.queue_event(FileDeletedEvent(src_path))
|
|
for src_path in events.files_modified:
|
|
self.queue_event(FileModifiedEvent(src_path))
|
|
for src_path in events.files_created:
|
|
self.queue_event(FileCreatedEvent(src_path))
|
|
for src_path, dest_path in events.files_moved:
|
|
self.queue_event(FileMovedEvent(src_path, dest_path))
|
|
|
|
# Directories.
|
|
for src_path in events.dirs_deleted:
|
|
self.queue_event(DirDeletedEvent(src_path))
|
|
for src_path in events.dirs_modified:
|
|
self.queue_event(DirModifiedEvent(src_path))
|
|
for src_path in events.dirs_created:
|
|
self.queue_event(DirCreatedEvent(src_path))
|
|
for src_path, dest_path in events.dirs_moved:
|
|
self.queue_event(DirMovedEvent(src_path, dest_path))
|
|
|
|
|
|
class PollingObserver(BaseObserver):
|
|
"""
|
|
Platform-independent observer that polls a directory to detect file
|
|
system changes.
|
|
"""
|
|
|
|
def __init__(self, timeout=DEFAULT_OBSERVER_TIMEOUT):
|
|
BaseObserver.__init__(self, emitter_class=PollingEmitter, timeout=timeout)
|
|
|
|
|
|
class PollingObserverVFS(BaseObserver):
|
|
"""
|
|
File system independent observer that polls a directory to detect changes.
|
|
"""
|
|
|
|
def __init__(self, stat, listdir, polling_interval=1):
|
|
"""
|
|
:param stat: stat function. See ``os.stat`` for details.
|
|
:param listdir: listdir function. See ``os.listdir`` for details.
|
|
:type polling_interval: float
|
|
:param polling_interval: interval in seconds between polling the file system.
|
|
"""
|
|
emitter_cls = partial(PollingEmitter, stat=stat, listdir=listdir)
|
|
BaseObserver.__init__(self, emitter_class=emitter_cls, timeout=polling_interval)
|