public LocalGameSaveManager(IFileSystemWatcher fileWatcher)
{
_fileWatcher = fileWatcher;
_savesDirectoryPath = fileWatcher.PathToWatch;
InitializeFileSystemWatcher();
}
private void Bootstrap()
{
_jobModelRegistry = new ConcurrentDictionary<string, JobModel>();
_compositionContainer = new CatalogConfigurator()
.AddAssembly(Assembly.GetExecutingAssembly())
.AddNestedDirectory(Config.JobsFolderName)
.BuildContainer();
_compositionContainer.ComposeParts(this);
InitTasksRegistry();
_appContainerBuilder = new ContainerBuilder();
_appContainerBuilder.RegisterModule<WorkerModule>();
_appContainerBuilder.RegisterModule<HostingModule>();
_appContainer = _appContainerBuilder.Build();
//TODO: make onchanged to an event
_fileSystemWatcher = new JobsWatcher { OnChanged = OnChanged };
_fileSystemWatcher.Watch(TasksFolderPath);
_logger = _appContainer.Resolve<ILogger>();
_logger.Info("[START] PanteonEngine");
Task.Run(() => MountApi());
}
public FileSystemRefreshableWatcher(IFileSystemWatcher watcher) : base(watcher)
{
_refreshTokenSource = new CancellationTokenSource();
_waitingThreadsEvents = new ConcurrentDictionary<Thread, ManualResetEventSlim>();
IsRefreshing = false;
_refreshLock = new object();
}
private static void RaiseDeleted(IFileSystemWatcher fileWatcher, IEnumerable<string> fullPaths)
{
foreach (var fullPath in fullPaths)
{
RaiseDeleted(fileWatcher, fullPath);
}
}
public DnxProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions<OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
IEventEmitter emitter,
DnxContext context)
{
_workspace = workspace;
_env = env;
_logger = loggerFactory.CreateLogger<DnxProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_options = optionsAccessor.Options;
_dnxPaths = new DnxPaths(env, _options, loggerFactory);
_designTimeHostManager = new DesignTimeHostManager(loggerFactory, _dnxPaths);
_packagesRestoreTool = new PackagesRestoreTool(_options, loggerFactory, emitter, context, _dnxPaths);
_context = context;
_watcher = watcher;
_emitter = emitter;
_directoryEnumerator = new DirectoryEnumerator(loggerFactory);
lifetime.ApplicationStopping.Register(OnShutdown);
}
public WaitForFileToChange(string file)
{
_watcher = FileWatcherFactory.CreateWatcher(Path.GetDirectoryName(file), usePollingWatcher: true);
_expectedFile = file;
_watcher.OnFileChange += WatcherEvent;
_watcher.EnableRaisingEvents = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="SafeEventFileSystemWatcher"/> class.
/// </summary>
/// <param name="watcher">The watcher.</param>
public SafeEventFileSystemWatcher(IFileSystemWatcher watcher)
{
if (watcher == null)
throw new ArgumentNullException("watcher");
this.InitLog();
this.watcher = watcher;
this.Initialize();
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginDirectory"/> class.
/// </summary>
/// <param name="watcher">The <see cref="IFileSystemWatcher"/> that rases events about file changes.</param>
/// <exception cref="System.ArgumentNullException">watcher</exception>
public PluginDirectory(IFileSystemWatcher watcher)
{
if (watcher == null)
throw new ArgumentNullException("watcher");
this.InitLog();
WatcherConnect(watcher, false);
}
private Solution(string solutionPath, Func<string, string> fileReader, IFileSystemWatcher fileSystemWatcher, IScheduler scheduler)
{
_solutionPath = solutionPath;
_fileReader = fileReader;
_fileSystemWatcher = fileSystemWatcher;
_projects = new Dictionary<string, ProjectFile>(StringComparer.CurrentCultureIgnoreCase);
ReloadSolution();
SetupFileSystemWatcherEvents(scheduler);
_fileSystemWatcher.Directory = Path.GetDirectoryName(_solutionPath);
}
public ConfigurationFileReader(
IConfigure configure,
IFileSystemWatcher fileSystemWatcher,
IYamlParser yamlParser,
IHarnessManager harnessManager)
{
_fileSystemWatcher = fileSystemWatcher;
_yamlParser = yamlParser;
_harnessManager = harnessManager;
fileSystemWatcher.SubscribeToChanges(FileChanged);
}
public HarnessManager(
IScriptEngine scriptEngine,
IPageGenerator pageGenerator,
IFileSystem fileSystem,
IFileSystemWatcher fileSystemWatcher)
{
_scriptEngine = scriptEngine;
_pageGenerator = pageGenerator;
_fileSystem = fileSystem;
_fileSystemWatcher = fileSystemWatcher;
_fileSystemWatcher.SubscribeToChanges(FileChanged);
}
public AggregatingFileSystemWatcherDecorator(
IPathService pathService,
IFileSystemWatcher fileSystemWatcher,
FileSystemWatcherConfiguration configuration)
{
_pathService = pathService;
_fileSystemWatcher = fileSystemWatcher;
_eventsQueue = new ConcurrentQueue <FileSystemEventArgs>();
_timer = new Timer(configuration.RefreshIntervalMs);
SubscribeToEvents();
StartTimer();
}
public TriggersCatalog(IDirectory directoryWrapper, IFile fileWrapper, string queueTriggersPath,
ISerializer serializer, IFileSystemWatcher watcherWrapper)
{
_directoryWrapper = directoryWrapper;
_fileWrapper = fileWrapper;
_queueTriggersPath = queueTriggersPath;
_directoryWrapper.CreateIfNotExists(_queueTriggersPath);
Queues = new List <ITriggerQueue>();
_serializer = serializer;
_watcherWrapper = watcherWrapper;
MonitorTriggerFolder();
}
public ContainerNotifier(
INotifierAction notify,
ILoggerAdapter <ContainerNotifier> logger,
IFileSystemWatcher fileSystemWatcher,
IGitIgnoreParser gitignore
)
{
_logger = logger;
_notify = notify;
_fileSystemWatcher = fileSystemWatcher;
_gitignore = gitignore;
}
public void Start(IFileSystemWatcher watcherInterface = null, int updateRatioInMilliseconds = 0)
{
Stop();
_watcher = new WatcherFileList(_settingsFileWatcher, watcherInterface, updateRatioInMilliseconds);
_source = new CancellationTokenSource();
_fileList = new WatcherCurrentFileList();
_channel = Channel.CreateBounded <FileTask>(MaxFileChanges);
_channelNewOutput = Channel.CreateBounded <NewOutput>(MaxFileChanges);
_current = Task.Run(async() => await this.ReadChannel(_source.Token));
_watcher.Start(HandleFileChanges);
}
/// <summary>
/// Stops listening to events from another <see cref="IFileSystemWatcher"/>.
/// </summary>
/// <param name="watcher">Instance to remove event handlers from.</param>
protected void UnregisterEvents(IFileSystemWatcher watcher)
{
if (watcher == null)
{
throw new ArgumentNullException(nameof(watcher));
}
watcher.Changed -= OnChanged;
watcher.Created -= OnCreated;
watcher.Deleted -= OnDeleted;
watcher.Error -= OnError;
watcher.Renamed -= OnRenamed;
}
public override object Clone()
{
IFileSystemWatcher clonedEncapsWatcher = InternalWatcher.Clone() as IFileSystemWatcher;
FileSystemAutoRefreshingWatcher clonedAutoRefreshingWatcher = new FileSystemAutoRefreshingWatcher(clonedEncapsWatcher);
// Add current refresher's policies to the cloned one
clonedAutoRefreshingWatcher.ClearPolicies();
foreach (var policy in _errorHandlingPolicies)
{
clonedAutoRefreshingWatcher.AddPolicy(policy);
}
return(clonedAutoRefreshingWatcher);
}
public MSBuildProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context)
{
_workspace = workspace;
_metadataReferenceCache = metadataReferenceCache;
_watcher = watcher;
_env = env;
_logger = loggerFactory.Create<MSBuildProjectSystem>();
_context = context;
}
public KeyboardManagerPage()
{
var settingsUtils = new SettingsUtils();
ViewModel = new KeyboardManagerViewModel(settingsUtils, SettingsRepository <GeneralSettings> .GetInstance(settingsUtils), ShellPage.SendDefaultIPCMessage, FilterRemapKeysList);
watcher = Helper.GetFileWatcher(
PowerToyName,
ViewModel.Settings.Properties.ActiveConfiguration.Value + ".json",
OnConfigFileUpdate);
InitializeComponent();
DataContext = ViewModel;
}
public TelemetryDataRepository(IFileSystem fileSystem, IFileSystemWatcherFactory fileSystemWatcherFactory)
{
this.fileSystem = fileSystem;
EnsureFileExists(StorageFilePath);
ReadFromXmlFile();
fileWatcher = fileSystemWatcherFactory.CreateNew();
fileWatcher.Path = Path.GetDirectoryName(StorageFilePath);
fileWatcher.Filter = Path.GetFileName(StorageFilePath);
fileWatcher.NotifyFilter = NotifyFilters.LastWrite;
fileWatcher.EnableRaisingEvents = true;
fileWatcher.Changed += OnStorageFileChanged;
}
public MiscellaneousFilesProjectSystem(OmniSharpWorkspace workspace, IFileSystemWatcher fileSystemWatcher, FileSystemHelper fileSystemHelper,
ILoggerFactory loggerFactory, [ImportMany] IEnumerable <Lazy <IProjectSystem, ProjectSystemMetadata> > projectSystems)
{
_workspace = workspace;
_fileSystemWatcher = fileSystemWatcher;
_fileSystemHelper = fileSystemHelper;
_logger = loggerFactory.CreateLogger <MiscellaneousFilesProjectSystem>();
_projectSystems = projectSystems
.Where(ps => ps.Metadata.Name == ProjectSystemNames.MSBuildProjectSystem ||
ps.Metadata.Name == ProjectSystemNames.DotNetProjectSystem)
.Select(ps => ps.Value)
.Cast <IWaitableProjectSystem>()
.ToList();
}
public MSBuildProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context)
{
_workspace = workspace;
_metadataReferenceCache = metadataReferenceCache;
_watcher = watcher;
_env = env;
_logger = loggerFactory.Create <MSBuildProjectSystem>();
_context = context;
}
private async void OnFilesChanged(IFileSystemWatcher sender, OnChangedEventArgs args)
{
try
{
logger.LogInformation("Detected filesystem changed.");
lock (exportLock)
{
lastTrigger = DateTime.Now;
if (isExportRunning)
{
logger.LogDebug("Export already running, skipping.");
return;
}
isExportRunning = true;
}
if (SyncThresholdInSeconds > 0)
{
var elapsed = DateTime.Now - lastTrigger.Value;
while (elapsed.TotalSeconds < SyncThresholdInSeconds)
{
logger.LogDebug($"Waiting for Untis to create all files.");
await Task.Delay(TimeSpan.FromSeconds(1));
elapsed = DateTime.Now - lastTrigger.Value;
}
}
await RunAsync();
isExportRunning = false;
lastTrigger = null;
}
catch (Exception e)
{
logger.LogError(e, "Something went terribly wrong.");
isExportRunning = false;
lastTrigger = null;
}
/**
* CAUTION with finally-Part here: there is a return statement inside try
*/
}
public void WatchTriggerResource(IFileSystemWatcher watcher)
{
var path = Path.GetDirectoryName(_path);
var filename = Path.GetFileName(_path);
watcher.EnableRaisingEvents = false;
watcher.Path = path;
watcher.Filter = filename;
watcher.NotifyFilter = NotifyFilters.LastWrite
| NotifyFilters.FileName
| NotifyFilters.DirectoryName;
watcher.EnableRaisingEvents = true;
}
private void DisposeWatcher(IFileSystemWatcher watcher)
{
if (Site.CanTrace())
{
Site.Trace($"Untrack changes from [{watcher.Path}]");
}
watcher.EnableRaisingEvents = false;
watcher.Changed -= OnFileSystemEvent;
watcher.Created -= OnFileSystemEvent;
watcher.Deleted -= OnFileSystemEvent;
watcher.Renamed -= OnFileSystemEvent;
watcher.Error -= WatcherOnError;
watcher.Dispose();
}
public SettingsWatcher(PowerToysRunSettings settings, ThemeManager themeManager)
{
_settingsUtils = new SettingsUtils();
_settings = settings;
_themeManager = themeManager;
// Set up watcher
_watcher = Microsoft.PowerToys.Settings.UI.Library.Utilities.Helper.GetFileWatcher(PowerLauncherSettings.ModuleName, "settings.json", OverloadSettings);
// Load initial settings file
OverloadSettings();
// Apply theme at startup
_themeManager.ChangeTheme(_settings.Theme, true);
}
public ProjectManager(ILoggerFactory loggerFactory, IEventEmitter eventEmitter, IFileSystemWatcher fileSystemWatcher, MetadataFileReferenceCache metadataFileReferenceCache, PackageDependencyChecker packageDependencyChecker, ProjectLoader projectLoader, OmniSharpWorkspace workspace)
{
_logger = loggerFactory.CreateLogger <ProjectManager>();
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_metadataFileReferenceCache = metadataFileReferenceCache;
_packageDependencyChecker = packageDependencyChecker;
_projectFiles = new ProjectFileInfoCollection();
_projectLoader = projectLoader;
_workspace = workspace;
_queue = new BufferBlock <ProjectToUpdate>();
_processLoopCancellation = new CancellationTokenSource();
_processLoopTask = Task.Run(() => ProcessLoopAsync(_processLoopCancellation.Token));
}
public UserSettings(Helpers.IThrottledActionInvoker throttledActionInvoker)
{
_settingsUtils = new SettingsUtils();
ChangeCursor = new SettingItem <bool>(true);
ActivationShortcut = new SettingItem <string>(DefaultActivationShortcut);
CopiedColorRepresentation = new SettingItem <ColorRepresentationType>(ColorRepresentationType.HEX);
ActivationAction = new SettingItem <ColorPickerActivationAction>(ColorPickerActivationAction.OpenEditor);
ColorHistoryLimit = new SettingItem <int>(20);
ColorHistory.CollectionChanged += ColorHistory_CollectionChanged;
LoadSettingsFromJson();
// delay loading settings on change by some time to avoid file in use exception
_watcher = Helper.GetFileWatcher(ColorPickerModuleName, "settings.json", () => throttledActionInvoker.ScheduleAction(LoadSettingsFromJson, SettingsReadOnChangeDelayInMs));
}
public FileSystemSyncWhenWatched(IFileSystemSync fileSystemSync, IFileSystemWatcher fileSystemWatcher)
{
if (fileSystemSync == null)
throw new ArgumentNullException(nameof(fileSystemSync));
_fileSystemSync = fileSystemSync;
if (fileSystemWatcher == null)
throw new ArgumentNullException(nameof(fileSystemWatcher));
_fileSystemWatcher = fileSystemWatcher;
fileSystemWatcher.OnChanged += FileSystemWatcherOnChanged;
fileSystemWatcher.OnCreated += FileSystemWatcherOnCreated;
fileSystemWatcher.OnDeleted += FileSystemWatcherOnDeleted;
fileSystemWatcher.OnRenamed += FileSystemWatcherOnRenamed;
}
protected internal virtual void FinalizeResourcesDirectoryWatcher(IFileSystemWatcher resourcesDirectoryWatcher)
{
if (resourcesDirectoryWatcher == null)
{
return;
}
resourcesDirectoryWatcher.Changed -= this.OnFileResourcesDirectoryEntryChanged;
resourcesDirectoryWatcher.Created -= this.OnFileResourcesDirectoryEntryCreated;
resourcesDirectoryWatcher.Deleted -= this.OnFileResourcesDirectoryEntryDeleted;
resourcesDirectoryWatcher.Error -= this.OnFileResourcesDirectoryEntryError;
resourcesDirectoryWatcher.Renamed -= this.OnFileResourcesDirectoryEntryRenamed;
resourcesDirectoryWatcher.Dispose();
}
private void When_constructing_watcher_for_valid_filter_it_must_succeed()
{
// Arrange
IFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
const string filter = "fil*.txt";
// Act
using (IFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(@"c:\", filter))
{
// Assert
watcher.Filter.Should().Be(filter);
}
}
/// <summary>
/// Refreshes the internal FileSystemWatcher
/// </summary>
/// <param name="returnWhenRefreshed">In case another thread is alreayd refreshing, determines wether the thread should return before the refreshing thread finishes or not.</param>
private void Refresh(bool returnWhenRefreshed)
{
// Making sure another thread isn't already refreshing:
if (!Monitor.TryEnter(_refreshLock))
{
// if another thread IS already refreshing - wait for it to finish then return
if (returnWhenRefreshed)
{
WaitForRefresh();
}
return;
}
IsRefreshing = true;
// 1. unsubscribe from old watcher's events.
UnsubscribeFromInternalWatcherEvents();
// 2a. Keeping the current internal "EnableRaisingEvents" value
bool currentEnableRaisingEvents = InternalWatcher.EnableRaisingEvents;
// 2b. Turning off EnableRaisingEvents to avoid "locking" the watched folder
InternalWatcher.EnableRaisingEvents = false;
// 3. Get a new watcher
IFileSystemWatcher newInternalWatcher = GetReplacementWatcher();
newInternalWatcher.EnableRaisingEvents = currentEnableRaisingEvents;
// 4. Disposing of the old watcher
InternalWatcher.Dispose();
// 5. Place new watcher in the Internal watcher property
// This also registers to the watcher's events
InternalWatcher = newInternalWatcher;
// Change state back to "not refreshing"
IsRefreshing = false;
// Notify any waiting threads that the refresh is done
foreach (var waitingThreadEvent in _waitingThreadsEvents.Values)
{
waitingThreadEvent.Set();
}
_waitingThreadsEvents.Clear();
Monitor.Exit(_refreshLock);
// Notify listeners about the refresh.
Refreshed?.Invoke(this, new EventArgs());
}
private static async Task InjectFilesIntoWatcher(IFileSystemWatcher fileWatcher, IFileSystem fileSystem, IEnumerable <string> fullPaths, ControlledTaskScheduler taskScheduler)
{
var files = fullPaths.AsList();
foreach (var path in files)
{
FileInfoStubFactory.Create(fileSystem, path);
}
RaiseCreated(fileWatcher, files);
await taskScheduler;
foreach (var path in files)
{
FileInfoStubFactory.Delete(fileSystem, path);
}
}
private void DestroyFileSystemWatcher()
{
lock (_SyncLock) {
if (_FileSystemWatcher != null)
{
_FileSystemWatcher.Enabled = false;
_FileSystemWatcher.Changed -= FileSystemWatcher_Changed;
_FileSystemWatcher.Deleted -= FileSystemWatcher_Deleted;
_FileSystemWatcher.Renamed -= FileSystemWatcher_Renamed;
_FileSystemWatcher.Error -= FileSystemWatcher_Error;
_FileSystemWatcher.Dispose();
_FileSystemWatcher = null;
}
}
}
private void Initialize(string path, HttpContext context)
{
System.Diagnostics.Debug.Assert(_watcher == null, "we only allow one manager per request!");
// initalize _logFiles before the file watcher since file watcher event handlers reference _logFiles
// this mirrors the Reset() where we stop the file watcher before nulling _logFile.
if (_logFiles == null)
{
var logFiles = new Dictionary <string, long>(StringComparer.OrdinalIgnoreCase);
foreach (var ext in LogFileExtensions)
{
foreach (var file in Directory.GetFiles(path, "*" + ext, SearchOption.AllDirectories))
{
try
{
logFiles[file] = new FileInfo(file).Length;
}
catch (Exception ex)
{
// avoiding racy with providers cleaning up log file
_tracer.TraceError(ex);
}
}
}
_logFiles = logFiles;
}
if (_watcher == null)
{
IFileSystemWatcher watcher = OSDetector.IsOnWindows()
? (IFileSystemWatcher) new FileSystemWatcherWrapper(path, includeSubdirectories: true)
: new NaiveFileSystemWatcher(path, LogFileExtensions);
watcher.Changed += new FileSystemEventHandler(DoSafeAction <object, FileSystemEventArgs, HttpContext>(OnChanged, "LogStreamManager.OnChanged", context));
watcher.Deleted += new FileSystemEventHandler(DoSafeAction <object, FileSystemEventArgs, HttpContext>(OnDeleted, "LogStreamManager.OnDeleted", context));
watcher.Renamed += new RenamedEventHandler(DoSafeAction <object, RenamedEventArgs, HttpContext>(OnRenamed, "LogStreamManager.OnRenamed", context));
//watcher.Error += new ErrorEventHandler(DoSafeAction<object, ErrorEventArgs,HttpContext>(OnError, "LogStreamManager.OnError", context));
watcher.Error += new ErrorEventHandler(DoSafeAction <object, ErrorEventArgs, HttpContext>(OnError, "LogStreamManager.OnError", context));
watcher.Start();
_watcher = watcher;
}
if (_heartbeat == null)
{
_heartbeat = new Timer(OnHeartbeat, context, HeartbeatInterval, HeartbeatInterval);
}
}
public DotNetProjectSystem(IOmnisharpEnvironment environment,
OmnisharpWorkspace omnisharpWorkspace,
IMetadataFileReferenceCache metadataFileReferenceCache,
ILoggerFactory loggerFactory,
IFileSystemWatcher watcher,
IEventEmitter emitter)
{
_environment = environment;
_omnisharpWorkspace = omnisharpWorkspace;
_logger = loggerFactory.CreateLogger <DotNetProjectSystem>();
_emitter = emitter;
_metadataFileReferenceCache = metadataFileReferenceCache;
_watcher = watcher;
_packageRestore = new PackagesRestoreTool(loggerFactory, _emitter);
_projectStates = new ProjectStatesCache(loggerFactory, _emitter);
}
public DotNetProjectSystem(IOmnisharpEnvironment environment,
OmnisharpWorkspace omnisharpWorkspace,
IMetadataFileReferenceCache metadataFileReferenceCache,
ILoggerFactory loggerFactory,
IFileSystemWatcher watcher,
IEventEmitter emitter)
{
_environment = environment;
_omnisharpWorkspace = omnisharpWorkspace;
_logger = loggerFactory.CreateLogger<DotNetProjectSystem>();
_emitter = emitter;
_metadataFileReferenceCache = metadataFileReferenceCache;
_watcher = watcher;
_packageRestore = new PackagesRestoreTool(loggerFactory, _emitter);
_projectStates = new ProjectStatesCache(loggerFactory);
}
private void When_constructing_watcher_for_existing_directory_it_must_succeed()
{
// Arrange
const string directoryToWatch = @"e:\ExistingFolder";
IFileSystem fileSystem = new FakeFileSystemBuilder()
.IncludingDirectory(directoryToWatch)
.Build();
// Act
using (IFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher(directoryToWatch))
{
// Assert
watcher.Path.Should().Be(directoryToWatch);
watcher.Filter.Should().Be("*.*");
}
}
public JekyllSiteContextTests()
{
filename = @"C:\Site\Index.md";
basePath = @"C:\Site\";
eventAggregator = Substitute.For<IEventAggregator>();
dialogService = Substitute.For<IDialogService>();
fileSystem = Substitute.For<IFileSystem>();
fileSystemWatcherFactory = Substitute.For<IFileSystemWatcherFactory>();
fileSystemWatcher = Substitute.For<IFileSystemWatcher>();
fileSystemWatcherFactory.Create(Arg.Any<string>()).Returns(fileSystemWatcher);
jekyllContext = new JekyllSiteContext(
eventAggregator,
dialogService,
fileSystem,
fileSystemWatcherFactory,
basePath);
}
public MSBuildProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions <OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IEventEmitter emitter,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context)
{
_workspace = workspace;
_metadataReferenceCache = metadataReferenceCache;
_watcher = watcher;
_env = env;
_options = optionsAccessor.Options.MsBuild;
_logger = loggerFactory.CreateLogger <MSBuildProjectSystem>();
_emitter = emitter;
_context = context;
}
private void When_constructing_watcher_it_must_succeed()
{
// Arrange
IFileSystem fileSystem = new FakeFileSystemBuilder()
.Build();
// Act
using (IFileSystemWatcher watcher = fileSystem.ConstructFileSystemWatcher())
{
// Assert
watcher.Path.Should().Be(string.Empty);
watcher.Filter.Should().Be("*.*");
watcher.NotifyFilter.Should().Be(NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite);
watcher.IncludeSubdirectories.Should().BeFalse();
watcher.EnableRaisingEvents.Should().BeFalse();
watcher.InternalBufferSize.Should().Be(8192);
}
}
public Delay50MsNoFiltering() {
_fileSystem = Substitute.For<IFileSystem>();
var watchers = GetWatchersFromMsBuildFileSystemWatcher(_fileSystem);
_fileSystemFilter = Substitute.For<IMsBuildFileSystemFilter>();
_fileSystemFilter.IsFileAllowed(Arg.Any<string>(), Arg.Any<FileAttributes>()).ReturnsForAnyArgs(true);
_fileSystemFilter.IsDirectoryAllowed(Arg.Any<string>(), Arg.Any<FileAttributes>()).ReturnsForAnyArgs(true);
_taskScheduler = new ControlledTaskScheduler(SynchronizationContext.Current);
_fileSystemWatcher = new MsBuildFileSystemWatcher(ProjectDirectory, "*", 50, 50, _fileSystem, _fileSystemFilter, Substitute.For<IActionLog>(), _taskScheduler);
_taskScheduler.Link(_fileSystemWatcher.SourceBlock, c => { _changeset = c; });
_fileSystemWatcher.Start();
_fileWatcher = watchers.FileWatcher;
_directoryWatcher = watchers.DirectoryWatcher;
_attributesWatcher = watchers.AttributesWatcher;
}
public MSBuildProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions<OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IEventEmitter emitter,
IMetadataFileReferenceCache metadataReferenceCache,
IFileSystemWatcher watcher,
MSBuildContext context)
{
_workspace = workspace;
_metadataReferenceCache = metadataReferenceCache;
_watcher = watcher;
_env = env;
_options = optionsAccessor.Options.MsBuild;
_logger = loggerFactory.CreateLogger<MSBuildProjectSystem>();
_emitter = emitter;
_context = context;
}
public JekyllSiteContextTests()
{
filename = @"C:\Site\Index.md";
basePath = @"C:\Site\";
eventAggregator = Substitute.For <IEventAggregator>();
dialogService = Substitute.For <IDialogService>();
fileSystem = Substitute.For <IFileSystem>();
fileSystemWatcherFactory = Substitute.For <IFileSystemWatcherFactory>();
fileSystemWatcher = Substitute.For <IFileSystemWatcher>();
fileSystemWatcherFactory.Create(Arg.Any <string>()).Returns(fileSystemWatcher);
jekyllContext = new JekyllSiteContext(
eventAggregator,
dialogService,
fileSystem,
fileSystemWatcherFactory,
basePath);
}
public ProjectManager(ILoggerFactory loggerFactory, IEventEmitter eventEmitter, IFileSystemWatcher fileSystemWatcher, MetadataFileReferenceCache metadataFileReferenceCache, PackageDependencyChecker packageDependencyChecker, ProjectLoader projectLoader, OmniSharpWorkspace workspace, ImmutableArray <IMSBuildEventSink> eventSinks)
{
_logger = loggerFactory.CreateLogger <ProjectManager>();
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_metadataFileReferenceCache = metadataFileReferenceCache;
_packageDependencyChecker = packageDependencyChecker;
_projectFiles = new ProjectFileInfoCollection();
_failedToLoadProjectFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_projectLoader = projectLoader;
_workspace = workspace;
_eventSinks = eventSinks;
_queue = new BufferBlock <ProjectToUpdate>();
_processLoopCancellation = new CancellationTokenSource();
_processLoopTask = Task.Run(() => ProcessLoopAsync(_processLoopCancellation.Token));
_onDirectoryFileChanged = OnDirectoryFileChanged;
}
public DotNetProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
IDotNetCliService dotNetCliService,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_dotNetCliService = dotNetCliService;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_logger = loggerFactory.CreateLogger <DotNetProjectSystem>();
_projectStates = new ProjectStatesCache(loggerFactory, _eventEmitter);
}
public Delay50MsNoFiltering()
{
_fileSystem = Substitute.For <IFileSystem>();
var watchers = GetWatchersFromMsBuildFileSystemWatcher(_fileSystem);
_fileSystemFilter = Substitute.For <IMsBuildFileSystemFilter>();
_fileSystemFilter.IsFileAllowed(Arg.Any <string>(), Arg.Any <FileAttributes>()).ReturnsForAnyArgs(true);
_fileSystemFilter.IsDirectoryAllowed(Arg.Any <string>(), Arg.Any <FileAttributes>()).ReturnsForAnyArgs(true);
_taskScheduler = new ControlledTaskScheduler(SynchronizationContext.Current);
_fileSystemWatcher = new MsBuildFileSystemWatcher(ProjectDirectory, "*", 50, 50, _fileSystem, _fileSystemFilter, Substitute.For <IActionLog>(), _taskScheduler);
_taskScheduler.Link(_fileSystemWatcher.SourceBlock, c => { _changeset = c; });
_fileSystemWatcher.Start();
_fileWatcher = watchers.FileWatcher;
_directoryWatcher = watchers.DirectoryWatcher;
_attributesWatcher = watchers.AttributesWatcher;
}
public NoDelayNoFiltering()
{
_fileSystem = Substitute.For<IFileSystem>();
_fileSystem.GetFileAttributes(Arg.Any<string>()).Throws<FileNotFoundException>();
var watchers = GetWatchersFromMsBuildFileSystemWatcher(_fileSystem);
var fileSystemFilter = Substitute.For<IMsBuildFileSystemFilter>();
fileSystemFilter.IsFileAllowed(Arg.Any<string>(), Arg.Any<FileAttributes>()).ReturnsForAnyArgs(true);
fileSystemFilter.IsDirectoryAllowed(Arg.Any<string>(), Arg.Any<FileAttributes>()).ReturnsForAnyArgs(true);
_taskScheduler = new ControlledTaskScheduler(SynchronizationContext.Current);
_fileSystemWatcher = new MsBuildFileSystemWatcher(ProjectDirectory, "*", 0, _fileSystem, fileSystemFilter, _taskScheduler, NullLog.Instance);
_fileSystemWatcher.Start();
_fileWatcher = watchers.FileWatcher;
_directoryWatcher = watchers.DirectoryWatcher;
_attributesWatcher = watchers.AttributesWatcher;
}
public HarnessManager(
IScriptEngine scriptEngine,
IPageGenerator pageGenerator,
IFileSystem fileSystem,
IFileSystemWatcher fileSystemWatcher)
{
_scriptEngine = scriptEngine;
_pageGenerator = pageGenerator;
_fileSystem = fileSystem;
_fileSystemWatcher = fileSystemWatcher;
var currentDir = Directory.GetCurrentDirectory();
var w = new System.IO.FileSystemWatcher(currentDir, "*.js");
w.IncludeSubdirectories = true;
w.NotifyFilter = NotifyFilters.LastWrite;
w.Changed += new FileSystemEventHandler(w_Changed);
w.EnableRaisingEvents = true;
}
public AspNet5ProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
IOptions<OmniSharpOptions> optionsAccessor,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
AspNet5Context context)
{
_workspace = workspace;
_env = env;
_options = optionsAccessor.Options;
_logger = loggerFactory.Create<AspNet5ProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_designTimeHostManager = new DesignTimeHostManager(loggerFactory);
_context = context;
_watcher = watcher;
lifetime.ApplicationStopping.Register(OnShutdown);
}
public NoDelayNoFiltering() {
_fileSystem = Substitute.For<IFileSystem>();
_fileSystem.GetFileAttributes(Arg.Any<string>()).Throws<FileNotFoundException>();
_fileSystem.ToLongPath(Arg.Any<string>()).Returns(ci => ci[0]);
_fileSystem.ToShortPath(Arg.Any<string>()).Returns(ci => ci[0]);
var watchers = GetWatchersFromMsBuildFileSystemWatcher(_fileSystem);
var fileSystemFilter = Substitute.For<IMsBuildFileSystemFilter>();
fileSystemFilter.IsFileAllowed(Arg.Any<string>(), Arg.Any<FileAttributes>()).ReturnsForAnyArgs(true);
fileSystemFilter.IsDirectoryAllowed(Arg.Any<string>(), Arg.Any<FileAttributes>()).ReturnsForAnyArgs(true);
_taskScheduler = new ControlledTaskScheduler(SynchronizationContext.Current);
DirectoryInfoStubFactory.Create(_fileSystem, ProjectDirectory);
_fileSystemWatcher = new MsBuildFileSystemWatcher(ProjectDirectory, "*", 0, 0, _fileSystem, fileSystemFilter, Substitute.For<IActionLog>(), _taskScheduler);
_fileSystemWatcher.Start();
_fileWatcher = watchers.FileWatcher;
_directoryWatcher = watchers.DirectoryWatcher;
_attributesWatcher = watchers.AttributesWatcher;
}
public DnxProjectSystem(OmnisharpWorkspace workspace,
IOmnisharpEnvironment env,
ILoggerFactory loggerFactory,
IMetadataFileReferenceCache metadataFileReferenceCache,
IApplicationLifetime lifetime,
IFileSystemWatcher watcher,
IEventEmitter emitter,
DnxContext context)
{
_workspace = workspace;
_env = env;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger<DnxProjectSystem>();
_metadataFileReferenceCache = metadataFileReferenceCache;
_context = context;
_watcher = watcher;
_emitter = emitter;
_directoryEnumerator = new DirectoryEnumerator(loggerFactory);
lifetime?.ApplicationStopping.Register(OnShutdown);
}
public void Start() {
_log.WatcherStarting();
Enqueue(new DirectoryCreated(_directory, _fileSystem, _fileSystemFilter, _directory));
_fileWatcher = CreateFileSystemWatcher(NotifyFilters.FileName);
_fileWatcher.Created += (sender, e) => Enqueue(new FileCreated(_directory, _fileSystem, _fileSystemFilter, e.FullPath));
_fileWatcher.Deleted += (sender, e) => Enqueue(new FileDeleted(_directory, e.FullPath));
_fileWatcher.Renamed += (sender, e) => Enqueue(new FileRenamed(_directory, _fileSystem, _fileSystemFilter, e.OldFullPath, e.FullPath));
_fileWatcher.Error += (sender, e) => TraceError("File Watcher", e);
_directoryWatcher = CreateFileSystemWatcher(NotifyFilters.DirectoryName);
_directoryWatcher.Created += (sender, e) => Enqueue(new DirectoryCreated(_directory, _fileSystem, _fileSystemFilter, e.FullPath));
_directoryWatcher.Deleted += (sender, e) => Enqueue(new DirectoryDeleted(_directory, e.FullPath));
_directoryWatcher.Renamed += (sender, e) => Enqueue(new DirectoryRenamed(_directory, _fileSystem, _fileSystemFilter, e.OldFullPath, e.FullPath));
_directoryWatcher.Error += (sender, e) => TraceError("Directory Watcher", e);
_attributesWatcher = CreateFileSystemWatcher(NotifyFilters.Attributes);
_attributesWatcher.Changed += (sender, e) => Enqueue(new AttributesChanged(e.Name, e.FullPath));
_attributesWatcher.Error += (sender, e) => TraceError("Attributes Watcher", e);
_log.WatcherStarted();
}
internal void WatcherConnect(IFileSystemWatcher fileSystemWatcher, bool adopt)
{
if (fileSystemWatcher != null)
{
this.watcher = fileSystemWatcher;
this.ownsWatcher = adopt;
this.watcher.Created += watcher_Created;
this.watcher.Changed += watcher_Changed;
this.watcher.Deleted += watcher_Deleted;
this.watcher.Renamed += watcher_Renamed;
}
}
public static Solution Load(string path, Func<string, string> fileReader, IFileSystemWatcher fileSystemWatcher, IScheduler scheduler)
{
return new Solution(path, fileReader, fileSystemWatcher, scheduler);
}
public FileSystemOverseer(IFileSystemPoller poller, IFileSystemWatcher watcher) : base(watcher)
{
_reportedItems = new HashSet<string>();
_reportedFilesLock = new object();
InitPollerErrorPolicies();
// Initiating poller
_poller = poller;
if(_poller.Path != watcher.Path)
{
_poller.Path = watcher.Path;
}
EnableRaisingEvents = false;
_poller.Created += OnCreatedPolled;
_poller.Deleted += OnDeletedPolled;
_poller.Error += OnPollerError;
// Getting initial directory content by forcing a poll
_poller.PollingType = PollingType.Poll;
_poller.ForcePoll();
// For the rest of the Overseer's lifespan, keep the poller as a 'watcher'
_poller.PollingType = PollingType.Watch;
}
public FileSystemAutoRefreshingWatcher(IFileSystemWatcher watcher) : base(watcher)
{
InitBasicPolicies();
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
private void Dispose(bool disposing)
{
if (disposing)
{
if (this.ownsWatcher && this.watcher != null)
this.watcher.Dispose();
this.watcher = null;
}
}
public FilesController(IFileSystemWatcher watcher)
{
_watcher = watcher;
}
public LocalFileSystem()
{
_fileSystemWatcher = new FileSystemWatcherImpl();
}
