PageRenderTime 45ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/src/NUnit/util/AssemblyWatcher.cs

#
C# | 163 lines | 124 code | 26 blank | 13 comment | 15 complexity | 4d64b93020299e123371b2394319f948 MD5 | raw file
Possible License(s): GPL-2.0
  1. // ****************************************************************
  2. // This is free software licensed under the NUnit license. You
  3. // may obtain a copy of the license as well as information regarding
  4. // copyright ownership at http://nunit.org.
  5. // ****************************************************************
  6. using System;
  7. using System.IO;
  8. using System.Timers;
  9. using NUnit.Core;
  10. namespace NUnit.Util
  11. {
  12. /// <summary>
  13. /// AssemblyWatcher keeps track of one or more assemblies to
  14. /// see if they have changed. It incorporates a delayed notification
  15. /// and uses a standard event to notify any interested parties
  16. /// about the change. The path to the assembly is provided as
  17. /// an argument to the event handler so that one routine can
  18. /// be used to handle events from multiple watchers.
  19. /// </summary>
  20. public class AssemblyWatcher : IAssemblyWatcher
  21. {
  22. static Logger log = InternalTrace.GetLogger(typeof(AssemblyWatcher));
  23. private FileSystemWatcher[] fileWatchers;
  24. private FileInfo[] files;
  25. private bool isWatching;
  26. protected System.Timers.Timer timer;
  27. protected string changedAssemblyPath;
  28. protected FileInfo GetFileInfo(int index)
  29. {
  30. return files[index];
  31. }
  32. public void Setup(int delay, string assemblyFileName)
  33. {
  34. Setup(delay, new string[] {assemblyFileName});
  35. }
  36. #if NET_2_0 || NET_4_0
  37. public void Setup(int delay, System.Collections.Generic.IList<string> assemblies)
  38. #else
  39. public void Setup(int delay, System.Collections.IList assemblies)
  40. #endif
  41. {
  42. log.Info("Setting up watcher");
  43. files = new FileInfo[assemblies.Count];
  44. fileWatchers = new FileSystemWatcher[assemblies.Count];
  45. for (int i = 0; i < assemblies.Count; i++)
  46. {
  47. log.Debug("Setting up FileSystemWatcher for {0}", assemblies[i]);
  48. files[i] = new FileInfo((string)assemblies[i]);
  49. fileWatchers[i] = new FileSystemWatcher();
  50. fileWatchers[i].Path = files[i].DirectoryName;
  51. fileWatchers[i].Filter = files[i].Name;
  52. fileWatchers[i].NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite;
  53. fileWatchers[i].Changed += new FileSystemEventHandler(OnChanged);
  54. fileWatchers[i].EnableRaisingEvents = false;
  55. }
  56. timer = new System.Timers.Timer(delay);
  57. timer.AutoReset = false;
  58. timer.Enabled = false;
  59. timer.Elapsed += new ElapsedEventHandler(OnTimer);
  60. }
  61. public void Start()
  62. {
  63. EnableWatchers( true );
  64. }
  65. public void Stop()
  66. {
  67. EnableWatchers( false );
  68. }
  69. private void EnableWatchers( bool enable )
  70. {
  71. if (fileWatchers != null)
  72. foreach( FileSystemWatcher watcher in fileWatchers )
  73. watcher.EnableRaisingEvents = enable;
  74. isWatching = enable;
  75. }
  76. public void FreeResources()
  77. {
  78. log.Info("FreeResources");
  79. Stop();
  80. if (fileWatchers != null)
  81. {
  82. foreach (FileSystemWatcher watcher in fileWatchers)
  83. {
  84. if (watcher != null)
  85. {
  86. watcher.Changed -= new FileSystemEventHandler(OnChanged);
  87. watcher.Dispose();
  88. }
  89. }
  90. }
  91. if (timer != null)
  92. {
  93. timer.Stop();
  94. timer.Close();
  95. }
  96. fileWatchers = null;
  97. timer = null;
  98. }
  99. public event AssemblyChangedHandler AssemblyChanged;
  100. protected void OnTimer(Object source, ElapsedEventArgs e)
  101. {
  102. lock(this)
  103. {
  104. log.Info("Timer expired");
  105. PublishEvent();
  106. timer.Enabled=false;
  107. }
  108. }
  109. protected void OnChanged(object source, FileSystemEventArgs e)
  110. {
  111. log.Info("File {0} changed", e.Name);
  112. changedAssemblyPath = e.FullPath;
  113. if ( timer != null )
  114. {
  115. lock(this)
  116. {
  117. if(!timer.Enabled)
  118. timer.Enabled=true;
  119. log.Info("Setting timer");
  120. timer.Start();
  121. }
  122. }
  123. else
  124. {
  125. PublishEvent();
  126. }
  127. }
  128. protected void PublishEvent()
  129. {
  130. if (AssemblyChanged != null)
  131. {
  132. log.Debug("Publishing Event to {0} listeners", AssemblyChanged.GetInvocationList().Length);
  133. AssemblyChanged(changedAssemblyPath);
  134. }
  135. }
  136. }
  137. }