1. import java.io.File;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import java.util.concurrent.ConcurrentHashMap;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.ScheduledExecutorService;
  7. import java.util.concurrent.TimeUnit;
  9. public class DirectoryMonitor {
  11. private final Map<String, Long> lastChecked = new ConcurrentHashMap<>(); // Directory path -> last checked timestamp
  12. private final Map<String, Long> rateLimit = new ConcurrentHashMap<>(); // Directory path -> rate limit info
  13. private final long checkIntervalSeconds;
  14. private final int maxChecksPerSecond;
  15. private final ScheduledExecutorService scheduler;
  17. public DirectoryMonitor(long checkIntervalSeconds, int maxChecksPerSecond) {
  18. this.checkIntervalSeconds = checkIntervalSeconds;
  19. this.maxChecksPerSecond = maxChecksPerSecond;
  20. this.scheduler = Executors.newSingleThreadScheduledExecutor();
  21. }
  23. public void start() {
  24. scheduler.scheduleAtFixedRate(this::checkDirectories, 0, checkIntervalSeconds, TimeUnit.SECONDS);
  25. }
  27. public void stop() {
  28. scheduler.shutdown();
  29. }
  32. private void checkDirectories() {
  33. File rootDir = new File("."); // Monitor current directory by default
  34. checkDirectory(rootDir);
  35. }
  38. public void checkDirectory(File dir) {
  39. try {
  40. if (!dir.exists()) {
  41. System.err.println("Directory does not exist: " + dir.getAbsolutePath());
  42. return; // Don't repeatedly check non-existent directories
  43. }
  45. long now = System.currentTimeMillis();
  46. String dirPath = dir.getAbsolutePath();
  48. // Rate limiting
  49. if (rateLimit.containsKey(dirPath)) {
  50. long lastCheckTime = rateLimit.get(dirPath);
  51. long timeSinceLastCheck = now - lastCheckTime;
  53. if (timeSinceLastCheck < 1000 / maxChecksPerSecond) { // Allow checks at most 1/maxChecksPerSecond seconds apart
  54. return; // Skip check if rate limit is exceeded
  55. }
  56. }
  58. // Actual directory check
  59. File[] files = dir.listFiles();
  60. if (files != null) {
  61. for (File file : files) {
  62. if (file.isDirectory()) {
  63. checkDirectory(file); // Recursive check
  64. } else {
  65. System.out.println("File changed: " + file.getAbsolutePath()); //Example change detection
  66. }
  67. }
  68. } else {
  69. System.out.println("Directory changed: " + dir.getAbsolutePath());//Example change detection
  70. }
  73. // Update last checked timestamp and rate limit
  74. lastChecked.put(dirPath, now);
  75. rateLimit.put(dirPath, now);
  76. } catch (Exception e) {
  77. System.err.println("Error checking directory " + dir.getAbsolutePath() + ": " + e.getMessage());
  78. }
  79. }
  81. public static void main(String[] args) throws InterruptedException {
  82. DirectoryMonitor monitor = new DirectoryMonitor(5, 10); //Check every 5 seconds, limit to 10 checks/second
  83. monitor.start();
  85. Thread.sleep(60000); // Run for 60 seconds
  87. monitor.stop();
  88. }
  89. }

Add your comment