@arela/uploader 0.2.12 → 0.3.0

package/src/services/WatchService.js

@@ -0,0 +1,783 @@
+import chokidar from 'chokidar';
+import fs from 'fs';
+import path from 'path';
+
+import watchEventHandler from '../utils/WatchEventHandler.js';
+import autoProcessingService from './AutoProcessingService.js';
+import { databaseService } from './DatabaseService.js';
+import logger from './LoggingService.js';
+import SmartWatchDatabaseService from './SmartWatchDatabaseService.js';
+
+/**
+ * WatchService - Monitors directories for file changes and triggers uploads
+ * Provides watch functionality with debouncing, multiple watchers, and event handling
+ * Integrated with SmartWatchDatabaseService for intelligent file queuing
+ */
+export class WatchService {
+  constructor() {
+    this.watchers = new Map(); // Map of directory -> watcher instance
+    this.watchedDirs = new Set(); // Set of watched directories
+    this.directoryConfigs = new Map(); // Map of directory -> configuration (path, folderStructure)
+    this.eventQueue = new Map(); // Queue of pending events with debounce
+    this.debounceTimers = new Map(); // Timers for debouncing
+    this.isRunning = false;
+    this.isWatchModeActive = false; // Flag to prevent direct uploads while watching
+    this.autoProcessingEnabled = false;
+    this.processingOptions = {};
+    this.watcherReady = new Map(); // Map of directory -> ready status (to ignore initial scan)
+    this.allWatchersReady = false; // Flag to indicate ALL initial scans are complete
+
+    // Watch mode state file (for inter-process communication)
+    this.watchStateFile = path.join(process.cwd(), '.watch-mode.lock');
+
+    // Smart Watch Queue Integration
+    this.smartWatchDb = new SmartWatchDatabaseService(databaseService);
+    this.queueStats = {
+      filesPending: 0,
+      filesReady: 0,
+      filesProcessing: 0,
+      filesUploaded: 0,
+      filesFailed: 0,
+    };
+
+    // File detection for pedimento simplificado
+    this.pedimentoPattern = /simplif|simple/i;
+
+    // Pipeline debouncing by directory to avoid conflicts
+    // When multiple files are detected in same dir, batch them together
+    this.pipelineDebounceTimers = new Map(); // Map of dirPath -> debounce timer
+    this.pipelineBatchSize = 500; // ms to wait before processing a directory batch
+    this.activePipelines = new Set(); // Track which directories have pipelines running
+
+    this.stats = {
+      filesAdded: 0,
+      filesModified: 0,
+      filesRemoved: 0,
+      uploadsTriggered: 0,
+      pipelinesTriggered: 0,
+      errorsEncountered: 0,
+    };
+  }
+
+  /**
+   * Initialize watcher for a directory
+   * @param {string} dirPath - Directory to watch
+   * @param {Object} options - Watcher options
+   * @param {Object} dirConfig - Directory configuration (path, folderStructure, etc)
+   * @returns {Promise<void>}
+   */
+  async addWatcher(dirPath, options = {}, dirConfig = {}) {
+    try {
+      // Validate directory path
+      if (!dirPath) {
+        throw new Error('Directory path is required');
+      }
+
+      const normalizedPath = path.resolve(dirPath);
+
+      // Check if already watching
+      if (this.watchedDirs.has(normalizedPath)) {
+        logger.warn(`Directory already being watched: ${normalizedPath}`);
+        return;
+      }
+
+      // Default watcher options
+      const watcherOptions = {
+        persistent: true,
+        ignored: /(^|[\/\\])\.|node_modules|\.git/, // Ignore hidden files and common dirs
+        ignoreInitial: true, // Don't trigger events for files found during initial scan
+        awaitWriteFinish: {
+          stabilityThreshold: options.stabilityThreshold || 300,
+          pollInterval: options.pollInterval || 100,
+        },
+        usePolling: options.usePolling || false,
+        interval: options.interval || 100,
+        binaryInterval: options.binaryInterval || 300,
+        ...options,
+      };
+
+      logger.info(`Initializing watcher for: ${normalizedPath}`);
+
+      // Create watcher
+      const watcher = chokidar.watch(normalizedPath, watcherOptions);
+
+      // Setup event handlers
+      watcher
+        .on('add', (filePath) => this.#handleFileAdded(filePath))
+        .on('change', (filePath) => this.#handleFileChanged(filePath))
+        .on('unlink', (filePath) => this.#handleFileRemoved(filePath))
+        .on('addDir', (dirPath) => this.#handleDirAdded(dirPath))
+        .on('unlinkDir', (dirPath) => this.#handleDirRemoved(dirPath))
+        .on('error', (error) => this.#handleWatcherError(error))
+        .on('ready', () => {
+          logger.info(`Watcher ready for: ${normalizedPath}`);
+          this.watcherReady.set(normalizedPath, true);
+        });
+
+      // Store watcher and configuration
+      this.watchers.set(normalizedPath, watcher);
+      this.watchedDirs.add(normalizedPath);
+      this.directoryConfigs.set(normalizedPath, {
+        path: normalizedPath,
+        folderStructure: dirConfig.folderStructure || 'default',
+        ...dirConfig,
+      });
+
+      logger.info(`✅ Watcher added for: ${normalizedPath}`);
+    } catch (error) {
+      logger.error(`Failed to add watcher for ${dirPath}: ${error.message}`);
+      this.stats.errorsEncountered++;
+      throw error;
+    }
+  }
+
+  /**
+   * Remove watcher for a directory
+   * @param {string} dirPath - Directory to stop watching
+   * @returns {Promise<void>}
+   */
+  async removeWatcher(dirPath) {
+    try {
+      const normalizedPath = path.resolve(dirPath);
+
+      if (!this.watchedDirs.has(normalizedPath)) {
+        logger.warn(`Directory not being watched: ${normalizedPath}`);
+        return;
+      }
+
+      const watcher = this.watchers.get(normalizedPath);
+      if (watcher) {
+        await watcher.close();
+        this.watchers.delete(normalizedPath);
+        this.watchedDirs.delete(normalizedPath);
+        this.directoryConfigs.delete(normalizedPath);
+        this.watcherReady.delete(normalizedPath);
+        logger.info(`✅ Watcher removed for: ${normalizedPath}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to remove watcher for ${dirPath}: ${error.message}`);
+      this.stats.errorsEncountered++;
+      throw error;
+    }
+  }
+
+  /**
+   * Start watching all configured directories
+   * @returns {Promise<void>}
+   */
+  async start() {
+    try {
+      if (this.isRunning) {
+        logger.warn('WatchService is already running');
+        return;
+      }
+
+      this.isRunning = true;
+      this.isWatchModeActive = true; // Prevent direct uploads while watching
+
+      // Create watch mode state file for inter-process communication
+      try {
+        fs.writeFileSync(
+          this.watchStateFile,
+          JSON.stringify({
+            started: new Date().toISOString(),
+            pid: process.pid,
+            timestamp: Date.now(),
+          }),
+        );
+        logger.debug(`📌 Watch state file created at ${this.watchStateFile}`);
+      } catch (error) {
+        logger.warn(`Could not create watch state file: ${error.message}`);
+      }
+
+      logger.info('🟢 WatchService started');
+      logger.info(`📁 Watching ${this.watchedDirs.size} director(y/ies)`);
+
+      // List watched directories
+      this.watchedDirs.forEach((dir) => {
+        logger.info(`   → ${dir}`);
+      });
+    } catch (error) {
+      logger.error(`Failed to start WatchService: ${error.message}`);
+      this.stats.errorsEncountered++;
+      this.isRunning = false;
+      throw error;
+    }
+  }
+
+  /**
+   * Stop watching all directories
+   * @returns {Promise<void>}
+   */
+  async stop(reason = 'unknown') {
+    try {
+      logger.info(`🔴 Stopping WatchService (reason: ${reason})...`);
+
+      // Clear all timers
+      this.debounceTimers.forEach((timer) => clearTimeout(timer));
+      this.debounceTimers.clear();
+      this.eventQueue.clear();
+
+      // Close all watchers
+      const closePromises = Array.from(this.watchers.values()).map((watcher) =>
+        watcher.close(),
+      );
+
+      await Promise.all(closePromises);
+
+      this.watchers.clear();
+      this.watchedDirs.clear();
+      this.watcherReady.clear();
+      this.allWatchersReady = false;
+      this.isWatchModeActive = false; // Allow direct uploads again
+      this.isRunning = false;
+
+      // Clean up watch mode state file for inter-process communication
+      try {
+        if (fs.existsSync(this.watchStateFile)) {
+          fs.unlinkSync(this.watchStateFile);
+          logger.debug('🧹 Cleaned up watch state file');
+        }
+      } catch (error) {
+        logger.warn(`Could not clean up watch state file: ${error.message}`);
+      }
+
+      // Save final state
+      await this.#saveState();
+
+      logger.info('✅ WatchService stopped successfully');
+
+      return {
+        success: true,
+        reason,
+        stats: this.getStats(),
+      };
+    } catch (error) {
+      logger.error(`Error stopping WatchService: ${error.message}`);
+      this.stats.errorsEncountered++;
+
+      return {
+        success: false,
+        reason,
+        error: error.message,
+        stats: this.getStats(),
+      };
+    }
+  }
+
+  /**
+   * Handle file added event
+   * Integrates with Smart Watch Queue for intelligent file management
+   * @private
+   * @param {string} filePath - Path to added file
+   */
+  async #handleFileAdded(filePath) {
+    logger.debug(`📄 File added: ${filePath}`);
+    this.stats.filesAdded++;
+
+    try {
+      const parentDir = path.dirname(filePath);
+      const fileName = path.basename(filePath);
+      const stats = fs.statSync(filePath);
+
+      // Check if file is a pedimento simplificado
+      const isPedimento = this.#isPedimentoSimplificado(fileName);
+
+      if (isPedimento) {
+        // Register pedimento and auto-update pending files
+        logger.info(`🎯 Pedimento detected: ${fileName}`);
+        await this.smartWatchDb.markPedimentoDetected(parentDir, filePath);
+        this.stats.uploadsTriggered++;
+      } else {
+        // Register file as PENDING, waiting for pedimento
+        logger.debug(`⏳ Registering file as PENDING: ${fileName}`);
+        await this.smartWatchDb.insertFileToUploader(filePath, {
+          processingStatus: 'PENDING',
+          dependsOnPath: parentDir,
+          size: stats.size,
+          fileExtension: path.extname(fileName).slice(1).toLowerCase(),
+        });
+      }
+    } catch (error) {
+      logger.error(`Error handling file added event: ${error.message}`);
+      this.stats.errorsEncountered++;
+    }
+
+    // If auto-processing is enabled, trigger the 4-step pipeline
+    // BUT only after ALL initial scans are complete (allWatchersReady)
+    if (this.autoProcessingEnabled) {
+      if (this.allWatchersReady) {
+        // Use debouncing to batch multiple files detected in quick succession
+        const parentDir = path.dirname(filePath);
+        this.#triggerAutoPipelineWithDebounce(filePath, parentDir);
+        return;
+      } else {
+        // During initial scan, silently skip - don't log to avoid noise
+      }
+    }
+
+    // Queue for regular upload processing
+    this.#queueEvent('add', filePath);
+  }
+
+  /**
+   * Trigger auto pipeline with debounce to avoid duplicates
+   * @private
+   * @param {string} filePath - Path to file
+   * @param {string} parentDir - Parent directory
+   * @returns {void}
+   */
+  #triggerAutoPipelineWithDebounce(filePath, parentDir) {
+    // Clear existing timer for this directory
+    if (this.pipelineDebounceTimers.has(parentDir)) {
+      clearTimeout(this.pipelineDebounceTimers.get(parentDir));
+    }
+
+    // Set new timer with increased debounce
+    const timer = setTimeout(() => {
+      this.#triggerAutoPipeline(filePath);
+      this.pipelineDebounceTimers.delete(parentDir);
+    }, 1000); // Increased to 1 second for better debouncing
+
+    this.pipelineDebounceTimers.set(parentDir, timer);
+  }
+
+  /**
+   * Handle file changed event
+   * @private
+   * @param {string} filePath - Path to changed file
+   */
+  #handleFileChanged(filePath) {
+    logger.debug(`✏️ File changed: ${filePath}`);
+    this.stats.filesModified++;
+    this.#queueEvent('change', filePath);
+  }
+
+  /**
+   * Handle file removed event
+   * @private
+   * @param {string} filePath - Path to removed file
+   */
+  #handleFileRemoved(filePath) {
+    logger.debug(`🗑️ File removed: ${filePath}`);
+    this.stats.filesRemoved++;
+    // Don't queue removal events as they don't need upload
+  }
+
+  /**
+   * Handle directory added event
+   * @private
+   * @param {string} dirPath - Path to added directory
+   */
+  #handleDirAdded(dirPath) {
+    logger.debug(`📁 Directory added: ${dirPath}`);
+  }
+
+  /**
+   * Handle directory removed event
+   * @private
+   * @param {string} dirPath - Path to removed directory
+   */
+  #handleDirRemoved(dirPath) {
+    logger.debug(`🗑️ Directory removed: ${dirPath}`);
+  }
+
+  /**
+   * Handle watcher error
+   * @private
+   * @param {Error} error - Error from watcher
+   */
+  #handleWatcherError(error) {
+    logger.error(`Watcher error: ${error.message}`);
+    this.stats.errorsEncountered++;
+  }
+
+  /**
+   * Queue an event with debouncing
+   * @private
+   * @param {string} eventType - Type of event (add, change, etc)
+   * @param {string} filePath - File path
+   * @param {number} debounceMs - Debounce delay in milliseconds
+   */
+  #queueEvent(eventType, filePath, debounceMs = 1000) {
+    const eventKey = `${eventType}:${filePath}`;
+
+    // Clear existing timer if any
+    if (this.debounceTimers.has(eventKey)) {
+      clearTimeout(this.debounceTimers.get(eventKey));
+    }
+
+    // Set new debounce timer
+    const timer = setTimeout(() => {
+      this.#processEvent(eventType, filePath);
+      this.debounceTimers.delete(eventKey);
+    }, debounceMs);
+
+    this.debounceTimers.set(eventKey, timer);
+  }
+
+  /**
+   * Get current watch statistics
+   * @returns {Object} Statistics object
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      watchedDirectories: this.watchedDirs.size,
+      activeWatchers: this.watchers.size,
+      isRunning: this.isRunning,
+      autoProcessingEnabled: this.autoProcessingEnabled,
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      filesAdded: 0,
+      filesModified: 0,
+      filesRemoved: 0,
+      uploadsTriggered: 0,
+      errorsEncountered: 0,
+    };
+  }
+
+  /**
+   * Check if service is running
+   * @returns {boolean} Running status
+   */
+  isWatching() {
+    return this.isRunning;
+  }
+
+  /**
+   * Get list of watched directories
+   * @returns {Array<string>} Watched directories
+   */
+  getWatchedDirs() {
+    return Array.from(this.watchedDirs);
+  }
+
+  /**
+   * Set custom event handler for processed events
+   * Used by WatchCommand to handle upload logic
+   * @param {Function} handler - Callback function (eventType, filePath) => void
+   */
+  setEventHandler(handler) {
+    if (typeof handler !== 'function') {
+      throw new Error('Event handler must be a function');
+    }
+    this.#customEventHandler = handler;
+  }
+
+  /**
+   * Custom event handler (to be set by WatchCommand)
+   * @private
+   */
+  #customEventHandler = null;
+
+  /**
+   * Process event with custom handler if set
+   * @private
+   * @param {string} eventType - Type of event
+   * @param {string} filePath - File path
+   */
+  #processEvent(eventType, filePath) {
+    logger.info(`⚡ Processing event: ${eventType} - ${filePath}`);
+
+    // Register event in handler
+    watchEventHandler.registerEvent(eventType, filePath);
+
+    if (this.#customEventHandler) {
+      try {
+        this.#customEventHandler(eventType, filePath);
+      } catch (error) {
+        logger.error(`Error in custom event handler: ${error.message}`);
+        this.stats.errorsEncountered++;
+      }
+    }
+  }
+
+  /**
+   * Trigger the automatic 4-step processing pipeline
+   * @private
+   * @param {string} filePath - Path to the newly added file
+   * @returns {Promise<void>}
+   */
+  async #triggerAutoPipeline(filePath) {
+    try {
+      // Find which watch directory this file belongs to
+      const watchDir = this.#findWatchDirectory(filePath);
+      if (!watchDir) {
+        logger.warn(
+          `[AutoPipeline] File not in any watched directory: ${filePath}`,
+        );
+        return;
+      }
+
+      const dirConfig = this.directoryConfigs.get(watchDir);
+      if (!dirConfig) {
+        logger.warn(
+          `[AutoPipeline] No configuration found for watch directory: ${watchDir}`,
+        );
+        return;
+      }
+
+      logger.info(
+        `[AutoPipeline] Triggering 4-step processing pipeline for: ${filePath}`,
+      );
+      this.stats.pipelinesTriggered++;
+
+      // Execute the 4-step pipeline
+      const result = await autoProcessingService.executeProcessingPipeline({
+        filePath,
+        watchDir,
+        folderStructure: dirConfig.folderStructure || 'default',
+        batchSize: this.processingOptions.batchSize || 10,
+      });
+
+      if (result.summary?.success) {
+        logger.info(
+          `[AutoPipeline] ✅ Pipeline completed successfully (ID: ${result.pipelineId})`,
+        );
+      } else {
+        const failureMsg = result.summary?.message || 'Unknown error occurred';
+        logger.error(`[AutoPipeline] ❌ Pipeline failed: ${failureMsg}`);
+      }
+    } catch (error) {
+      logger.error(
+        `[AutoPipeline] Error triggering auto-processing pipeline: ${error.message}`,
+      );
+      this.stats.errorsEncountered++;
+    }
+  }
+
+  /**
+   * Find which watch directory a file belongs to
+   * @private
+   * @param {string} filePath - Path to file
+   * @returns {string|null} Watch directory path or null
+   */
+  #findWatchDirectory(filePath) {
+    const absolutePath = path.resolve(filePath);
+
+    for (const watchDir of this.watchedDirs) {
+      if (absolutePath.startsWith(watchDir)) {
+        return watchDir;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Detect if a file is a "pedimento simplificado"
+   * @private
+   * @param {string} fileName - File name to check
+   * @returns {boolean} True if file matches pedimento pattern
+   */
+  #isPedimentoSimplificado(fileName) {
+    return this.pedimentoPattern.test(fileName);
+  }
+
+  /**
+   * Enable automatic processing pipeline on new files
+   * @param {Object} options - Processing options
+   * @param {number} options.batchSize - Batch size for processing
+   * @returns {void}
+   */
+  enableAutoProcessing(options = {}) {
+    this.autoProcessingEnabled = true;
+    this.processingOptions = options;
+    logger.info(
+      `[AutoPipeline] Automatic processing enabled with options:`,
+      options,
+    );
+  }
+
+  /**
+   * Disable automatic processing pipeline
+   * @returns {void}
+   */
+  disableAutoProcessing() {
+    this.autoProcessingEnabled = false;
+    logger.info('[AutoPipeline] Automatic processing disabled');
+  }
+
+  /**
+   * Get current Smart Watch Queue statistics
+   * @returns {Object} Queue statistics
+   */
+  async getQueueStats() {
+    try {
+      const stats = await this.smartWatchDb.getProcessingStats();
+      const progress = await this.smartWatchDb.getOverallProgress();
+
+      return {
+        queue: {
+          pending: stats.pending,
+          readyToUpload: stats.readyToUpload,
+          processing: stats.processing,
+          uploaded: stats.uploaded,
+          failed: stats.failed,
+          total: stats.total,
+        },
+        progress: {
+          percentComplete: progress.percentComplete,
+          estimatedTimeRemaining: progress.estimatedTimeRemaining,
+          avgProcessingTimeMs: progress.avgProcessingTimeMs,
+        },
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      logger.error(`Error getting queue stats: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Check if auto-processing is enabled
+   * @returns {boolean} Auto-processing status
+   */
+  isAutoProcessingEnabled() {
+    return this.autoProcessingEnabled;
+  }
+
+  /**
+   * Wait for all watchers to complete initial scan (ready state)
+   * @returns {Promise<void>}
+   */
+  async waitForWatchersReady() {
+    if (this.watchedDirs.size === 0) {
+      logger.info('✅ No watchers to wait for');
+      this.allWatchersReady = true;
+      return;
+    }
+
+    logger.info(
+      `⏳ Waiting for ${this.watchedDirs.size} watcher(s) to complete initial scan...`,
+    );
+
+    // Set a reasonable timeout (30 seconds max)
+    const timeout = 30000;
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeout) {
+      const readyCounts = Array.from(this.watchedDirs).filter(
+        (dir) => this.watcherReady.get(dir) === true,
+      ).length;
+
+      if (readyCounts === this.watchedDirs.size) {
+        logger.info(`✅ All ${this.watchedDirs.size} watcher(s) ready`);
+        this.allWatchersReady = true; // Set global flag
+        return;
+      }
+
+      // Wait a bit before checking again
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    logger.warn(
+      'Timeout waiting for watchers to be ready, but setting flag to proceed',
+    );
+    this.allWatchersReady = true; // Set flag anyway to unblock
+  }
+
+  /**
+   * Save the current state before shutdown
+   * @private
+   * @returns {Promise<void>}
+   */
+  async #saveState() {
+    try {
+      logger.debug('WatchService: Saving current state...');
+
+      // Log final stats
+      const stats = this.getStats();
+      logger.info('WatchService: Final Stats');
+      logger.info(`├─ Files Added: ${stats.filesAdded}`);
+      logger.info(`├─ Files Modified: ${stats.filesModified}`);
+      logger.info(`├─ Files Removed: ${stats.filesRemoved}`);
+      logger.info(`├─ Uploads Triggered: ${stats.uploadsTriggered}`);
+      logger.info(`└─ Errors Encountered: ${stats.errorsEncountered}`);
+
+      // Flush any pending events
+      this.eventQueue.clear();
+
+      logger.debug('WatchService: State saved successfully');
+    } catch (error) {
+      logger.error(`WatchService: Error saving state: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if watch mode is currently active (prevents direct uploads)
+   * @returns {boolean} True if watch mode is active
+   */
+  isWatchActive() {
+    // Check lock file for inter-process communication
+    // This allows upload command to detect watch mode even in separate process
+    try {
+      if (!fs.existsSync(this.watchStateFile)) {
+        return this.isWatchModeActive;
+      }
+
+      // Read lock file to check process status
+      const lockData = JSON.parse(
+        fs.readFileSync(this.watchStateFile, 'utf-8'),
+      );
+      const lockPid = lockData.pid;
+      const lockTimestamp = lockData.timestamp;
+
+      // Check if process is still alive
+      if (lockPid && typeof lockPid === 'number') {
+        try {
+          // Sending signal 0 checks if process exists without killing it
+          process.kill(lockPid, 0);
+          return true; // Process exists
+        } catch (error) {
+          // Process doesn't exist, clean up stale lock file
+          logger.warn(
+            `🧹 Found stale watch lock (PID ${lockPid} no longer exists), cleaning up...`,
+          );
+          try {
+            fs.unlinkSync(this.watchStateFile);
+            logger.debug('✅ Stale watch lock removed');
+          } catch (cleanupError) {
+            logger.warn(
+              `Could not remove stale lock file: ${cleanupError.message}`,
+            );
+          }
+          return false;
+        }
+      }
+
+      // Fallback: check if lock file is too old (>1 hour)
+      const ageMs = Date.now() - (lockTimestamp || 0);
+      if (ageMs > 3600000) {
+        logger.warn(
+          '🧹 Found very old watch lock file (>1 hour), cleaning up...',
+        );
+        try {
+          fs.unlinkSync(this.watchStateFile);
+          logger.debug('✅ Old watch lock removed');
+        } catch (cleanupError) {
+          logger.warn(
+            `Could not remove old lock file: ${cleanupError.message}`,
+          );
+        }
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      // If we can't read the file properly, fall back to memory flag
+      logger.debug(`Error checking watch state file: ${error.message}`);
+      return this.isWatchModeActive;
+    }
+  }
+}
+
+// Export singleton instance
+export default new WatchService();