1. import java.io.*;
  2. import java.nio.file.*;
  3. import java.util.concurrent.Executors;
  4. import java.util.concurrent.ScheduledExecutorService;
  5. import java.util.concurrent.TimeUnit;
  7. public class ConfigWatcher {
  9. private final Path configFilePath;
  10. private final FileSystem fileSystem;
  11. private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
  12. private boolean running = true;
  14. public ConfigWatcher(Path configFilePath) {
  15. this.configFilePath = configFilePath;
  16. this.fileSystem = FileSystems.newFileSystem(configFilePath, new java.util.Properties());
  17. }
  20. public void start() {
  21. scheduler.scheduleAtFixedRate(this::checkConfigChanges, 0, 5, TimeUnit.SECONDS); // Check every 5 seconds
  22. }
  24. public void stop() {
  25. running = false;
  26. scheduler.shutdown();
  27. try {
  28. scheduler.awaitTermination(5, TimeUnit.SECONDS); //wait for tasks to complete
  29. } catch (InterruptedException e) {
  30. Thread.currentThread().interrupt();
  31. }
  32. fileSystem.close();
  33. }
  36. private void checkConfigChanges() {
  37. try {
  38. if (!running) return; //Exit if stopped
  40. Path configPath = configFilePath;
  41. try (InputStream inputStream = fileSystem.open(configPath);
  42. BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
  44. String currentContent = reader.lines().toString();
  46. // Simulate reading the previous content (in a real scenario, this would load from a persistent store)
  47. String previousContent = loadPreviousContent();
  49. if (!currentContent.equals(previousContent)) {
  50. System.out.println("Configuration file changed: " + configFilePath);
  51. // Perform data migration logic here
  52. performDataMigration();
  53. previousContent = currentContent; // Update previous content
  54. }
  55. } catch (IOException e) {
  56. System.err.println("Error reading configuration file: " + e.getMessage());
  57. }
  58. } catch (Exception e) {
  59. System.err.println("An unexpected error occurred: " + e.getMessage());
  60. }
  61. }
  63. private String loadPreviousContent() {
  64. //In a real application, this would load the previous content from a file or database.
  65. //For this example, we just return an empty string.
  66. return "";
  67. }
  69. private void performDataMigration() {
  70. System.out.println("Performing data migration...");
  71. //Add data migration code here.
  72. try {
  73. // Simulate data migration
  74. Thread.sleep(2000);
  75. System.out.println("Data migration complete.");
  76. } catch (InterruptedException e) {
  77. Thread.currentThread().interrupt();
  78. }
  79. }
  82. public static void main(String[] args) throws IOException {
  83. if (args.length != 1) {
  84. System.out.println("Usage: java ConfigWatcher <config_file_path>");
  85. System.exit(1);
  86. }
  88. Path configFilePath = Paths.get(args[0]);
  90. try (FileSystem fs = FileSystems.newFileSystem(configFilePath, new java.util.Properties())) {
  91. ConfigWatcher watcher = new ConfigWatcher(configFilePath);
  92. watcher.start();
  94. Runtime.getRuntime().addShutdownHook(new Thread(() -> {
  95. System.out.println("Shutting down ConfigWatcher...");
  96. watcher.stop();
  97. System.out.println("ConfigWatcher stopped.");
  98. }));
  100. while (true) {
  101. try {
  102. Thread.sleep(1000);
  103. } catch (InterruptedException e) {
  104. Thread.currentThread().interrupt();
  105. break;
  106. }
  107. }
  108. }
  109. }
  110. }

Add your comment