Monitoring for Filesystem Changes using PHP and Laravel

Let’s say you have a Laravel application that does some data processing, and you want to monitor a directory for incoming changes, that you can then process using queued jobs. There are a couple of ways you could do something like this.

You could scan those directories on a schedule using a cronjob. It’s doable. But what happens if you want to monitor a few thousand directories for changes? You can use tools like incron. Also doable, but another dependency.

But what if I told you you could do it all with PHP. And within Laravel, no less?

This is where the PHP inotify extension comes in. Be aware that this is not installed with the standard PHP installation. It’s part of PECL, the 2000s throwback. So, to get started, you will first need to install the extension:

$ pecl install inotify

And let pecl do it’s thing. Follow any instructions to install the extension and be sure it’s working. php -i | grep inotify is usually sufficient.

Now, in your Laravel app, create a new command. We’ll call it watch. Make it look something like this:


namespace App\Console\Commands;

use Illuminate\Console\Command;
use Log;

use Symfony\Component\Finder\Finder;

class Watch extends Command {
    protected $signature = 'watch';
    protected $description = 'Watches paths for changes.';

    private $mapping = [];
    private $io_instance = null;
    private $semaphore = true;

    public function handle() {
        $directories = ["/tmp/foo", "/tmp/bar"];

        if (!empty($directories)) {
            $this->io_instance = inotify_init();
            stream_set_blocking($this->io_instance, 0);

            foreach ($directories as $directory) {

            while ($this->semaphore) {
                $events = inotify_read($this->io_instance);

                if (!empty($events)) {
                    foreach ($events as $event) {
                        $dir = $this->mapping[$event['wd']];
                        $filename = $event['name'];
                        $path = "$dir/$filename";
                        Log::info("Found event for $path.");

                        $job = new MyJob();
                        $job->file = $path;

            Log::info("Shutting down gracefully.");
            foreach (array_keys($this->mapping) as $watch) {
                inotify_rm_watch($this->io_instance, $watch);


    private function add_watch($dir) {
        $watch = inotify_add_watch($this->io_instance, $dir, IN_CREATE | IN_DELETE | IN_MODIFY );
        $this->mapping[$watch] = $dir;
        Log::info("Watching " . $dir);

Don’t forget to add your new command to the Kernel.php file. And you trigger your job just like you would run any other artisan command:

$ php artisan watch

Try moving some files in and watch it pick up the changes and dispatch the jobs. Pretty neat!

One thing to be aware of is that it will not watch subdirectories. You will need to add a separate inotify_add_watch for every directory you want monitored. I highly suggest pairing this with the Symfony Finder component as a great way to get an entire tree of directories, each of which can have an inotify_add_watch on them.

So now that you have a command, you just have to run it someway. And, just like with Laravel queues, you can run this using a monitoring daemon. I personally like supervisord. So you might add this config:

command=php /path/to/installation/artisan watch

Stuff that into supervisord and restart, and you’re good to go!

Did something I wrote help you out?

That's great! I don't earn any money from this site - I run no ads, sell no products and participate in no affiliate programs. I do this solely because it's fun; I enjoy writing and sharing what I learn.

All the same, if you found this article helpful and want to show your appreciation, here's my wishlist.

Read More

New Open Source Code

Launched two new pieces of open source code in the last couple of months. PlayerControls PlayerControls is a macOS Cocoa framework that creates a View containing playback controls for media like videos or sounds. It is written in pure Swift 4 and has no dependencies. SearchParser SearchParser is a parser that converts a freeform query into an intermediate object, that can then be converted to query many backends (SQL, ElasticSearch, etc). It includes translators for SQL (using PDO) and Laravel Eloquent ORM. It supports a faceted language search as commonly found on many sites across the web. It is written in modern PHP. Both are licensed under the MIT license. Go check them out on Github.