Nicksxs's Blog

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class InotifyWatchCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'file:watch
        {path : Directory to watch}
        {--recursive : Watch subdirectories recursively}
        {--event=* : Events to watch (create, modify, delete, move). Default: create,modify}
        {--ext=* : Only watch files with these extensions (e.g., --ext=mp4 --ext=mkv)}
        {--output= : Output file path for logging (optional)}
        {--format=text : Output format: text or json}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Watch directory for file write events using inotify';

    /**
     * Event constants mapping.
     */
    protected $eventMap = [
        'create'        => IN_CREATE,
        'modify'        => IN_MODIFY,
        'delete'        => IN_DELETE,
        'move'          => IN_MOVED_TO,
        'close_write'   => IN_CLOSE_WRITE,
        'open'          => IN_OPEN,
        'access'        => IN_ACCESS,
        'attrib'        => IN_ATTRIB,
    ];

    /**
     * @var resource
     */
    protected $inotify;

    /**
     * @var array
     */
    protected $watchDescriptors = [];

    /**
     * @var resource|null
     */
    protected $outputHandle;

    /**
     * @var bool
     */
    protected $running = true;

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $path = trim($this->argument('path'));
        $recursive = $this->option('recursive');
        $events = $this->option('event') ?: ['create', 'modify'];
        $extensions = $this->option('ext');
        $outputFile = $this->option('output');
        $format = $this->option('format');

        // Validate path
        if (!is_dir($path)) {
            $this->error("Directory does not exist: {$path}");
            return 1;
        }

        // Setup output file if specified
        if ($outputFile) {
            $this->outputHandle = fopen($outputFile, 'a');
            if (!$this->outputHandle) {
                $this->error("Cannot open output file: {$outputFile}");
                return 1;
            }
        }

        // Calculate event mask
        $eventMask = 0;
        foreach ($events as $event) {
            if (!isset($this->eventMap[$event])) {
                $this->error("Unknown event: {$event}. Available: " . implode(', ', array_keys($this->eventMap)));
                return 1;
            }
            $eventMask |= $this->eventMap[$event];
        }

        // Always add IN_CLOSE_WRITE for reliable write detection
        $eventMask |= IN_CLOSE_WRITE;

        // Initialize inotify
        $this->inotify = inotify_init();

        if (!$this->inotify) {
            $this->error("Failed to initialize inotify");
            return 1;
        }

        // Set non-blocking mode for graceful shutdown
        stream_set_blocking($this->inotify, false);

        // Setup signal handling for graceful shutdown
        if (function_exists('pcntl_signal')) {
            pcntl_signal(SIGTERM, [$this, 'handleSignal']);
            pcntl_signal(SIGINT, [$this, 'handleSignal']);
        }

        // Add watches
        $this->addWatch($path, $recursive);

        $this->info("Watching: {$path}");
        $this->info("Events: " . implode(', ', $events));
        $this->info("Recursive: " . ($recursive ? 'yes' : 'no'));
        if ($extensions) {
            $this->info("Extensions: " . implode(', ', $extensions));
        }
        $this->info("Press Ctrl+C to stop");
        $this->line('');

        // Main loop
        $checkInterval = 500000; // 500ms in microseconds

        while ($this->running) {
            // Check for signals
            if (function_exists('pcntl_signal_dispatch')) {
                pcntl_signal_dispatch();
            }

            $events = inotify_read($this->inotify);

            if ($events !== false && !empty($events)) {
                foreach ($events as $event) {
                    $this->handleEvent($event, $extensions, $format);
                }
            }

            usleep($checkInterval);
        }

        // Cleanup
        $this->cleanup();

        return 0;
    }

    /**
     * Add inotify watch for a directory.
     */
    protected function addWatch(string $path, bool $recursive): void
    {
        $mask = IN_CREATE | IN_MODIFY | IN_DELETE | IN_MOVED_TO | IN_CLOSE_WRITE | IN_OPEN | IN_ATTRIB;
        $wd = inotify_add_watch($this->inotify, $path, $mask);
        $this->watchDescriptors[$wd] = $path;

        if ($recursive) {
            $items = scandir($path);
            foreach ($items as $item) {
                if ($item === '.' || $item === '..') {
                    continue;
                }
                $fullPath = $path . DIRECTORY_SEPARATOR . $item;
                if (is_dir($fullPath)) {
                    $this->addWatch($fullPath, true);
                }
            }
        }
    }

    /**
     * Handle inotify event.
     */
    protected function handleEvent(array $event, array $extensions, string $format): void
    {
        $wd = $event['wd'];
        $mask = $event['mask'];
        $name = $event['name'] ?? '';
        $cookie = $event['cookie'] ?? 0;

        // Get directory path from watch descriptor
        $dir = $this->watchDescriptors[$wd] ?? 'unknown';

        // Skip if no filename
        if (empty($name)) {
            return;
        }

        // Filter by extension if specified
        if (!empty($extensions)) {
            $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
            if (!in_array($ext, $extensions)) {
                return;
            }
        }

        // Determine event type
        $eventType = $this->getEventType($mask);

        // Build file path
        $filePath = $dir . DIRECTORY_SEPARATOR . $name;

        // Build event data
        $data = [
            'timestamp' => date('Y-m-d H:i:s'),
            'event'     => $eventType,
            'file'      => $name,
            'path'      => $filePath,
            'dir'       => $dir,
            'cookie'    => $cookie,
        ];

        // Output based on format
        if ($format === 'json') {
            $output = json_encode($data, JSON_UNESCAPED_UNICODE) . "\n";
        } else {
            $output = $this->formatTextOutput($data);
        }

        // Write to console
        $this->writeToConsole($eventType, $output);

        // Write to file if handle exists
        if ($this->outputHandle) {
            fwrite($this->outputHandle, $output);
        }
    }

    /**
     * Get human-readable event type from mask.
     */
    protected function getEventType(int $mask): string
    {
        $types = [];

        if ($mask & IN_CREATE) {
            $types[] = 'CREATE';
        }
        if ($mask & IN_MODIFY) {
            $types[] = 'MODIFY';
        }
        if ($mask & IN_DELETE) {
            $types[] = 'DELETE';
        }
        if ($mask & IN_MOVED_TO) {
            $types[] = 'MOVED_TO';
        }
        if ($mask & IN_CLOSE_WRITE) {
            $types[] = 'CLOSE_WRITE';
        }
        if ($mask & IN_OPEN) {
            $types[] = 'OPEN';
        }
        if ($mask & IN_ACCESS) {
            $types[] = 'ACCESS';
        }
        if ($mask & IN_ATTRIB) {
            $types[] = 'ATTRIB';
        }

        return implode('|', $types);
    }

    /**
     * Format text output.
     */
    protected function formatTextOutput(array $data): string
    {
        return sprintf(
            "[%s] %-12s %s (%s)\n",
            $data['timestamp'],
            $data['event'],
            $data['file'],
            $data['dir']
        );
    }

    /**
     * Write output to console with color coding.
     */
    protected function writeToConsole(string $eventType, string $output): void
    {
        if (strpos($eventType, 'CREATE') !== false) {
            $this->info(rtrim($output));
        } elseif (strpos($eventType, 'DELETE') !== false) {
            $this->error(rtrim($output));
        } elseif (strpos($eventType, 'MODIFY') !== false || strpos($eventType, 'CLOSE_WRITE') !== false) {
            $this->comment(rtrim($output));
        } elseif (strpos($eventType, 'MOVED_TO') !== false) {
            $this->warn(rtrim($output));
        } else {
            $this->line(rtrim($output));
        }
    }

    /**
     * Handle signal for graceful shutdown.
     */
    public function handleSignal(int $signal): void
    {
        $this->running = false;
        $this->line('');
        $this->info("Received signal {$signal}, shutting down...");
    }

    /**
     * Cleanup resources.
     */
    protected function cleanup(): void
    {
        if ($this->outputHandle) {
            fclose($this->outputHandle);
        }

        // Remove all watches
        foreach ($this->watchDescriptors as $wd => $path) {
            inotify_rm_watch($this->inotify, $wd);
        }

        if (is_resource($this->inotify)) {
            fclose($this->inotify);
        }

        $this->info("Watch stopped.");
    }
}