PowerShellNotebook

2.6.13

Watch-Directory.ps1

<#
.Synopsis
    File change watcher and handler.
    Author: Roman Kuzmin
 
.Description
    The script watches for changed, created, deleted, and renamed files in the
    given directories. On changes it invokes the specified command with change
    info. It is a dictionary where keys are changed file paths, values are last
    change types.
 
    If the command is omitted then the script outputs change info as text.
 
    The script works until it is forcedly stopped (Ctrl-C).
 
.Parameter Path
        Specifies the watched directory paths.
.Parameter Command
        Specifies the command to process changes.
        It may be a script block or a command name.
.Parameter Filter
        Simple and effective file system filter. Default *.*
.Parameter Include
        Inclusion regular expression pattern applied after Filter.
.Parameter Exclude
        Exclusion regular expression pattern applied after Filter.
.Parameter Recurse
        Tells to watch files in subdirectories as well.
.Parameter TestSeconds
        Time to sleep between checks for change events.
.Parameter WaitSeconds
        Time to wait after the last change before processing.
 
.Link
    https://github.com/nightroman/PowerShelf
#>

param(
    [Parameter(Position = 1, Mandatory = 1)]
    [string[]]$Path,
    [Parameter(Position = 2)]
    $Command,
    [string]$Filter,
    [string]$Include,
    [string]$Exclude,
    [switch]$Recurse,
    [int]$TestSeconds = 5,
    [int]$WaitSeconds = 5
)

trap { $PSCmdlet.ThrowTerminatingError($_) }

$Path = foreach ($_ in $Path) {
    $_ = $PSCmdlet.GetUnresolvedProviderPathFromPSPath($_)
    if (!([System.IO.Directory]::Exists($_))) {
        throw "Missing directory: $_"
    }
    $_
}

Add-Type @'
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Text.RegularExpressions;
 
public class FileSystemWatcherHelper : IDisposable
{
    public string[] Path;
    public string Filter;
    public bool Recurse;
 
    public DateTime LastTime { get { return _lastTime; } }
    public bool HasChanges { get { return _changes.Count > 0; } }
 
    OrderedDictionary _changes = new OrderedDictionary();
    readonly List<FileSystemWatcher> _watchers = new List<FileSystemWatcher>();
    readonly object _lock = new object();
    DateTime _lastTime;
    Regex _include;
    Regex _exclude;
 
    public void Include(string pattern)
    {
        if (!string.IsNullOrEmpty(pattern))
            _include = new Regex(pattern, RegexOptions.IgnoreCase);
    }
    public void Exclude(string pattern)
    {
        if (!string.IsNullOrEmpty(pattern))
            _exclude = new Regex(pattern, RegexOptions.IgnoreCase);
    }
    public void Start()
    {
        foreach (string p in Path)
        {
            FileSystemWatcher watcher = new FileSystemWatcher(p);
            _watchers.Add(watcher);
 
            watcher.IncludeSubdirectories = Recurse;
            watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite;
            if (!string.IsNullOrEmpty(Filter))
                watcher.Filter = Filter;
 
            watcher.Created += OnChanged;
            watcher.Changed += OnChanged;
            watcher.Deleted += OnChanged;
            watcher.Renamed += OnChanged;
            watcher.EnableRaisingEvents = true;
        }
    }
    public object GetChanges()
    {
        lock (_lock)
        {
            object r = _changes;
            _changes = new OrderedDictionary();
            return r;
        }
    }
    public void Dispose()
    {
        foreach (FileSystemWatcher watcher in _watchers)
            watcher.Dispose();
        _watchers.Clear();
        _changes.Clear();
    }
    void OnChanged(object sender, FileSystemEventArgs e)
    {
        if (_include != null && !_include.IsMatch(e.Name))
            return;
 
        if (_exclude != null && _exclude.IsMatch(e.Name))
            return;
 
        lock (_lock)
        {
            _changes[e.FullPath] = e.ChangeType;
            _lastTime = DateTime.Now;
        }
    }
}
'@

$watcher = New-Object FileSystemWatcherHelper
$watcher.Path = $Path
$watcher.Filter = $Filter
$watcher.Recurse = $Recurse
try { $watcher.Include($Include) } catch { throw "Parameter Include: $_" }
try { $watcher.Exclude($Exclude) } catch { throw "Parameter Exclude: $_" }
try {
    $watcher.Start()
    for () {
        Start-Sleep -Seconds $TestSeconds

        if (!$watcher.HasChanges) { continue }
        if (([datetime]::Now - $watcher.LastTime).TotalSeconds -lt $WaitSeconds) { continue }

        $changes = $watcher.GetChanges()
        if ($Command) {
            try {
                & $Command $changes
            }
            catch {
                "$($_.ToString())`r`n$($_.InvocationInfo.PositionMessage)"
            }
        }
        else {
            foreach ($kv in $changes.GetEnumerator()) {
                "$($kv.Value) $($kv.Key)"
            }
        }
    }
}
finally {
    $watcher.Dispose()
}