Merge pull request #1 from phprtc/recursive-dir-watch

Ahmard · web-flow · commit 2a868061aebb · 2022-03-06T00:23:45.000+01:00
Recursive Directory Watching
diff --git a/src/Watcher.php b/src/Watcher.php
@@ -4,31 +4,45 @@
 namespace RTC\Watcher;
 
 
-use JetBrains\PhpStorm\Pure;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
 use RTC\Watcher\Watching\EventInfo;
 use RTC\Watcher\Watching\EventTrait;
 use RTC\Watcher\Watching\WatchedItem;
-use Swoole\Event as SWEvent;
+use Swoole\Event as SwooleEvent;
 
 class Watcher
 {
-    use EventTrait;
+    use EventTrait {
+        EventTrait::__construct as private __eventTraitConstructor;
+    }
 
     protected mixed $inotifyFD;
     protected array $paths = [];
     protected array $extensions = [];
     protected array $watchedItems = [];
 
+    protected readonly int $maskItemCreated;
+    protected readonly int $maskItemDeleted;
+
     protected array $fileShouldNotEndWith = [
         '~'
     ];
 
 
-    #[Pure] public static function create(): Watcher
+    public static function create(): Watcher
     {
         return new Watcher();
     }
 
+    public function __construct()
+    {
+        $this->__eventTraitConstructor();
+
+        $this->maskItemCreated = Event::ON_CREATE_HIGH->value;
+        $this->maskItemDeleted = Event::ON_DELETE_HIGH->value;
+    }
+
     /**
      * Get inotify file descriptor
      *
@@ -44,6 +58,8 @@ public function getInotifyFD(): mixed
     }
 
     /**
+     * Returns list of files currently being watched
+     *
      * @return WatchedItem[]
      */
     public function getWatchedItems(): array
@@ -58,49 +74,143 @@ public function getWatchedItems(): array
      */
     public function watch(): void
     {
-        static $index = 1;
-
         // Register paths
         foreach ($this->paths as $path) {
-            $this->watchedItems[$index] = $path;
-            inotify_add_watch($this->getInotifyFD(), $path, $this->event->value);
-            $index += 1;
+            $this->recursivelyRegisterInotifyEvent($path);
         }
 
         // Set up a new event listener for inotify read events
-        SWEvent::add($this->getInotifyFD(), function () {
-            $events = inotify_read($this->getInotifyFD());
+        SwooleEvent::add($this->getInotifyFD(), function () {
+            $inotifyEvents = inotify_read($this->getInotifyFD());
 
             // IF WE ARE LISTENING TO 'ON_ALL_EVENTS'
             if ($this->willWatchAny) {
-                foreach ($events as $event) {
-                    if (!empty($event['name'])) {   // Filter out invalid events
-                        $this->fireEvent($event);
-                    }
+                foreach ($inotifyEvents as $inotifyEvent) {
+                    $this->inotifyPerformAdditionalOperations($inotifyEvent);
+
+                    $this->fireEvent($inotifyEvent);
                 }
 
                 return;
             }
 
             // INDIVIDUAL LISTENERS
-            foreach ($events as $event) {
+            foreach ($inotifyEvents as $inotifyEvent) {
+                $this->inotifyPerformAdditionalOperations($inotifyEvent);
+
                 // Make sure that we support this event
-                if (array_key_exists($event['mask'], self::$constants)) {
-                    $this->fireEvent($event);
+                if ($inotifyEvent['mask'] == $this->event->value) {
+                    $this->fireEvent($inotifyEvent);
                 }
             }
 
         });
 
         // Set to monitor and listen for read events for the given $fd
-        SWEvent::set(
+        SwooleEvent::set(
             $this->getInotifyFD(),
             null,
             null,
             SWOOLE_EVENT_READ
         );
     }
 
+    /**
+     * Handles directory creation/deletion on the fly
+     *
+     * @param array $inotifyEvent
+     * @return void
+     */
+    private function inotifyPerformAdditionalOperations(array $inotifyEvent): void
+    {
+        // Handle directory creation
+        if ($inotifyEvent['mask'] == $this->maskItemCreated) {
+            $eventInfo = new EventInfo($inotifyEvent, $this->watchedItems[$inotifyEvent['wd']]);
+            // Register this path also if it's directory
+            if ($eventInfo->getWatchedItem()->isDir()) {
+                $this->recursivelyRegisterInotifyEvent($eventInfo->getWatchedItem()->getFullPath());
+            }
+
+            return;
+        }
+
+        // Handle directory deletion
+        if ($inotifyEvent['mask'] == $this->maskItemDeleted) {
+            $eventInfo = new EventInfo($inotifyEvent, $this->watchedItems[$inotifyEvent['wd']]);
+            // Remove this path also if it's directory
+            if ($eventInfo->getWatchedItem()->isDir()) {
+                $this->removeInotifyEvent($eventInfo);
+            }
+        }
+    }
+
+    /**
+     * Register directory/file to inotify watcher
+     * Loops through directory recursively and register all it's subdirectories as well
+     *
+     * @param string $path
+     * @return void
+     */
+    private function recursivelyRegisterInotifyEvent(string $path): void
+    {
+        if (is_dir($path)) {
+            $iterator = new RecursiveDirectoryIterator($path);
+
+            // Loop through files
+            foreach (new RecursiveIteratorIterator($iterator) as $file) {
+                if ($file->isDir()/**&& !in_array($file->getRealPath(), $this->watchedItems)**/) {
+                    $this->registerInotifyEvent($file->getRealPath());
+                }
+            }
+
+            return;
+        }
+
+        // Register file watch
+        $this->registerInotifyEvent($path);
+    }
+
+    /**
+     * Register directory/file to inotify watcher
+     *
+     * @param string $path
+     * @return void
+     */
+    private function registerInotifyEvent(string $path): void
+    {
+        $descriptor = inotify_add_watch(
+            $this->getInotifyFD(),
+            $path,
+            Event::ON_ALL_EVENTS->value
+        );
+
+        $this->watchedItems[$descriptor] = [
+            'path' => $path,
+            'mask' => $this->event->value,
+        ];
+    }
+
+    /**
+     * Stop watching file/directory
+     *
+     * @param EventInfo $eventInfo
+     * @return void
+     */
+    public function removeInotifyEvent(EventInfo $eventInfo)
+    {
+        // Stop watching event
+        inotify_rm_watch($this->getInotifyFD(), $eventInfo->getWatchDescriptor());
+
+        // Stop tracking descriptor
+        unset($this->watchedItems[$eventInfo->getWatchDescriptor()]);
+    }
+
+    /**
+     * Trigger an event
+     *
+     * @param array $inotifyEvent
+     * @return void
+     */
     private function fireEvent(array $inotifyEvent): void
     {
         $shouldFireEvent = array_key_exists($inotifyEvent['mask'], self::$constants);
@@ -131,7 +241,7 @@ private function fireEvent(array $inotifyEvent): void
 
                 $eventMask = $this->willWatchAny
                     ? Event::ON_ALL_EVENTS->value
-                    : $eventInfo->getMask();
+                    : $eventInfo->getMask()->value;
 
                 $this->eventEmitter->emit($eventMask, [$eventInfo]);
             }
diff --git a/src/Watching/EventInfo.php b/src/Watching/EventInfo.php
@@ -2,6 +2,8 @@
 
 namespace RTC\Watcher\Watching;
 
+use JetBrains\PhpStorm\Pure;
+use RTC\Watcher\Event;
 use RTC\Watcher\Watcher;
 
 class EventInfo
@@ -13,17 +15,17 @@ class EventInfo
 
     public function __construct(
         protected array $event,
-        string $path
+        array $pathData
     )
     {
-        $this->watchedItem = new WatchedItem($path, $this);
+        $this->watchedItem = new WatchedItem($pathData['path'], $this);
         $this->eventMask = $this->event['mask'];
         $this->eventInfo = Watcher::$constants[$event['mask']];
     }
 
-    public function getMask(): int
+    public function getMask(): Event
     {
-        return $this->eventMask;
+        return Event::from($this->eventMask);
     }
 
     public function getName(): string
@@ -44,6 +46,11 @@ public function getEvent(): array
         return $this->event;
     }
 
+    #[Pure] public function getWatchDescriptor(): int
+    {
+        return $this->getEvent()['wd'];
+    }
+
     /**
      * @return WatchedItem
      */
diff --git a/src/Watching/EventTrait.php b/src/Watching/EventTrait.php
@@ -35,9 +35,9 @@ trait EventTrait
         32768 => ['ON_IGNORED', 'Watch was removed (explicitly by inotify_rm_watch() or because file was removed or filesystem unmounted'],
         1073741824 => ['ON_ISDIR', 'Subject of this event is a directory'],
         1073741840 => ['ON_CLOSE_NOWRITE', 'High-bit: File not opened for writing was closed'],
-        1073741856 => ['ON_OPEN', 'High-bit: File was opened'],
-        1073742080 => ['ON_CREATE', 'High-bit: File or directory created in watched directory'],
-        1073742336 => ['ON_DELETE', 'High-bit: File or directory deleted in watched directory'],
+        1073741856 => ['ON_OPEN_HIGH', 'High-bit: File was opened'],
+        1073742080 => ['ON_CREATE_HIGH', 'High-bit: File or directory created in watched directory'],
+        1073742336 => ['ON_DELETE_HIGH', 'High-bit: File or directory deleted in watched directory'],
         16777216 => ['ON_ONLYDIR', 'Only watch pathname if it is a directory (Since Linux 2.6.15)'],
         33554432 => ['ON_DONT_FOLLOW', 'Do not dereference pathname if it is a symlink (Since Linux 2.6.15)'],
         536870912 => ['ON_MASK_ADD', 'Add events to watch mask for this pathname if it already exists (instead of replacing mask).'],

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`
`3`	`3`	`namespace RTC\Watcher\Watching;`
`4`	`4`
	`5`	`+use JetBrains\PhpStorm\Pure;`
	`6`	`+use RTC\Watcher\Event;`
`5`	`7`	`use RTC\Watcher\Watcher;`
`6`	`8`
`7`	`9`	`class EventInfo`
`@@ -13,17 +15,17 @@ class EventInfo`
`13`	`15`
`14`	`16`	`public function __construct(`
`15`	`17`	`protected array $event,`
`16`		`- string $path`
	`18`	`+ array $pathData`
`17`	`19`	`)`
`18`	`20`	`{`
`19`		`- $this->watchedItem = new WatchedItem($path, $this);`
	`21`	`+ $this->watchedItem = new WatchedItem($pathData['path'], $this);`
`20`	`22`	`$this->eventMask = $this->event['mask'];`
`21`	`23`	`$this->eventInfo = Watcher::$constants[$event['mask']];`
`22`	`24`	`}`
`23`	`25`
`24`		`- public function getMask(): int`
	`26`	`+ public function getMask(): Event`
`25`	`27`	`{`
`26`		`- return $this->eventMask;`
	`28`	`+ return Event::from($this->eventMask);`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`public function getName(): string`
`@@ -44,6 +46,11 @@ public function getEvent(): array`
`44`	`46`	`return $this->event;`
`45`	`47`	`}`
`46`	`48`
	`49`	`+ #[Pure] public function getWatchDescriptor(): int`
	`50`	`+ {`
	`51`	`+ return $this->getEvent()['wd'];`
	`52`	`+ }`
	`53`	`+`
`47`	`54`	`/**`
`48`	`55`	`* @return WatchedItem`
`49`	`56`	`*/`