mirror of https://github.com/dotnet/tye.git
Justin Kotalik
6 years ago
committed by
GitHub
GitHub
23 changed files with 1207 additions and 19 deletions
@ -0,0 +1,107 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System.Collections.Generic; |
||||
|
using System.Linq; |
||||
|
using System.Text; |
||||
|
|
||||
|
namespace Microsoft.Tye |
||||
|
{ |
||||
|
public static class ArgumentEscaper |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Undo the processing which took place to create string[] args in Main, so that the next process will
|
||||
|
/// receive the same string[] args.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// See https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
|
||||
|
/// </remarks>
|
||||
|
/// <param name="args">The arguments to concatenate.</param>
|
||||
|
/// <returns>The escaped arguments, concatenated.</returns>
|
||||
|
public static string EscapeAndConcatenate(IEnumerable<string> args) |
||||
|
=> string.Join(" ", args.Select(EscapeSingleArg)); |
||||
|
|
||||
|
private static string EscapeSingleArg(string arg) |
||||
|
{ |
||||
|
var sb = new StringBuilder(); |
||||
|
|
||||
|
var needsQuotes = ShouldSurroundWithQuotes(arg); |
||||
|
var isQuoted = needsQuotes || IsSurroundedWithQuotes(arg); |
||||
|
|
||||
|
if (needsQuotes) |
||||
|
{ |
||||
|
sb.Append('"'); |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < arg.Length; ++i) |
||||
|
{ |
||||
|
var backslashes = 0; |
||||
|
|
||||
|
// Consume all backslashes
|
||||
|
while (i < arg.Length && arg[i] == '\\') |
||||
|
{ |
||||
|
backslashes++; |
||||
|
i++; |
||||
|
} |
||||
|
|
||||
|
if (i == arg.Length && isQuoted) |
||||
|
{ |
||||
|
// Escape any backslashes at the end of the arg when the argument is also quoted.
|
||||
|
// This ensures the outside quote is interpreted as an argument delimiter
|
||||
|
sb.Append('\\', 2 * backslashes); |
||||
|
} |
||||
|
else if (i == arg.Length) |
||||
|
{ |
||||
|
// At then end of the arg, which isn't quoted,
|
||||
|
// just add the backslashes, no need to escape
|
||||
|
sb.Append('\\', backslashes); |
||||
|
} |
||||
|
else if (arg[i] == '"') |
||||
|
{ |
||||
|
// Escape any preceding backslashes and the quote
|
||||
|
sb.Append('\\', (2 * backslashes) + 1); |
||||
|
sb.Append('"'); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// Output any consumed backslashes and the character
|
||||
|
sb.Append('\\', backslashes); |
||||
|
sb.Append(arg[i]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (needsQuotes) |
||||
|
{ |
||||
|
sb.Append('"'); |
||||
|
} |
||||
|
|
||||
|
return sb.ToString(); |
||||
|
} |
||||
|
|
||||
|
private static bool ShouldSurroundWithQuotes(string argument) |
||||
|
{ |
||||
|
// Don't quote already quoted strings
|
||||
|
if (IsSurroundedWithQuotes(argument)) |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// Only quote if whitespace exists in the string
|
||||
|
return ContainsWhitespace(argument); |
||||
|
} |
||||
|
|
||||
|
private static bool IsSurroundedWithQuotes(string argument) |
||||
|
{ |
||||
|
if (argument.Length <= 1) |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
return argument[0] == '"' && argument[argument.Length - 1] == '"'; |
||||
|
} |
||||
|
|
||||
|
private static bool ContainsWhitespace(string argument) |
||||
|
=> argument.IndexOfAny(new[] { ' ', '\t', '\n' }) >= 0; |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,122 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.ComponentModel; |
||||
|
using System.Diagnostics; |
||||
|
using System.IO; |
||||
|
using System.Runtime.InteropServices; |
||||
|
|
||||
|
namespace Microsoft.Tye |
||||
|
{ |
||||
|
internal static class ProcessExtensions |
||||
|
{ |
||||
|
private static readonly bool _isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows); |
||||
|
private static readonly TimeSpan _defaultTimeout = TimeSpan.FromSeconds(30); |
||||
|
|
||||
|
public static void KillTree(this System.Diagnostics.Process process) => process.KillTree(_defaultTimeout); |
||||
|
|
||||
|
public static void KillTree(this System.Diagnostics.Process process, TimeSpan timeout) |
||||
|
{ |
||||
|
var pid = process.Id; |
||||
|
if (_isWindows) |
||||
|
{ |
||||
|
RunProcessAndWaitForExit( |
||||
|
"taskkill", |
||||
|
$"/T /F /PID {pid}", |
||||
|
timeout, |
||||
|
out var _); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
var children = new HashSet<int>(); |
||||
|
GetAllChildIdsUnix(pid, children, timeout); |
||||
|
foreach (var childId in children) |
||||
|
{ |
||||
|
KillProcessUnix(childId, timeout); |
||||
|
} |
||||
|
KillProcessUnix(pid, timeout); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void GetAllChildIdsUnix(int parentId, ISet<int> children, TimeSpan timeout) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
RunProcessAndWaitForExit( |
||||
|
"pgrep", |
||||
|
$"-P {parentId}", |
||||
|
timeout, |
||||
|
out var stdout); |
||||
|
|
||||
|
if (!string.IsNullOrEmpty(stdout)) |
||||
|
{ |
||||
|
using (var reader = new StringReader(stdout)) |
||||
|
{ |
||||
|
while (true) |
||||
|
{ |
||||
|
var text = reader.ReadLine(); |
||||
|
if (text == null) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (int.TryParse(text, out var id)) |
||||
|
{ |
||||
|
children.Add(id); |
||||
|
// Recursively get the children
|
||||
|
GetAllChildIdsUnix(id, children, timeout); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) |
||||
|
{ |
||||
|
// This probably means that pgrep isn't installed. Nothing to be done?
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void KillProcessUnix(int processId, TimeSpan timeout) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
RunProcessAndWaitForExit( |
||||
|
"kill", |
||||
|
$"-TERM {processId}", |
||||
|
timeout, |
||||
|
out var stdout); |
||||
|
} |
||||
|
catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) |
||||
|
{ |
||||
|
// This probably means that the process is already dead
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void RunProcessAndWaitForExit(string fileName, string arguments, TimeSpan timeout, out string? stdout) |
||||
|
{ |
||||
|
var startInfo = new ProcessStartInfo |
||||
|
{ |
||||
|
FileName = fileName, |
||||
|
Arguments = arguments, |
||||
|
RedirectStandardOutput = true, |
||||
|
RedirectStandardError = true, |
||||
|
UseShellExecute = false, |
||||
|
}; |
||||
|
|
||||
|
var process = System.Diagnostics.Process.Start(startInfo); |
||||
|
|
||||
|
stdout = null; |
||||
|
if (process.WaitForExit((int)timeout.TotalMilliseconds)) |
||||
|
{ |
||||
|
stdout = process.StandardOutput.ReadToEnd(); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
process.Kill(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,24 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using System.IO; |
||||
|
|
||||
|
namespace Microsoft.Tye |
||||
|
{ |
||||
|
public class ProcessSpec |
||||
|
{ |
||||
|
public string? Executable { get; set; } |
||||
|
public string? WorkingDirectory { get; set; } |
||||
|
public IDictionary<string, string> EnvironmentVariables { get; set; } = new Dictionary<string, string>(); |
||||
|
public string? Arguments { get; set; } |
||||
|
public Action<string>? OutputData { get; set; } |
||||
|
public Action<string>? ErrorData { get; set; } |
||||
|
public Action<int>? OnStart { get; set; } |
||||
|
public string? ShortDisplayName() |
||||
|
=> Path.GetFileNameWithoutExtension(Executable); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,102 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System.Globalization; |
||||
|
using System.Threading; |
||||
|
using System.Threading.Tasks; |
||||
|
using Microsoft.DotNet.Watcher.Internal; |
||||
|
using Microsoft.Extensions.Logging; |
||||
|
using Microsoft.Tye; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher |
||||
|
{ |
||||
|
public class DotNetWatcher |
||||
|
{ |
||||
|
private readonly ILogger _logger; |
||||
|
|
||||
|
public DotNetWatcher(ILogger logger) |
||||
|
{ |
||||
|
_logger = logger; |
||||
|
} |
||||
|
|
||||
|
public async Task WatchAsync(ProcessSpec processSpec, IFileSetFactory fileSetFactory, string replica, |
||||
|
CancellationToken cancellationToken) |
||||
|
{ |
||||
|
var cancelledTaskSource = new TaskCompletionSource<object>(); |
||||
|
cancellationToken.Register(state => ((TaskCompletionSource<object>)state!).TrySetResult(null!), |
||||
|
cancelledTaskSource); |
||||
|
|
||||
|
var iteration = 1; |
||||
|
|
||||
|
while (true) |
||||
|
{ |
||||
|
processSpec.EnvironmentVariables["DOTNET_WATCH_ITERATION"] = iteration.ToString(CultureInfo.InvariantCulture); |
||||
|
iteration++; |
||||
|
|
||||
|
var fileSet = await fileSetFactory.CreateAsync(cancellationToken); |
||||
|
|
||||
|
if (fileSet == null) |
||||
|
{ |
||||
|
_logger.LogError("watch: Failed to find a list of files to watch"); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (cancellationToken.IsCancellationRequested) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
using (var currentRunCancellationSource = new CancellationTokenSource()) |
||||
|
using (var combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource( |
||||
|
cancellationToken, |
||||
|
currentRunCancellationSource.Token)) |
||||
|
using (var fileSetWatcher = new FileSetWatcher(fileSet, _logger)) |
||||
|
{ |
||||
|
var fileSetTask = fileSetWatcher.GetChangedFileAsync(combinedCancellationSource.Token); |
||||
|
var processTask = ProcessUtil.RunAsync(processSpec, combinedCancellationSource.Token, throwOnError: false); |
||||
|
|
||||
|
var args = processSpec.Arguments!; |
||||
|
_logger.LogDebug($"Running {processSpec.ShortDisplayName()} with the following arguments: {args}"); |
||||
|
|
||||
|
_logger.LogInformation("watch: {Replica} Started", replica); |
||||
|
|
||||
|
var finishedTask = await Task.WhenAny(processTask, fileSetTask, cancelledTaskSource.Task); |
||||
|
|
||||
|
// Regardless of the which task finished first, make sure everything is cancelled
|
||||
|
// and wait for dotnet to exit. We don't want orphan processes
|
||||
|
currentRunCancellationSource.Cancel(); |
||||
|
|
||||
|
await Task.WhenAll(processTask, fileSetTask); |
||||
|
|
||||
|
if (processTask.Result.ExitCode != 0 && finishedTask == processTask && !cancellationToken.IsCancellationRequested) |
||||
|
{ |
||||
|
// Only show this error message if the process exited non-zero due to a normal process exit.
|
||||
|
// Don't show this if dotnet-watch killed the inner process due to file change or CTRL+C by the user
|
||||
|
_logger.LogError($"watch: Exited with error code {processTask.Result}"); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
_logger.LogInformation("watch: {Replica} Exited", replica); |
||||
|
} |
||||
|
|
||||
|
if (finishedTask == cancelledTaskSource.Task || cancellationToken.IsCancellationRequested) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (finishedTask == processTask) |
||||
|
{ |
||||
|
// Now wait for a file to change before restarting process
|
||||
|
await fileSetWatcher.GetChangedFileAsync(cancellationToken, () => _logger.LogWarning("Waiting for a file to change before restarting dotnet...")); |
||||
|
} |
||||
|
|
||||
|
if (!string.IsNullOrEmpty(fileSetTask.Result)) |
||||
|
{ |
||||
|
_logger.LogInformation($"watch: File changed: {fileSetTask.Result}"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,13 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System.Collections.Generic; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher |
||||
|
{ |
||||
|
public interface IFileSet : IEnumerable<string> |
||||
|
{ |
||||
|
bool Contains(string filePath); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,14 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System.Threading; |
||||
|
using System.Threading.Tasks; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher |
||||
|
{ |
||||
|
public interface IFileSetFactory |
||||
|
{ |
||||
|
Task<IFileSet> CreateAsync(CancellationToken cancellationToken); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,27 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections; |
||||
|
using System.Collections.Generic; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
public class FileSet : IFileSet |
||||
|
{ |
||||
|
private readonly HashSet<string> _files; |
||||
|
|
||||
|
public FileSet(IEnumerable<string> files) |
||||
|
{ |
||||
|
_files = new HashSet<string>(files, StringComparer.OrdinalIgnoreCase); |
||||
|
} |
||||
|
|
||||
|
public bool Contains(string filePath) => _files.Contains(filePath); |
||||
|
|
||||
|
public int Count => _files.Count; |
||||
|
|
||||
|
public IEnumerator<string> GetEnumerator() => _files.GetEnumerator(); |
||||
|
IEnumerator IEnumerable.GetEnumerator() => _files.GetEnumerator(); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,61 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.IO; |
||||
|
using System.Threading; |
||||
|
using System.Threading.Tasks; |
||||
|
using Microsoft.Extensions.Logging; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
public class FileSetWatcher : IDisposable |
||||
|
{ |
||||
|
private readonly FileWatcher _fileWatcher; |
||||
|
private readonly IFileSet _fileSet; |
||||
|
|
||||
|
public FileSetWatcher(IFileSet fileSet, ILogger logger) |
||||
|
{ |
||||
|
_fileSet = fileSet; |
||||
|
_fileWatcher = new FileWatcher(logger); |
||||
|
} |
||||
|
|
||||
|
public async Task<string> GetChangedFileAsync(CancellationToken cancellationToken, Action startedWatching) |
||||
|
{ |
||||
|
foreach (var file in _fileSet) |
||||
|
{ |
||||
|
_fileWatcher.WatchDirectory(Path.GetDirectoryName(file)!); |
||||
|
} |
||||
|
|
||||
|
var tcs = new TaskCompletionSource<string>(); |
||||
|
cancellationToken.Register(() => tcs.TrySetResult(null!)); |
||||
|
|
||||
|
Action<string> callback = path => |
||||
|
{ |
||||
|
if (_fileSet.Contains(path)) |
||||
|
{ |
||||
|
tcs.TrySetResult(path); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
_fileWatcher.OnFileChange += callback; |
||||
|
startedWatching(); |
||||
|
var changedFile = await tcs.Task; |
||||
|
_fileWatcher.OnFileChange -= callback; |
||||
|
|
||||
|
return changedFile; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
public Task<string> GetChangedFileAsync(CancellationToken cancellationToken) |
||||
|
{ |
||||
|
return GetChangedFileAsync(cancellationToken, () => { }); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
_fileWatcher.Dispose(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,140 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.IO; |
||||
|
using System.Linq; |
||||
|
using Microsoft.Extensions.Logging; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
public class FileWatcher |
||||
|
{ |
||||
|
private bool _disposed; |
||||
|
|
||||
|
private readonly IDictionary<string, IFileSystemWatcher> _watchers; |
||||
|
private readonly ILogger _logger; |
||||
|
|
||||
|
public FileWatcher(ILogger logger) |
||||
|
{ |
||||
|
_logger = logger ?? throw new ArgumentNullException(nameof(logger)); |
||||
|
_watchers = new Dictionary<string, IFileSystemWatcher>(); |
||||
|
} |
||||
|
|
||||
|
public event Action<string>? OnFileChange; |
||||
|
|
||||
|
public void WatchDirectory(string directory) |
||||
|
{ |
||||
|
EnsureNotDisposed(); |
||||
|
AddDirectoryWatcher(directory); |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
if (_disposed) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
_disposed = true; |
||||
|
|
||||
|
foreach (var watcher in _watchers) |
||||
|
{ |
||||
|
watcher.Value.OnFileChange -= WatcherChangedHandler!; |
||||
|
watcher.Value.OnError -= WatcherErrorHandler!; |
||||
|
watcher.Value.Dispose(); |
||||
|
} |
||||
|
|
||||
|
_watchers.Clear(); |
||||
|
} |
||||
|
|
||||
|
private void AddDirectoryWatcher(string directory) |
||||
|
{ |
||||
|
directory = EnsureTrailingSlash(directory); |
||||
|
|
||||
|
var alreadyWatched = _watchers |
||||
|
.Where(d => directory.StartsWith(d.Key)) |
||||
|
.Any(); |
||||
|
|
||||
|
if (alreadyWatched) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var redundantWatchers = _watchers |
||||
|
.Where(d => d.Key.StartsWith(directory)) |
||||
|
.Select(d => d.Key) |
||||
|
.ToList(); |
||||
|
|
||||
|
if (redundantWatchers.Any()) |
||||
|
{ |
||||
|
foreach (var watcher in redundantWatchers) |
||||
|
{ |
||||
|
DisposeWatcher(watcher); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var newWatcher = FileWatcherFactory.CreateWatcher(directory); |
||||
|
newWatcher.OnFileChange += WatcherChangedHandler!; |
||||
|
newWatcher.OnError += WatcherErrorHandler!; |
||||
|
newWatcher.EnableRaisingEvents = true; |
||||
|
|
||||
|
_watchers.Add(directory, newWatcher); |
||||
|
} |
||||
|
|
||||
|
private void WatcherErrorHandler(object sender, Exception error) |
||||
|
{ |
||||
|
if (sender is IFileSystemWatcher watcher) |
||||
|
{ |
||||
|
_logger.LogWarning($"The file watcher observing '{watcher.BasePath}' encountered an error: {error.Message}"); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void WatcherChangedHandler(object sender, string changedPath) |
||||
|
{ |
||||
|
NotifyChange(changedPath); |
||||
|
} |
||||
|
|
||||
|
private void NotifyChange(string path) |
||||
|
{ |
||||
|
if (OnFileChange != null) |
||||
|
{ |
||||
|
OnFileChange(path); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void DisposeWatcher(string directory) |
||||
|
{ |
||||
|
var watcher = _watchers[directory]; |
||||
|
_watchers.Remove(directory); |
||||
|
|
||||
|
watcher.EnableRaisingEvents = false; |
||||
|
|
||||
|
watcher.OnFileChange -= WatcherChangedHandler!; |
||||
|
watcher.OnError -= WatcherErrorHandler!; |
||||
|
|
||||
|
watcher.Dispose(); |
||||
|
} |
||||
|
|
||||
|
private void EnsureNotDisposed() |
||||
|
{ |
||||
|
if (_disposed) |
||||
|
{ |
||||
|
throw new ObjectDisposedException(nameof(FileWatcher)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static string EnsureTrailingSlash(string path) |
||||
|
{ |
||||
|
if (!string.IsNullOrEmpty(path) && |
||||
|
path[path.Length - 1] != Path.DirectorySeparatorChar) |
||||
|
{ |
||||
|
return path + Path.DirectorySeparatorChar; |
||||
|
} |
||||
|
|
||||
|
return path; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,154 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.ComponentModel; |
||||
|
using System.IO; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
internal class DotnetFileWatcher : IFileSystemWatcher |
||||
|
{ |
||||
|
private volatile bool _disposed; |
||||
|
|
||||
|
private readonly Func<string, FileSystemWatcher> _watcherFactory; |
||||
|
|
||||
|
private FileSystemWatcher? _fileSystemWatcher; |
||||
|
|
||||
|
private readonly object _createLock = new object(); |
||||
|
|
||||
|
public DotnetFileWatcher(string watchedDirectory) |
||||
|
: this(watchedDirectory, DefaultWatcherFactory) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
internal DotnetFileWatcher(string watchedDirectory, Func<string, FileSystemWatcher> fileSystemWatcherFactory) |
||||
|
{ |
||||
|
BasePath = watchedDirectory; |
||||
|
_watcherFactory = fileSystemWatcherFactory; |
||||
|
CreateFileSystemWatcher(); |
||||
|
} |
||||
|
|
||||
|
public event EventHandler<string>? OnFileChange; |
||||
|
|
||||
|
public event EventHandler<Exception>? OnError; |
||||
|
|
||||
|
public string BasePath { get; } |
||||
|
|
||||
|
private static FileSystemWatcher DefaultWatcherFactory(string watchedDirectory) |
||||
|
{ |
||||
|
return new FileSystemWatcher(watchedDirectory); |
||||
|
} |
||||
|
|
||||
|
private void WatcherErrorHandler(object sender, ErrorEventArgs e) |
||||
|
{ |
||||
|
if (_disposed) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var exception = e.GetException(); |
||||
|
|
||||
|
// Win32Exception may be triggered when setting EnableRaisingEvents on a file system type
|
||||
|
// that is not supported, such as a network share. Don't attempt to recreate the watcher
|
||||
|
// in this case as it will cause a StackOverflowException
|
||||
|
if (!(exception is Win32Exception)) |
||||
|
{ |
||||
|
// Recreate the watcher if it is a recoverable error.
|
||||
|
CreateFileSystemWatcher(); |
||||
|
} |
||||
|
|
||||
|
OnError?.Invoke(this, exception); |
||||
|
} |
||||
|
|
||||
|
private void WatcherRenameHandler(object sender, RenamedEventArgs e) |
||||
|
{ |
||||
|
if (_disposed) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
NotifyChange(e.OldFullPath); |
||||
|
NotifyChange(e.FullPath); |
||||
|
|
||||
|
if (Directory.Exists(e.FullPath)) |
||||
|
{ |
||||
|
foreach (var newLocation in Directory.EnumerateFileSystemEntries(e.FullPath, "*", SearchOption.AllDirectories)) |
||||
|
{ |
||||
|
// Calculated previous path of this moved item.
|
||||
|
var oldLocation = Path.Combine(e.OldFullPath, newLocation.Substring(e.FullPath.Length + 1)); |
||||
|
NotifyChange(oldLocation); |
||||
|
NotifyChange(newLocation); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void WatcherChangeHandler(object sender, FileSystemEventArgs e) |
||||
|
{ |
||||
|
if (_disposed) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
NotifyChange(e.FullPath); |
||||
|
} |
||||
|
|
||||
|
private void NotifyChange(string fullPath) |
||||
|
{ |
||||
|
// Only report file changes
|
||||
|
OnFileChange?.Invoke(this, fullPath); |
||||
|
} |
||||
|
|
||||
|
private void CreateFileSystemWatcher() |
||||
|
{ |
||||
|
lock (_createLock) |
||||
|
{ |
||||
|
bool enableEvents = false; |
||||
|
|
||||
|
if (_fileSystemWatcher != null) |
||||
|
{ |
||||
|
enableEvents = _fileSystemWatcher.EnableRaisingEvents; |
||||
|
|
||||
|
DisposeInnerWatcher(); |
||||
|
} |
||||
|
|
||||
|
_fileSystemWatcher = _watcherFactory(BasePath); |
||||
|
_fileSystemWatcher.IncludeSubdirectories = true; |
||||
|
|
||||
|
_fileSystemWatcher.Created += WatcherChangeHandler; |
||||
|
_fileSystemWatcher.Deleted += WatcherChangeHandler; |
||||
|
_fileSystemWatcher.Changed += WatcherChangeHandler; |
||||
|
_fileSystemWatcher.Renamed += WatcherRenameHandler; |
||||
|
_fileSystemWatcher.Error += WatcherErrorHandler; |
||||
|
|
||||
|
_fileSystemWatcher.EnableRaisingEvents = enableEvents; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void DisposeInnerWatcher() |
||||
|
{ |
||||
|
_fileSystemWatcher!.EnableRaisingEvents = false; |
||||
|
|
||||
|
_fileSystemWatcher.Created -= WatcherChangeHandler; |
||||
|
_fileSystemWatcher.Deleted -= WatcherChangeHandler; |
||||
|
_fileSystemWatcher.Changed -= WatcherChangeHandler; |
||||
|
_fileSystemWatcher.Renamed -= WatcherRenameHandler; |
||||
|
_fileSystemWatcher.Error -= WatcherErrorHandler; |
||||
|
|
||||
|
_fileSystemWatcher.Dispose(); |
||||
|
} |
||||
|
|
||||
|
public bool EnableRaisingEvents |
||||
|
{ |
||||
|
get => _fileSystemWatcher!.EnableRaisingEvents; |
||||
|
set => _fileSystemWatcher!.EnableRaisingEvents = value; |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
_disposed = true; |
||||
|
DisposeInnerWatcher(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,14 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
public static class FileWatcherFactory |
||||
|
{ |
||||
|
public static IFileSystemWatcher CreateWatcher(string watchedDirectory) |
||||
|
=> new DotnetFileWatcher(watchedDirectory); |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,19 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
public interface IFileSystemWatcher : IDisposable |
||||
|
{ |
||||
|
event EventHandler<string> OnFileChange; |
||||
|
|
||||
|
event EventHandler<Exception> OnError; |
||||
|
|
||||
|
string BasePath { get; } |
||||
|
|
||||
|
bool EnableRaisingEvents { get; set; } |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,173 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using System.IO; |
||||
|
using System.Linq; |
||||
|
using System.Text; |
||||
|
using System.Threading; |
||||
|
using System.Threading.Tasks; |
||||
|
using Microsoft.Extensions.Logging; |
||||
|
using Microsoft.Tye; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
public class MsBuildFileSetFactory : IFileSetFactory |
||||
|
{ |
||||
|
private const string TargetName = "GenerateWatchList"; |
||||
|
private const string WatchTargetsFileName = "DotNetWatch.targets"; |
||||
|
private readonly ILogger _logger; |
||||
|
private readonly string _projectFile; |
||||
|
private readonly bool _waitOnError; |
||||
|
private readonly IReadOnlyList<string> _buildFlags; |
||||
|
|
||||
|
public MsBuildFileSetFactory(ILogger reporter, |
||||
|
string projectFile, |
||||
|
bool waitOnError, |
||||
|
bool trace) |
||||
|
: this(reporter, projectFile, trace) |
||||
|
{ |
||||
|
_waitOnError = waitOnError; |
||||
|
} |
||||
|
|
||||
|
internal MsBuildFileSetFactory(ILogger logger, |
||||
|
string projectFile, |
||||
|
bool trace) |
||||
|
{ |
||||
|
_logger = logger; |
||||
|
_projectFile = projectFile; |
||||
|
_buildFlags = InitializeArgs(FindTargetsFile(), trace); |
||||
|
} |
||||
|
|
||||
|
public async Task<IFileSet> CreateAsync(CancellationToken cancellationToken) |
||||
|
{ |
||||
|
var watchList = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); |
||||
|
try |
||||
|
{ |
||||
|
var projectDir = Path.GetDirectoryName(_projectFile); |
||||
|
|
||||
|
while (true) |
||||
|
{ |
||||
|
cancellationToken.ThrowIfCancellationRequested(); |
||||
|
|
||||
|
var args = new StringBuilder(); |
||||
|
args.Append($"msbuild {_projectFile} /p:_DotNetWatchListFile={watchList}"); |
||||
|
foreach (var flag in _buildFlags) |
||||
|
{ |
||||
|
args.Append(" "); |
||||
|
args.Append(flag); |
||||
|
} |
||||
|
|
||||
|
var processSpec = new ProcessSpec |
||||
|
{ |
||||
|
Executable = "dotnet", |
||||
|
WorkingDirectory = projectDir!, |
||||
|
Arguments = args.ToString() |
||||
|
}; |
||||
|
|
||||
|
_logger.LogDebug($"Running MSBuild target '{TargetName}' on '{_projectFile}'"); |
||||
|
|
||||
|
var processResult = await ProcessUtil.RunAsync(processSpec, cancellationToken); |
||||
|
|
||||
|
if (processResult.ExitCode == 0 && File.Exists(watchList)) |
||||
|
{ |
||||
|
var fileset = new FileSet( |
||||
|
File.ReadAllLines(watchList) |
||||
|
.Select(l => l?.Trim()) |
||||
|
.Where(l => !string.IsNullOrEmpty(l))!); |
||||
|
|
||||
|
_logger.LogDebug($"Watching {fileset.Count} file(s) for changes"); |
||||
|
#if DEBUG
|
||||
|
|
||||
|
foreach (var file in fileset) |
||||
|
{ |
||||
|
_logger.LogDebug($" -> {file}"); |
||||
|
} |
||||
|
|
||||
|
Debug.Assert(fileset.All(Path.IsPathRooted), "All files should be rooted paths"); |
||||
|
#endif
|
||||
|
|
||||
|
return fileset; |
||||
|
} |
||||
|
|
||||
|
_logger.LogError($"Error(s) finding watch items project file '{Path.GetFileName(_projectFile)}'"); |
||||
|
|
||||
|
_logger.LogInformation($"MSBuild output from target '{TargetName}':"); |
||||
|
_logger.LogInformation(string.Empty); |
||||
|
|
||||
|
_logger.LogInformation(string.Empty); |
||||
|
|
||||
|
if (!_waitOnError) |
||||
|
{ |
||||
|
return null!; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
_logger.LogWarning("Fix the error to continue or press Ctrl+C to exit."); |
||||
|
|
||||
|
var fileSet = new FileSet(new[] { _projectFile }); |
||||
|
|
||||
|
using (var watcher = new FileSetWatcher(fileSet, _logger)) |
||||
|
{ |
||||
|
await watcher.GetChangedFileAsync(cancellationToken); |
||||
|
|
||||
|
_logger.LogInformation($"File changed: {_projectFile}"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
if (File.Exists(watchList)) |
||||
|
{ |
||||
|
File.Delete(watchList); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private IReadOnlyList<string> InitializeArgs(string watchTargetsFile, bool trace) |
||||
|
{ |
||||
|
var args = new List<string> |
||||
|
{ |
||||
|
"/nologo", |
||||
|
"/v:n", |
||||
|
"/t:" + TargetName, |
||||
|
"/p:DotNetWatchBuild=true", // extensibility point for users
|
||||
|
"/p:DesignTimeBuild=true", // don't do expensive things
|
||||
|
"/p:CustomAfterMicrosoftCommonTargets=" + watchTargetsFile, |
||||
|
"/p:CustomAfterMicrosoftCommonCrossTargetingTargets=" + watchTargetsFile, |
||||
|
}; |
||||
|
|
||||
|
if (trace) |
||||
|
{ |
||||
|
// enables capturing markers to know which projects have been visited
|
||||
|
args.Add("/p:_DotNetWatchTraceOutput=true"); |
||||
|
} |
||||
|
|
||||
|
return args; |
||||
|
} |
||||
|
|
||||
|
private string FindTargetsFile() |
||||
|
{ |
||||
|
var assemblyDir = Path.GetDirectoryName(typeof(MsBuildFileSetFactory).Assembly.Location); |
||||
|
string[] searchPaths = new[] |
||||
|
{ |
||||
|
Path.Combine(AppContext.BaseDirectory, "Watch", "assets"), |
||||
|
Path.Combine(assemblyDir!, "Watch", "assets"), |
||||
|
AppContext.BaseDirectory, |
||||
|
assemblyDir, |
||||
|
}!; |
||||
|
|
||||
|
var targetPath = searchPaths.Select(p => Path.Combine(p, WatchTargetsFileName)).FirstOrDefault(File.Exists); |
||||
|
if (targetPath == null) |
||||
|
{ |
||||
|
_logger.LogError("Fatal error: could not find DotNetWatch.targets"); |
||||
|
return null!; |
||||
|
} |
||||
|
return targetPath; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,54 @@ |
|||||
|
// Licensed to the .NET Foundation under one or more agreements.
|
||||
|
// The .NET Foundation licenses this file to you under the MIT license.
|
||||
|
// See the LICENSE file in the project root for more information.
|
||||
|
|
||||
|
using System; |
||||
|
using System.IO; |
||||
|
using System.Linq; |
||||
|
|
||||
|
namespace Microsoft.DotNet.Watcher.Internal |
||||
|
{ |
||||
|
internal class MsBuildProjectFinder |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Finds a compatible MSBuild project.
|
||||
|
/// <param name="searchBase">The base directory to search</param>
|
||||
|
/// <param name="project">The filename of the project. Can be null.</param>
|
||||
|
/// </summary>
|
||||
|
public static string FindMsBuildProject(string searchBase, string project) |
||||
|
{ |
||||
|
var projectPath = project ?? searchBase; |
||||
|
|
||||
|
if (!Path.IsPathRooted(projectPath)) |
||||
|
{ |
||||
|
projectPath = Path.Combine(searchBase, projectPath); |
||||
|
} |
||||
|
|
||||
|
if (Directory.Exists(projectPath)) |
||||
|
{ |
||||
|
var projects = Directory.EnumerateFileSystemEntries(projectPath, "*.*proj", SearchOption.TopDirectoryOnly) |
||||
|
.Where(f => !".xproj".Equals(Path.GetExtension(f), StringComparison.OrdinalIgnoreCase)) |
||||
|
.ToList(); |
||||
|
|
||||
|
if (projects.Count > 1) |
||||
|
{ |
||||
|
throw new FileNotFoundException($"The project file '{projectPath}' does not exist."); |
||||
|
} |
||||
|
|
||||
|
if (projects.Count == 0) |
||||
|
{ |
||||
|
throw new FileNotFoundException($"Could not find a MSBuild project file in '{projectPath}'. Specify which project to use with the --project option."); |
||||
|
} |
||||
|
|
||||
|
return projects[0]; |
||||
|
} |
||||
|
|
||||
|
if (!File.Exists(projectPath)) |
||||
|
{ |
||||
|
throw new FileNotFoundException($"The project file '{projectPath}' does not exist."); |
||||
|
} |
||||
|
|
||||
|
return projectPath; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,66 @@ |
|||||
|
<Project xmlns = "http://schemas.microsoft.com/developer/msbuild/2003" > |
||||
|
<!-- |
||||
|
========================================================================= |
||||
|
GenerateWatchList |
||||
|
Main target called by dotnet-watch. It gathers MSBuild items and writes |
||||
|
them to a file. |
||||
|
========================================================================= |
||||
|
--> |
||||
|
<Target Name="GenerateWatchList" |
||||
|
DependsOnTargets="_CollectWatchItems"> |
||||
|
<WriteLinesToFile Overwrite="true" |
||||
|
File="$(_DotNetWatchListFile)" |
||||
|
Lines="@(Watch -> '%(FullPath)')" /> |
||||
|
</Target> |
||||
|
|
||||
|
<!-- |
||||
|
========================================================================= |
||||
|
_CollectWatchItems |
||||
|
Gathers all files to be watched. |
||||
|
Returns: @(Watch) |
||||
|
========================================================================= |
||||
|
--> |
||||
|
<PropertyGroup> |
||||
|
<_CollectWatchItemsDependsOn Condition=" '$(TargetFrameworks)' != '' AND '$(TargetFramework)' == '' "> |
||||
|
_CollectWatchItemsPerFramework; |
||||
|
</_CollectWatchItemsDependsOn> |
||||
|
<_CollectWatchItemsDependsOn Condition=" '$(TargetFramework)' != '' "> |
||||
|
_CoreCollectWatchItems; |
||||
|
</_CollectWatchItemsDependsOn> |
||||
|
</PropertyGroup> |
||||
|
|
||||
|
<Target Name="_CollectWatchItems" DependsOnTargets="$(_CollectWatchItemsDependsOn)" Returns="@(Watch)" /> |
||||
|
|
||||
|
<Target Name="_CollectWatchItemsPerFramework"> |
||||
|
<ItemGroup> |
||||
|
<_TargetFramework Include="$(TargetFrameworks)" /> |
||||
|
</ItemGroup> |
||||
|
|
||||
|
<MSBuild Projects="$(MSBuildProjectFullPath)" |
||||
|
Targets="_CoreCollectWatchItems" |
||||
|
Properties="TargetFramework=%(_TargetFramework.Identity)"> |
||||
|
<Output TaskParameter="TargetOutputs" ItemName="Watch" /> |
||||
|
</MSBuild> |
||||
|
</Target> |
||||
|
|
||||
|
<Target Name="_CoreCollectWatchItems" Returns="@(Watch)"> |
||||
|
<!-- message used to debug --> |
||||
|
<Message Importance="High" Text="Collecting watch items from '$(MSBuildProjectName)'" Condition="'$(_DotNetWatchTraceOutput)'=='true'" /> |
||||
|
|
||||
|
<Error Text="TargetFramework should be set" Condition="'$(TargetFramework)' == '' "/> |
||||
|
|
||||
|
<ItemGroup> |
||||
|
<Watch Include="%(Compile.FullPath)" Condition="'%(Compile.Watch)' != 'false'" /> |
||||
|
<Watch Include="%(EmbeddedResource.FullPath)" Condition="'%(EmbeddedResource.Watch)' != 'false'"/> |
||||
|
<Watch Include="$(MSBuildProjectFullPath)" /> |
||||
|
<_WatchProjects Include="%(ProjectReference.Identity)" Condition="'%(ProjectReference.Watch)' != 'false'" /> |
||||
|
</ItemGroup> |
||||
|
|
||||
|
<MSBuild Projects="@(_WatchProjects)" |
||||
|
Targets="_CollectWatchItems" |
||||
|
BuildInParallel="true"> |
||||
|
<Output TaskParameter="TargetOutputs" ItemName="Watch" /> |
||||
|
</MSBuild> |
||||
|
</Target> |
||||
|
|
||||
|
</Project> |
||||
Loading…
Reference in new issue