[ResourceWatcher] resource watcher object created

symfony · everzet · Mar 25, 2011 · Mar 25, 2011 · Mar 25, 2011 · Mar 25, 2011
commit 150bc5a738cbc2cf61fdd1ef154d0fe10ea9ac6b
diff --git a/src/Symfony/Component/ResourceWatcher/ResourceWatcher.php b/src/Symfony/Component/ResourceWatcher/ResourceWatcher.php
@@ -0,0 +1,151 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ResourceWatcher;
+
+use Symfony\Component\Config\Resource\ResourceInterface;
+use Symfony\Component\ResourceWatcher\Event\Event;
+use Symfony\Component\ResourceWatcher\Event\EventListener;
+use Symfony\Component\ResourceWatcher\Event\EventListenerInterface;
+use Symfony\Component\ResourceWatcher\Tracker\TrackerInterface;
+
+/**
+ * Resources changes watcher.
+ *
+ * @author Konstantin Kudryashov <ever.zet@gmail.com>
+ */
+class ResourceWatcher
+{
+    private $tracker;
+    private $watching   = true;
+    private $listeners  = array();
+
+    /**
+     * Initializes path watcher.
+     *
+     * @param   TrackerInterface  $tracker
+     */
+    public function __construct(TrackerInterface $tracker)
+    {
+        $this->tracker = $tracker;
+    }
+
+    /**
+     * Track resource with watcher.
+     *
+     * @param   ResourceInterface   $resource   resource to track
+     * @param   callable            $callback   event callback
+     * @param   integer             $eventsMask event types bitmask
+     */
+    public function track(ResourceInterface $resource, $callback, $eventsMask = Event::ALL)
+    {
+        if (!is_callable($callback)) {
+            throw new \InvalidArgumentException('Second argument to track() should be callable.');
+        }
+
+        $this->addListener(new EventListener($resource, $callback, $eventsMask));
+    }
+
+    /**
+     * Adds resource event listener to watcher.
+     *
+     * @param   EventListenerInterface  $listener   resource event listener
+     */
+    public function addListener(EventListenerInterface $listener)
+    {
+        if (!$this->getTracker()->isResourceTracked($listener->getResource())) {
+            $this->getTracker()->track($listener->getResource());
+        }
+
+        $trackingId = $this->getTracker()->getResourceTrackingId($listener->getResource());
+
+        if (!isset($this->listeners[$trackingId])) {
+            $this->listeners[$trackingId] = array();
+        }
+
+        $this->listeners[$trackingId][] = $listener;
+    }
+
+    /**
+     * Returns true if watcher is currently watching on tracked resources (started).
+     *
+     * @return  Boolean
+     */
+    public function isWatching()
+    {
+        return $this->watching;
+    }
+
+    /**
+     * Starts wathing on tracked resources.
+     *
+     * @param   integer $checkInterval  check interval in microseconds
+     * @param   integer $timeLimit      maximum watching time limit in microseconds
+     */
+    public function start($checkInterval = 1000000, $timeLimit = null)
+    {
+        $totalTime = 0;
+        $this->watching = true;
+
+        while ($this->watching) {
+            usleep($checkInterval);
+            $totalTime += $checkInterval;
+
+            if (null !== $timeLimit && $totalTime > $timeLimit) {
+                break;
+            }
+
+            if (count($events = $this->getTracker()->checkChanges())) {
+                $this->notifyListeners($events);
+            }
+        }
+
+        $this->watching = false;
+    }
+
+    /**
+     * Stop watching on tracked resources.
+     */
+    public function stop()
+    {
+        $this->watching = false;
+    }
+
+    /**
+     * Returns current tracker instance.
+     *
+     * @return  TrackerInterface
+     */
+    protected function getTracker()
+    {
+        return $this->tracker;
+    }
+
+    /**
+     * Notifies all registered resource event listeners about their events.
+     *
+     * @param   array   $events     array of resource events
+     */
+    private function notifyListeners(array $events)
+    {
+        foreach ($events as $event) {
+            $trackingId = $event->getTrackingId();
+
+            if (isset($this->listeners[$trackingId])) {
+                foreach ($this->listeners[$trackingId] as $listener) {
+                    if ($listener->handles($event)) {
+                        call_user_func($listener->getCallback(), $event);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/Symfony/Tests/Component/ResourceWatcher/ResourceWatcherTest.php b/tests/Symfony/Tests/Component/ResourceWatcher/ResourceWatcherTest.php
@@ -0,0 +1,160 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Tests\Component\ResourceWatcher;
+
+use Symfony\Component\ResourceWatcher\ResourceWatcher;
+use Symfony\Component\ResourceWatcher\Event\Event;
+
+class ResourceWatcherTest extends \PHPUnit_Framework_TestCase
+{
+    public function testUntrackedResourceTrack()
+    {
+        $tracker = $this
+            ->getMockBuilder('Symfony\Component\ResourceWatcher\Tracker\TrackerInterface')
+            ->getMock();
+
+        $resource = $this
+            ->getMockBuilder('Symfony\Component\Config\Resource\ResourceInterface')
+            ->getMock();
+
+        $tracker
+            ->expects($this->once())
+            ->method('isResourceTracked')
+            ->with($resource)
+            ->will($this->returnValue(false));
+        $tracker
+            ->expects($this->once())
+            ->method('track')
+            ->with($resource)
+            ->will($this->returnValue(null));
+        $tracker
+            ->expects($this->once())
+            ->method('getResourceTrackingId')
+            ->with($resource);
+
+        $watcher = new ResourceWatcher($tracker);
+        $watcher->track($resource, function(){});
+    }
+
+    public function testTrackedResourceTrack()
+    {
+        $tracker = $this
+            ->getMockBuilder('Symfony\Component\ResourceWatcher\Tracker\TrackerInterface')
+            ->getMock();
+
+        $resource = $this
+            ->getMockBuilder('Symfony\Component\Config\Resource\ResourceInterface')
+            ->getMock();
+
+        $tracker
+            ->expects($this->once())
+            ->method('isResourceTracked')
+            ->with($resource)
+            ->will($this->returnValue(true));
+        $tracker
+            ->expects($this->never())
+            ->method('track');
+        $tracker
+            ->expects($this->once())
+            ->method('getResourceTrackingId')
+            ->with($resource);
+
+        $watcher = new ResourceWatcher($tracker);
+        $watcher->track($resource, function(){});
+    }
+
+    public function testWatching()
+    {
+        $tracker = $this
+            ->getMockBuilder('Symfony\Component\ResourceWatcher\Tracker\TrackerInterface')
+            ->getMock();
+
+        $resourceMockBuilder = $this
+            ->getMockBuilder('Symfony\Component\Config\Resource\ResourceInterface');
+
+        $resource1 = $resourceMockBuilder->getMock();
+        $resource2 = $resourceMockBuilder->getMock();
+
+        $listenerMockBuilder = $this
+            ->getMockBuilder('Symfony\Component\ResourceWatcher\Event\EventListenerInterface');
+
+        $listener1 = $listenerMockBuilder->getMock();
+        $listener2 = $listenerMockBuilder->getMock();
+        $listener3 = $listenerMockBuilder->getMock();
+
+        $listener1
+            ->expects($this->exactly(3))
+            ->method('getResource')
+            ->will($this->returnValue($resource1));
+        $listener2
+            ->expects($this->exactly(3))
+            ->method('getResource')
+            ->will($this->returnValue($resource2));
+        $listener3
+            ->expects($this->exactly(2))
+            ->method('getResource')
+            ->will($this->returnValue($resource2));
+
+        $tracker
+            ->expects($this->exactly(3))
+            ->method('isResourceTracked')
+            ->will($this->onConsecutiveCalls(false, false, true));
+        $tracker
+            ->expects($this->exactly(2))
+            ->method('track');
+        $tracker
+            ->expects($this->exactly(3))
+            ->method('getResourceTrackingId')
+            ->will($this->onConsecutiveCalls(1, 2, 2));
+
+        $watcher = new ResourceWatcher($tracker);
+        $watcher->addListener($listener1);
+        $watcher->addListener($listener2);
+        $watcher->addListener($listener3);
+
+        $listener1
+            ->expects($this->once())
+            ->method('handles')
+            ->will($this->returnValue(true));
+        $listener2
+            ->expects($this->exactly(2))
+            ->method('handles')
+            ->will($this->onConsecutiveCalls(false, false));
+        $listener3
+            ->expects($this->exactly(2))
+            ->method('handles')
+            ->will($this->onConsecutiveCalls(true, true));
+
+        $listener1
+            ->expects($this->once())
+            ->method('getCallback')
+            ->will($this->returnValue(function($e){}));
+        $listener2
+            ->expects($this->never())
+            ->method('getCallback');
+        $listener3
+            ->expects($this->exactly(2))
+            ->method('getCallback')
+            ->will($this->returnValue(function($e){}));
+
+        $tracker
+            ->expects($this->once())
+            ->method('checkChanges')
+            ->will($this->returnValue(array(
+                new Event(1, $resource1, 1),
+                new Event(2, $resource2, 1),
+                new Event(2, $resource2, 1),
+            )));
+
+        $watcher->start(1, 1);
+    }
+}