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));
}
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 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);
}
}
