public void RegisterDeleteFileTest() { Random rnd = new Random(); string dir = Path.Combine(Directory.GetCurrentDirectory(), rnd.Next().ToString()); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } var files2Create = Enumerable.Range(1, 5) .Select(n => rnd.Next(10000, 99999)) .Select(n => Path.Combine(dir, $"{n}.txt")).ToList(); files2Create.ForEach(f => File.WriteAllText(Path.Combine(dir, f), ";)")); List <string> deletedFiles = new List <string>(); using (var watcher = new DirectoryWatcher(dir)) { Action <string> notifyMe = (f) => deletedFiles.Add(f); watcher.Register(notifyMe, ObserverType.Delete); files2Create.ForEach(f => { if (File.Exists(f)) { File.Delete(f); } }); Thread.Sleep(500); CollectionAssert.AreEqual(files2Create, deletedFiles); } Directory.Delete(dir, true); }
public void Can_Watch_Directory_For_New_Items() { // Arrange IDirectory directory = new InMemoryDirectory(); var watcher = new DirectoryWatcher(directory); var watchPattern = "/some/dir/folder/newfile.*"; watcher.AddFilter(watchPattern); // bool notified = false; watcher.ItemAdded += (sender, e) => { DirectoryItemAddedEventArgs args = e.DirectoryItemEventArgs; var matchedFilters = e.MatchedFilters; IDirectoryItem newItem = args.NewItem; Assert.Equal("newfile.txt", newItem.Name); notified = true; }; directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "newfile.txt")); Assert.True(notified); notified = false; directory.AddFile("/some/dir/folder/", new StringFileInfo("shouldnt trigger", "anotherfile.txt")); Assert.False(notified); }
public void Should_send_message_when_file_changes_once() { var messageBus = MockRepository.GenerateMock <IMessageBus>(); var validator = MockRepository.GenerateMock <IWatchValidator>(); var configuration = MockRepository.GenerateMock <IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); configuration.Stub(c => c.WatchAllFiles).Return(true); validator.Stub(v => v.GetIgnorePatterns()).Return(""); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock <IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); var file = Path.GetFullPath("watcher_test_changes_once.txt"); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); validator.Stub(v => v.ShouldPublish("")).IgnoreArguments().Return(true).Repeat.Any(); // Write twice File.WriteAllText(file, "meh "); using (var writer = new StreamWriter(file, true)) { writer.WriteLine("some text"); } Thread.Sleep(450); messageBus.AssertWasCalled( m => m.Publish <FileChangeMessage>( Arg <FileChangeMessage> .Matches( f => f.Files.Length > 0 && f.Files[0].Extension.Equals(Path.GetExtension(file)) && f.Files[0].FullName.Equals(file) && f.Files[0].Name.Equals(Path.GetFileName(file)))), m => m.Repeat.Once()); File.Delete(file); }
public MainWindow() { InitializeComponent(); SettingsHelper.UpgradeSettings(); SettingsHelper.IncrementLaunches(); this.AnimateSize(AnimationMode.Hide); if (Settings.Default.HideDelay > 0) { _hideTimer = new DispatcherTimer {Interval = TimeSpan.FromMilliseconds(Settings.Default.HideDelay)}; _hideTimer.Tick += delegate { _hideTimer.Stop(); HideNotification(); }; } _notificationQueue = new Queue<string>(); _directoryWatcher = new DirectoryWatcher(delegate(string path) { Dispatcher.Invoke(() => { AddToFileQueue(path); }); }); _directoryWatcher.Start(); App.SuccessfullyLoaded = true; }
public void Should_only_publish_pusblish_files_listed_in_cache() { var messageBus = MockRepository.GenerateMock <IMessageBus>(); var validator = MockRepository.GenerateMock <IWatchValidator>(); var configuration = MockRepository.GenerateMock <IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); validator.Stub(v => v.ShouldPublish("")).IgnoreArguments().Return(true).Repeat.Any(); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock <IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); var file = Path.GetFullPath("not_detection_when_paused.txt"); _cahce.Stub(x => x.IsProjectFile(file)).Return(true); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); watcher.Pause(); watcher.Resume(); File.WriteAllText(file, "meh "); Thread.Sleep(450); messageBus.AssertWasCalled(m => m.Publish <FileChangeMessage>(new FileChangeMessage()), m => m.IgnoreArguments()); }
public void Should_always_publish_fs_project_files() { var messageBus = MockRepository.GenerateMock <IMessageBus>(); var validator = MockRepository.GenerateMock <IWatchValidator>(); var configuration = MockRepository.GenerateMock <IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); validator.Stub(v => v.ShouldPublish("")).IgnoreArguments().Return(true).Repeat.Any(); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock <IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); var file = Path.GetFullPath("some_project_file_for_detection.fsproj"); _cahce.Stub(c => c.Get <Project>(file)).Return(new Project("", new ProjectDocument(ProjectType.FSharp))); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); watcher.Pause(); watcher.Resume(); File.WriteAllText(file, "meh "); Thread.Sleep(450); messageBus.AssertWasCalled(m => m.Publish <FileChangeMessage>(new FileChangeMessage()), m => m.IgnoreArguments()); }
private void Reset() { // Has everything loaded yet? if (this._watchedFolders == null) return; foreach (var watcher in directoryWatchers) { watcher.Dispose(); } this.directoryWatchers.Clear(); if (this.syncThingManager.State != SyncThingState.Running) return; var folders = this.syncThingManager.Folders.FetchAll(); if (folders == null) return; // Folders haven't yet loaded foreach (var folder in folders) { if (!this._watchedFolders.Contains(folder.FolderId)) continue; var watcher = new DirectoryWatcher(folder.Path, this.BackoffInterval, this.FolderExistenceCheckingInterval); watcher.PreviewDirectoryChanged += (o, e) => e.Cancel = this.PreviewDirectoryChanged(folder, e.SubPath); watcher.DirectoryChanged += (o, e) => this.DirectoryChanged(folder, e.SubPath); this.directoryWatchers.Add(watcher); } }
private void DirectoryViewModelBaseOnNoExistDirectory(object sender, DirectoryViewModelBase.NoExistDirectoryArgs e) { var directory = PathHelper.ClearNotExistDirectories(e.Directory); e.Directory.Parent.SubDirectories.Remove(directory); DirectoryWatcher.DeleteFileSystemWatcher(e.Directory); }
protected override void Destroy() { // Mark effect system as destroyed (so that async effect compilation are ignored) lock (cachedEffects) { // Clear effects foreach (var effect in cachedEffects) { effect.Value.ReleaseInternal(); } cachedEffects.Clear(); // Mark as not initialized anymore isInitialized = false; } #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP if (directoryWatcher != null) { directoryWatcher.Modified -= FileModifiedEvent; directoryWatcher.Dispose(); directoryWatcher = null; } #endif base.Destroy(); }
public void Execute(object parameter) { if (File.Exists(Constant.SAVE_FILE_PATH)) { try { string json = File.ReadAllText(Constant.SAVE_FILE_PATH, Encoding.UTF8); var loadObj = JSON.Deserialize <IDictionary <string, IList <WatchLog> > >(json); foreach (var item in loadObj) { var watcher = DirectoryWatcher.Listen(item.Key); foreach (var log in item.Value) { watcher.Logs.Add(log); } Watchers.Add(watcher); } } catch (Exception e) { MessageBox.Show(e.Message + "\r\n" + e.StackTrace); File.AppendAllText("err.log", "[" + DateTime.Now + "] " + e.Message + "\r\n" + e.StackTrace); } } }
public EffectNodeFactory() { mainContext = VLServiceRegistry.Default.GetService <SynchronizationContext>(); var game = VLServiceRegistry.Default.GetService <Game>(); ServiceRegistry = game?.Services; ContentManger = game?.Content; EffectSystem = game?.EffectSystem; DeviceManager = game?.GraphicsDeviceManager; ScriptSystem = game?.Script; nodeDescriptions = new ObservableCollection <IVLNodeDescription>(GetNodeDescriptions()); NodeDescriptions = new ReadOnlyObservableCollection <IVLNodeDescription>(nodeDescriptions); if (EffectSystem != null) { // Ensure the effect system tracks the same files as we do var fieldInfo = typeof(EffectSystem).GetField("directoryWatcher", BindingFlags.NonPublic | BindingFlags.Instance); directoryWatcher = fieldInfo.GetValue(EffectSystem) as DirectoryWatcher; } else { directoryWatcher = new DirectoryWatcher(xkslFileFilter); } directoryWatcher.Modified += DirectoryWatcher_Modified; }
public override void Initialize() { base.Initialize(); isInitialized = true; // Get graphics device service graphicsDeviceService = Services.GetSafeServiceAs <IGraphicsDeviceService>(); #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP Enabled = true; directoryWatcher = new DirectoryWatcher("*.xksl"); directoryWatcher.Modified += FileModifiedEvent; // TODO: xkfx too #endif // Setup shader compiler settings from a compilation mode. // TODO: We might want to provide overrides on the GameSettings to specify debug and/or optim level specifically. if (Game != null && (((Game)Game).Settings != null)) { effectCompilerParameters.ApplyCompilationMode(((Game)Game).Settings.CompilationMode); } // Make sure default compiler is created (local if possible otherwise none) if nothing else was explicitely set/requested (i.e. by GameSettings) if (Compiler == null) { Compiler = CreateEffectCompiler(); } }
public void WatchFile(string path) { if (!path.ToLower().Contains(":\\progra")) return; var dir = Path.GetDirectoryName(path); if ( !Path.IsPathRooted(dir) ) dir = Path.GetFullPath(dir); if (!Directory.Exists(dir)) { Logging.Error("ignored watch on missing folder {0}", dir); return; } DirectoryWatcher w; if (!dwatchers.TryGetValue(dir, out w)) { if (!FileExists(path)) { Logging.Error("ignored watch on missing file {0}", path); return; } Logging.Emit("create new watcher for {0}", dir); w = new DirectoryWatcher(dir); dwatchers.Add(dir, w); w.FileChanged += OnWatchedFileChanged; w.Enable(); } var file = Path.GetFileName(path); w.Watch(file); }
public override void Initialize() { base.Initialize(); isInitialized = true; // Get graphics device service graphicsDeviceService = Services.GetSafeServiceAs<IGraphicsDeviceService>(); #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP Enabled = true; directoryWatcher = new DirectoryWatcher("*.xksl"); directoryWatcher.Modified += FileModifiedEvent; // TODO: xkfx too #endif // Setup shader compiler settings from a compilation mode. // TODO: We might want to provide overrides on the GameSettings to specify debug and/or optim level specifically. if (Game != null && (((Game)Game).Settings != null)) { effectCompilerParameters.ApplyCompilationMode(((Game)Game).Settings.CompilationMode); } // Make sure default compiler is created (local if possible otherwise none) if nothing else was explicitely set/requested (i.e. by GameSettings) if (Compiler == null) Compiler = CreateEffectCompiler(); }
public static IDirectoryViewModel ClearNotExistDirectories(IDirectoryViewModel directory) { IDirectoryViewModel noExistDirectory = null; IDirectoryViewModel currentDirectory = directory; while (currentDirectory.Parent != null) { if (currentDirectory.Path == "" || Directory.Exists(currentDirectory.Path)) { if (noExistDirectory != null) { currentDirectory.SubDirectories.Remove(noExistDirectory); } return(currentDirectory); } DirectoryWatcher.DeleteFileSystemWatcher(currentDirectory); currentDirectory.SubDirectories.Clear(); currentDirectory.Files.Clear(); noExistDirectory = currentDirectory; currentDirectory = currentDirectory.Parent; } // only this pc if (currentDirectory.Path == "") { if (noExistDirectory != null) { currentDirectory.SubDirectories.Remove(noExistDirectory); } return(currentDirectory); } return(null); }
public void Can_Watch_Directory_For_Updated_Items() { // Arrange IDirectory directory = new InMemoryDirectory(); directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "newfile.txt")); var watcher = new DirectoryWatcher(directory); var watchPattern = "/some/dir/folder/new*.txt"; watcher.AddFilter(watchPattern); // bool notified = false; watcher.ItemUpdated += (sender, e) => { DirectoryItemUpdatedEventArgs args = e.DirectoryItemEventArgs; var matchedFilters = e.MatchedFilters; Assert.Equal("newfile.txt", args.OldItem.Name); Assert.Equal("newfile.csv", args.NewItem.Name); notified = true; }; // now update the file var existingItem = directory.GetFile("/some/dir/folder/newfile.txt"); existingItem.Update(new StringFileInfo("changed", "newfile.csv")); Assert.True(notified); notified = false; existingItem.Update(new StringFileInfo("changed again", "newfile.csv")); // second update shouldnt trigger as our watch pattern is only watching newfile*.txt files. Assert.False(notified); }
public void _watcher_CreatedTest() { string dirName = "DelDirTest"; Directory mydir = fact_createTestDirectory(dirName); string dirPath = mydir.Path; _TestTrigger = new AutoResetEvent(false); bHandlerRaised = false; DirectoryWatcher dw = new DirectoryWatcher(mydir); dw.FileCreated += dw_FileCreated; dw.EnableRaisingEvents = true; Directory myd2 = new Directory(mydir, "subDir"); myd2.Create(); _TestTrigger.WaitOne(2000); Assert.IsTrue(bHandlerRaised, "Dir Create Event not raised"); bHandlerRaised = false; //unassign event handlers for other tests. dw.FileCreated -= dw_FileCreated; dw = null; }
public void Execute(object parameter) { if (null == Watchers) { return; } if (parameter is string[] files) { foreach (var file in files) { // 購読済みなら追加しない foreach (var watcher in Watchers) { if (file == watcher.Path) { goto SKIP; } } if (Directory.Exists(file)) { var watcher = DirectoryWatcher.Listen(file); Watchers.Add(watcher); } SKIP :; } } }
public void EnableRaisingEventsTest() { string dirName = "testDir"; Directory directoryToWatch = fact_createTestDirectory(dirName); DirectoryWatcher target = new DirectoryWatcher(directoryToWatch); bHandlerRaised = false; _TestTrigger = new AutoResetEvent(false); File df = new File(directoryToWatch, "test1.txt"); target.FileCreated += dw_FileCreated; target.EnableRaisingEvents = false; df.Create(); _TestTrigger.WaitOne(3000); // should time out Assert.IsFalse(bHandlerRaised, "Event should not be raised"); //now prove that event is raised by recreating file. bHandlerRaised = false; GC.WaitForPendingFinalizers(); System.IO.File.Delete(df.Path); target.EnableRaisingEvents = true; df.Create(); _TestTrigger.WaitOne(3000); // should expect event Assert.IsTrue(bHandlerRaised, "Event should be raised"); target.FileCreated -= dw_FileCreated; _TestTrigger = null; }
static Languages() { DoInit(); ms_watcher = new DirectoryWatcher(ms_installedPath, TimeSpan.FromMilliseconds(250)); ms_watcher.Changed += Languages.DoFilesChanged; }
public SharedFolderWatcher(string target, eAssignedLane_Printer laneID, string path = "") { Target = target; LaneID = laneID; //WatchedFiles = new MutexFileQueue<string>(target); WatchedFiles.Clear(); Watcher = new DirectoryWatcher(target); Watcher.AddOnCreatedEventHandler(OnCreateFileInWatchedFolder); Watcher.AddOnRenamedEventHandler(OnRenameFileInWatchedFolder); if (laneID == eAssignedLane_Printer.Lane1) { ViewModelLocator.Atom.FlowHostVM.IsLane1WFExist = true; ViewModelLocator.Atom.FlowHostVM.Lane1WFDisk = target; ViewModelLocator.Atom.FlowHostVM.Lane1WFPath = path; } else if (laneID == eAssignedLane_Printer.Lane2) { ViewModelLocator.Atom.FlowHostVM.IsLane2WFExist = true; ViewModelLocator.Atom.FlowHostVM.Lane1WFDisk = target; ViewModelLocator.Atom.FlowHostVM.Lane2WFPath = path; } Watcher.BeginWatching(); }
public static IApplicationBuilder AddLiveReload(this IApplicationBuilder app, LiveReloadingSettings liveRelaodingSettings = null) { app.AddWebSocket(); app.UseMiddleware <LiveReloadingMiddleware>(); DirectoryWatcher.StatWatching(liveRelaodingSettings ?? new LiveReloadingSettings()); return(app); }
public void Should_send_message_when_file_changes_once() { var messageBus = MockRepository.GenerateMock<IMessageBus>(); var validator = MockRepository.GenerateMock<IWatchValidator>(); var configuration = MockRepository.GenerateMock<IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator); var file = Path.GetFullPath("watcher_test_changes_once.txt"); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); validator.Stub(v => v.ShouldPublish(null)).IgnoreArguments().Return(true).Repeat.Any(); // Write twice File.WriteAllText(file, "meh "); using (var writer = new StreamWriter(file, true)) { writer.WriteLine("some text"); } Thread.Sleep(450); messageBus.AssertWasCalled( m => m.Publish<FileChangeMessage>( Arg<FileChangeMessage>.Matches( f => f.Files.Length > 0 && f.Files[0].Extension.Equals(Path.GetExtension(file)) && f.Files[0].FullName.Equals(file) && f.Files[0].Name.Equals(Path.GetFileName(file)))), m => m.Repeat.Once()); File.Delete(file); }
public void Should_not_start_watch_when_folder_is_invalid() { var bus = MockRepository.GenerateMock<IMessageBus>(); var watcher = new DirectoryWatcher(bus, null); watcher.Watch(""); bus.AssertWasNotCalled(m => m.Publish<InformationMessage>(null), m => m.IgnoreArguments()); }
public void Setup() { _mocker = new AutoMoqer(); var mockFileSystem = new MockFileSystem(); _mocker.SetInstance<IFileSystem>(mockFileSystem); // GetMock of the abstract class before create to prevent automoq bugs _mocker.GetMock<FileSystemWatcherBase>(); _instance = _mocker.Create<DirectoryWatcher>(); // Mocked files var content = new byte[] {1, 1, 1}; _expectedFileLength = content.Length; _expectedWriteDate = DateTime.Now.ToUniversalTime(); var nameWithPath = mockFileSystem.Path.Combine(Path, FileName); mockFileSystem.AddFile(nameWithPath, new MockFileData(content) { LastWriteTime = _expectedWriteDate }); _trackedFile = new TrackedFile(); _mocker.GetMock<ITrackedFileStore>() .Setup(x => x.GetTrackedFileByFullPath(nameWithPath)) .Returns(_trackedFile); }
private void UploaderPropertyChanged(object sender, PropertyChangedEventArgs e) { LOGGER.Debug($"Received a uploader property changed event for property {e.PropertyName}"); if (e.PropertyName == nameof(Uploader.State)) { if (Uploader.State == UploaderState.Waiting) { LOGGER.Info($"Uploader state changed to waiting -> end if should end afterwards"); WatchedProcesses.ProcessesCompleted += ProcessesCompleted; EndIfShouldEnd(); } else if (Uploader.State == UploaderState.Uploading) { LOGGER.Info($"Uploader state changed to uploading -> can't end until it's finished or cancelled"); WatchedProcesses.ProcessesCompleted -= ProcessesCompleted; } else if (Uploader.State == UploaderState.NotRunning) { LOGGER.Info($"Uploader state changed to not running -> end if should end"); DirectoryWatcher.Cancel(); EndIfShouldEnd(); } } }
private DependencyInjector() { ExportChanged = new Subject <ExportChangedEventArgs>(); _conventions = GetConventions(); var assembly = Assembly.GetExecutingAssembly(); var directory = Config.Current.Paths.Plugins.Location; var filter = @"*.dll"; // Create catalogs _directoryCatalog = new DirectoryCatalog(directory, filter, _conventions); _assemblyCatalog = new AssemblyCatalog(assembly, _conventions); // Initialize container _container = InitContainer(); _container.ExportsChanged += OnExportsChanged; // Start file watcher for the directory catalog // so that dependencies can be loaded at runtime var logger = Resolve <ILogger>(); _watcher = new DirectoryWatcher(logger, directory, filter); _subscription = _watcher.Events .Where(e => e.Type == FileChangedEvent.Ready || e.Type == FileChangedEvent.Removed) .ObserveOn(new EventLoopScheduler()) .Subscribe(OnDependencyChanged); _watcherTask = _watcher.Watch(); }
public void SetListeners(DirectoryWatcher watcher) { watcher.OnDirectoryChanged += OnDirectoryChanged; watcher.OnFileChanged += OnFileChanged; watcher.OnDeleted += OnDeleted; Watchers.Add(watcher); }
public void SetUp() { _messageBus = MockRepository.GenerateMock<IMessageBus>(); _validator = MockRepository.GenerateMock<IWatchValidator>(); _watcher = new DirectoryWatcher(_messageBus, _validator); _file = Path.GetFullPath("watcher_test.txt"); _watcher.Watch(Path.GetDirectoryName(_file)); }
public void TestMethod1() { var watcher = DirectoryWatcher.Listen(@"C:\Users\PC user\Desktop\1"); System.Threading.Tasks.Task.Delay(20000).Wait(); watcher.Dispose(); }
public DirectoryWatcherTests() { tempDirectory = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}"); watcherTempDirectory = Path.Combine(tempDirectory, $"{Guid.NewGuid():N}"); Directory.CreateDirectory(watcherTempDirectory); fileWatcherDispatcher = new FileWatcherDispatcher(); directoryWatcher = new DirectoryWatcher(watcherTempDirectory, fileWatcherDispatcher); }
public KsAnimAnimator(string filename, float duration, bool skipFixed) { _duration = duration; _skipFixed = skipFixed; _filename = filename; _original = File.Exists(_filename) ? KsAnim.FromFile(_filename) : KsAnim.CreateEmpty(); _watcher = DirectoryWatcher.WatchFile(filename, Reload); }
public ViewModel(IFilter <RaceResultsObject> filter, List <RaceResultsObject> entries) { _filter = filter; Entries = new ChangeableObservableCollection <RaceResultsObject>(entries); Entries.ItemPropertyChanged += OnPropertyChanged; _watcher = new DirectoryWatcher(RaceResultsStorage.Instance.SessionsDirectory); _watcher.Update += OnUpdate; }
public static void CreateLuaFileWatcher(LuaState luaState, string scriptPath) { var directoryWatcher = new DirectoryWatcher(scriptPath, new FileSystemEventHandler(LuaFileOnChanged)); reloadFunc = luaState.GetFunction("HotReload"); EditorApplication.update -= Reload; EditorApplication.update += Reload; }
public void Initialize(string dataDirectory) { _directory = Path.Combine(dataDirectory, "Replacements"); FileUtils.EnsureDirectoryExists(_directory); _watcher = DirectoryWatcher.WatchDirectory(_directory, Reload); Reload(null); }
public ViewModel(string directory, IFilter <FileInfo> filter, IEnumerable <Screenshot> screenshots) { Screenshots = new ChangeableObservableCollection <Screenshot>(screenshots); Screenshots.ItemPropertyChanged += OnPropertyChanged; _directory = directory; _filter = filter; _watcher = new DirectoryWatcher(directory); _watcher.Update += OnUpdate; }
public static void CreateLuaFileWatcher(LuaEnv luaEnv) { var scriptPath = Path.Combine(Application.dataPath, PrePath); DirectoryWatcher.CreateWatch(scriptPath, new FileSystemEventHandler(OnLuaFileChanged)); _reloadFunction = luaEnv.Global.Get <ReloadDelegate>("hotfix"); EditorApplication.update -= Reload; EditorApplication.update += Reload; }
public Service1() { InitializeComponent(); VescoLog vl = new VescoLog(); Properties props = new Properties(); DirectoryWatcher watcher = new DirectoryWatcher(); GmailWatcher gw = new GmailWatcher(); }
public void DirectoryWatcherConstructorTest() { var watcher = new DirectoryWatcher(TestContext.TestDir); watcher.UnsubscribeEvents(); Assert.AreEqual(watcher._directory, TestContext.TestDir); Assert.AreEqual(watcher.LastChangeEvent, DateTime.Today); }
public void Should_not_start_watch_when_folder_is_invalid() { var bus = MockRepository.GenerateMock<IMessageBus>(); var config = MockRepository.GenerateMock<IConfiguration>(); config.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(bus, null, config); watcher.Watch(""); bus.AssertWasNotCalled(m => m.Publish<InformationMessage>(null), m => m.IgnoreArguments()); }
public void Should_not_start_watch_when_folder_is_invalid() { var bus = MockRepository.GenerateMock<IMessageBus>(); var config = MockRepository.GenerateMock<IConfiguration>(); config.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(bus, null, config, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); watcher.Watch(""); bus.AssertWasNotCalled(m => m.Publish<InformationMessage>(null), m => m.IgnoreArguments()); }
public void SetUp() { _messageBus = MockRepository.GenerateMock<IMessageBus>(); _validator = MockRepository.GenerateMock<IWatchValidator>(); _configuration = MockRepository.GenerateMock<IConfiguration>(); _validator.Stub(v => v.GetIgnorePatterns()).Return(""); _configuration.Stub(c => c.FileChangeBatchDelay).Return(50); _watcher = new DirectoryWatcher(_messageBus, _validator, _configuration); _file = Path.GetFullPath("watcher_test.txt"); _watchDirectory = Path.GetDirectoryName(_file); _watcher.Watch(_watchDirectory); }
public static void Initialize() { if (!(Utilites.IsNullOrEmpty(Properties.Settings.Default.FTPUploadPath) || Utilites.IsNullOrEmpty(Properties.Settings.Default.FTPAddress) || Utilites.IsNullOrEmpty(Properties.Settings.Default.FTPUsername))) { var credentials = new NetworkCredential(Properties.Settings.Default.FTPUsername, Utilites.StringCipher.Decrypt(Properties.Settings.Default.FTPPassword, "TorrentFlow")); ftpClient = new FTPClient(); var host = Properties.Settings.Default.FTPAddress; if (!host.StartsWith("ftp://")) { host = "ftp://" + host; } if (Properties.Settings.Default.FTPPort != 0) { host = String.Format("{0}:{1}", host, Properties.Settings.Default.FTPPort.ToString()); } ftpClient.Host = host; ftpClient.Credentials = credentials; ftpClient.EncryptionMode = Properties.Settings.Default.FTPEncryptionMode; } else { pi.Notify("Not Uploading", "No FTP server configured.", 3000); } if (!Utilites.IsNullOrEmpty(Properties.Settings.Default.WatchDirectory)) { watcher = new DirectoryWatcher(Properties.Settings.Default.WatchDirectory, NewTorrentFileDetected, NotifyFilters.LastWrite | NotifyFilters.CreationTime); watcher.SetFilter("*.torrent"); watcher.Start(); } else { pi.Notify("Not Watching", "TorrentFlow is not watching for torrent files.", 3000); } if (!Utilites.IsNullOrEmpty(Properties.Settings.Default.DownloadDirectory)) { //ftpClient.DownloadStatusChanged += OnDownloadStatusChanged; StartTimer(); } else { pi.Notify("Not Downloading", "TorrentFlow will not download any files.", 3000); } }
public void SetUp() { _messageBus = MockRepository.GenerateMock<IMessageBus>(); _validator = MockRepository.GenerateMock<IWatchValidator>(); _configuration = MockRepository.GenerateMock<IConfiguration>(); _validator.Stub(v => v.GetIgnorePatterns()).Return(""); _configuration.Stub(c => c.FileChangeBatchDelay).Return(50); _watcher = new DirectoryWatcher(_messageBus, _validator, _configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>()); _file = Path.GetFullPath("watcher_test.txt"); _directory = Path.GetFullPath("mytestfolder"); _watchDirectory = Path.GetDirectoryName(_file); _localConfig = Path.Combine(_watchDirectory, "AutoTest.config"); File.WriteAllText(_localConfig, "<configuration></configuration>"); _watcher.Watch(_watchDirectory); }
public void AddFile(string filePath, EventHandler handler) { string dir = Path.GetDirectoryName(filePath).ToLower(); string fileName = Path.GetFileName(filePath).ToLower(); DirectoryWatcher watcher; lock (dirsLock) { if (!directories.TryGetValue(dir, out watcher)) { watcher = new DirectoryWatcher(dir); directories.Add(dir, watcher); } } watcher.AddFile(fileName, handler); }
public static void Initialize() { ftp = new FTPClient(Properties.Settings.Default.FTPAddress, Properties.Settings.Default.FTPUsername, StringCipher.Decrypt(Properties.Settings.Default.FTPPassword, "TorrentFlow")); if (!Utilites.IsNullOrEmpty(Properties.Settings.Default.WatchDirectory)){ watcher = new DirectoryWatcher(Properties.Settings.Default.WatchDirectory, NewTorrentFileDetected, NotifyFilters.LastWrite); watcher.SetFilter("*.torrent"); watcher.Start(); } else { pi.Notify("Not Watching", "TorrentFlow is not watching for torrent files.", 5000); } if (!Utilites.IsNullOrEmpty(Properties.Settings.Default.DownloadDirectory)) { StartTimer(); } else { pi.Notify("Not Downloading", "Torrentflow will not download any files.", 5000); } }
public override void Initialize() { base.Initialize(); isInitialized = true; // Get graphics device service graphicsDeviceService = Services.GetSafeServiceAs<IGraphicsDeviceService>(); #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP Enabled = true; directoryWatcher = new DirectoryWatcher("*.xksl"); directoryWatcher.Modified += FileModifiedEvent; // TODO: xkfx too #endif // Make sure default compiler is created (local if possible otherwise none) if nothing else was explicitely set/requested (i.e. by GameSettings) if (Compiler == null) Compiler = CreateEffectCompiler(); }
public ViewModel(WidgetId guid) : base(guid) { Settings = guid.GetSettings() as Settings; if (Settings == null) return; switch (Settings.ResumeOnStartMode) { case ResumeOnStartMode.Auto: if (Settings.ResumeOnNextStart) { Settings.Paused = false; Settings.ResumeOnNextStart = false; } break; case ResumeOnStartMode.Resume: Settings.Paused = false; break; } IsPaused = Settings.Paused; if (Settings.CurrentFile != null && !Settings.FileHistory.Contains(Settings.CurrentFile)) Settings.FileHistory.Add(Settings.CurrentFile); CurrentFile = Settings.CurrentFile; OpenFile = new RelayCommand(OpenFileExecute); TogglePlayPause = new RelayCommand(TogglePlayPauseExecute); Next = new RelayCommand(NextExecute); Previous = new RelayCommand(PreviousExecute); _resumeTimer = new DispatcherTimer(); _resumeTimer.Tick += (sender, args) => { Unpause(); }; _directoryWatcher = new DirectoryWatcher(Settings.DirectoryWatcherSettings, AddToFileQueue); _directoryWatcher.Start(); CheckFile(false); }
protected override void OnStart(string[] args) { this.ReadSettings(); Debug.Listeners.Add( new VanLeeuwen.Framework.Diagnostics.LogFileTraceListener( Parameters_DataProcessor.LogFolder, "Van Leeuwen WebPortal DataProcessor Service", VanLeeuwen.Framework.Logging.Logger.LogFileSettings.LogFilePerDay, VanLeeuwen.Framework.Logging.Logger.LogFolderSettings.LogFolderPerYear | VanLeeuwen.Framework.Logging.Logger.LogFolderSettings.LogFolderPerMonth, VanLeeuwen.Framework.Logging.Logger.TimeStamps.DateTime)); Trace.WriteLine("-------------------------------------------------------------------"); Trace.WriteLine("Started Van Leeuwen WebPortal DataProcessor Service...", "OnStart"); Trace.WriteLine("-------------------------------------------------------------------"); Trace.WriteLine(String.Format("Version: {0}", Assembly.GetExecutingAssembly().GetName().Version.ToString()), "OnStart"); Trace.WriteLine("Logger attached", "OnStart"); this.LogSettingsRead(); directoryWatcher = new DirectoryWatcher(); directoryWatcher.Start(); }
public void SetUp() { _launcer = MockRepository.GenerateMock<IApplicatonLauncher>(); _messageBus = MockRepository.GenerateMock<IMessageBus>(); _validator = MockRepository.GenerateMock<IWatchValidator>(); _configuration = MockRepository.GenerateMock<IConfiguration>(); _pathLocator = MockRepository.GenerateMock<IWatchPathLocator>(); _cahce = MockRepository.GenerateMock<ICache>(); _slnConsumer = MockRepository.GenerateMock<ISolutionChangeConsumer>(); _rebuildMarker = MockRepository.GenerateMock<IMarkProjectsForRebuild>(); _configuration.Stub(x => x.IgnoreFile).Return(""); _validator.Stub(v => v.GetIgnorePatterns()).Return(""); _configuration.Stub(c => c.FileChangeBatchDelay).Return(50); _configuration.Stub(c => c.WatchAllFiles).Return(true); _configuration.Stub(c => c.WatchToken).Return(_watchDirectory); _watcher = new DirectoryWatcher(_messageBus, _validator, _configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); _file = Path.GetFullPath("watcher_test.txt"); _directory = Path.GetFullPath("mytestfolder"); _watchDirectory = Path.GetDirectoryName(_file); _pathLocator.Stub(x => x.Locate(_watchDirectory)).Return(_watchDirectory); _localConfig = new PathTranslator(_watchDirectory).Translate(Path.Combine(_watchDirectory, "AutoTest.config")); File.WriteAllText(_localConfig, "<configuration></configuration>"); _watcher.Watch(_watchDirectory); }
/// <summary> /// For derived class implementers. /// <para>This method is called with argument true when class user calls Dispose(), while with argument false when /// the Garbage Collector invokes the finalizer, or Finalize() method.</para> /// <para>You must reclaim all used unmanaged resources in both cases, and can use this chance to call Dispose on disposable fields if the argument is true.</para> /// <para>Also, you must call the base virtual method within your overriding method.</para> /// </summary> /// <param name="disposing">true if the call comes from the Dispose() method; false if it comes from the Garbage Collector finalizer.</param> protected virtual void Dispose(bool disposing) { // Free managed resources...but only if called from Dispose // (If called from Finalize then the objects might not exist anymore) if (disposing) { DocumentsDirectoryWatcher.Invalidate (); DocumentsDirectoryWatcher = null; DocumentsDirectoryChangedDelegate = null; Changed = null; } }
private static void AddDirectoryListener(IDirectoryListener listener) { if (_watcher == null) { _watcher = new DirectoryWatcher(FileUtils.GetCarSetupsDirectory()); _watcher.Subscribe(new InternalListener()); Logging.Write("[CarSetupsDirectories.InternalListener] Start watching…"); } Listeners.Purge(); Listeners.Add(listener); }
public void TestDirectory() { var tempDirectory = new DirectoryInfo("Temp." + typeof(TestWatcher).Assembly.GetName().Name); RemoveDirectory(tempDirectory); if (!tempDirectory.Exists) { tempDirectory.Create(); } var pa0 = GetDirectoryPath(tempDirectory, @"a0"); var pb0 = GetDirectoryPath(tempDirectory, @"a0\b0"); var p1 = CreateDirectoryPath(tempDirectory, @"a0\b0\c0"); var p2 = CreateDirectoryPath(tempDirectory, @"a0\b0\c1"); var p3 = CreateDirectoryPath(tempDirectory, @"a0\b0\c2"); var watcher = new DirectoryWatcher(); watcher.Track(p1); var list = watcher.GetTrackedDirectories(); Assert.AreEqual(1, list.Count); Assert.AreEqual(p1, list[0]); watcher.Track(p2); list = watcher.GetTrackedDirectories(); Assert.AreEqual(2, list.Count); Assert.AreEqual(p1, list[0]); Assert.AreEqual(p2, list[1]); // Adding p3 should set the track on the parent directory watcher.Track(p3); list = watcher.GetTrackedDirectories(); Assert.AreEqual(1, list.Count); Assert.AreEqual(pb0, list[0]); // Tracking again a child should not add a new track as the parent is already tracking watcher.Track(p1); list = watcher.GetTrackedDirectories(); Assert.AreEqual(1, list.Count); Assert.AreEqual(pb0, list[0]); watcher.Track(pb0); list = watcher.GetTrackedDirectories(); Assert.AreEqual(1, list.Count); Assert.AreEqual(pb0, list[0]); var events = new List<FileEvent>(); EventHandler<FileEvent> fileEventHandler = (sender, args) => events.Add(args); watcher.Modified += fileEventHandler; var p4 = CreateDirectoryPath(tempDirectory, @"a0\b0\c3"); Thread.Sleep(20); watcher.Modified -= fileEventHandler; Assert.AreEqual(1, events.Count); Assert.AreEqual(p4, events[0].FullPath.ToLower()); events.Clear(); watcher.Modified += fileEventHandler; RemoveDirectory(new DirectoryInfo(pb0)); Thread.Sleep(400); watcher.Modified -= fileEventHandler; Assert.IsTrue(events.All(args => args.ChangeType == FileEventChangeType.Deleted)); // c0, c1, c2, c3 removed //// We should not track any directory //list = watcher.GetTrackedDirectories(); //Assert.AreEqual(0, list.Count); RemoveDirectory(tempDirectory); }
private void DoOnOpenDir(string name, object value) { Boss boss = (Boss) value; if (boss == m_boss) { var editor = boss.Get<IDirectoryEditor>(); if (!m_watchers.Any(w => Paths.AreEqual(w.Path, editor.Path))) { var watcher = new DirectoryWatcher(editor.Path, TimeSpan.FromMilliseconds(100)); watcher.Changed += this.DoDirChanged; m_watchers.Add(watcher); } DoAddFiles(editor.Path); } }
public void When_config_setting_start_paused_is_set_pause_watcher() { var messageBus = MockRepository.GenerateMock<IMessageBus>(); var validator = MockRepository.GenerateMock<IWatchValidator>(); var configuration = MockRepository.GenerateMock<IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); validator.Stub(v => v.ShouldPublish(null)).IgnoreArguments().Return(true).Repeat.Any(); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); configuration.Stub(c => c.StartPaused).Return(true); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator); var file = Path.GetFullPath("start_as_paused.txt"); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); File.WriteAllText(file, "meh "); Thread.Sleep(450); messageBus.AssertWasNotCalled(m => m.Publish<FileChangeMessage>(null), m => m.IgnoreArguments()); }
public void When_setting_wath_path_it_should_initialize_application_launcher() { var messageBus = MockRepository.GenerateMock<IMessageBus>(); var validator = MockRepository.GenerateMock<IWatchValidator>(); var configuration = MockRepository.GenerateMock<IConfiguration>(); var launcher = MockRepository.GenerateMock<IApplicatonLauncher>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); validator.Stub(v => v.ShouldPublish(null)).IgnoreArguments().Return(true).Repeat.Any(); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); configuration.Stub(c => c.StartPaused).Return(true); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator, launcher, _cahce, _rebuildMarker, _slnConsumer); var watchDirectory = Path.GetDirectoryName(Path.GetFullPath("somefile.txt")); watcher.Watch(watchDirectory); launcher.AssertWasCalled(x => x.Initialize(watchDirectory)); }
public void Should_always_publish_fs_project_files() { var messageBus = MockRepository.GenerateMock<IMessageBus>(); var validator = MockRepository.GenerateMock<IWatchValidator>(); var configuration = MockRepository.GenerateMock<IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); validator.Stub(v => v.ShouldPublish(null)).IgnoreArguments().Return(true).Repeat.Any(); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); var file = Path.GetFullPath("some_project_file_for_detection.fsproj"); _cahce.Stub(c => c.Get<Project>(file)).Return(new Project("", new ProjectDocument(ProjectType.FSharp))); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); watcher.Pause(); watcher.Resume(); File.WriteAllText(file, "meh "); Thread.Sleep(450); messageBus.AssertWasCalled(m => m.Publish<FileChangeMessage>(null), m => m.IgnoreArguments()); }
public void Should_not_publish_pusblish_files_not_listed_in_cache() { var messageBus = MockRepository.GenerateMock<IMessageBus>(); var validator = MockRepository.GenerateMock<IWatchValidator>(); var configuration = MockRepository.GenerateMock<IConfiguration>(); configuration.Stub(x => x.IgnoreFile).Return(""); validator.Stub(v => v.GetIgnorePatterns()).Return(""); validator.Stub(v => v.ShouldPublish(null)).IgnoreArguments().Return(true).Repeat.Any(); configuration.Stub(c => c.FileChangeBatchDelay).Return(50); var watcher = new DirectoryWatcher(messageBus, validator, configuration, MockRepository.GenerateMock<IHandleDelayedConfiguration>(), _pathLocator, _launcer, _cahce, _rebuildMarker, _slnConsumer); var file = Path.GetFullPath("not_detection_when_paused.txt"); var watchDirectory = Path.GetDirectoryName(file); watcher.Watch(watchDirectory); watcher.Pause(); watcher.Resume(); File.WriteAllText(file, "meh "); Thread.Sleep(450); messageBus.AssertWasNotCalled(m => m.Publish<FileChangeMessage>(null), m => m.IgnoreArguments()); }
/// <summary> /// Resets the DirectoryWatcher to watch a different path /// </summary> private void ResetWatcher() { try { DocumentsDirectoryWatcher.Invalidate(); DocumentsDirectoryWatcher = DirectoryWatcher.WatchFolderWithPath (Path, DocumentsDirectoryChangedDelegate); } catch (Exception ex) { Console.WriteLine (ex.Message); } }