cantemo-portal-agent 1.1.1 → 1.2.0

data/lib/envoi/mam/cantemo/agent/watch_folder_manager.rb

@@ -1,5 +1,6 @@
 require 'envoi/mam/cantemo/agent'
 require 'envoi/aspera/watch_service/watch_folder'
+require 'envoi/watch_folder_utility/watch_folder'
 require 'envoi/watch_folder_utility/watch_folder/handler/listen'
 
 module Envoi::Mam::Cantemo
@@ -13,21 +14,33 @@ module Envoi::Mam::Cantemo
 
       DEFAULT_WATCH_FOLDER_PROCESSOR_LIMIT = 10
 
-      attr_accessor :logger, :agent, :config, :watch_folder_defs, :watch_folders
+      attr_accessor :logger, :default_agent_class, :default_agent, :config, :watch_folder_defs, :watch_folders
 
       def initialize(args = {})
         initialize_logger(args)
 
         logger.debug { 'Initializing Agent Watch Folder Manager.' }
 
-        logger.debug { 'Initializing Cantemo Portal Agent.' }
         args[:default_preserve_file_path] = args.fetch(:default_preserve_file_path, false)
-        @agent                            = Envoi::Mam::Cantemo::Agent.load_from_config_file(args)
-        logger.debug { 'Cantemo Portal Agent Initialized.' }
 
-        @config            = agent.config
-        cantemo_config     = config[:cantemo] || config['cantemo']
-        @watch_folder_defs = cantemo_config[:watch_folders] || cantemo_config['watch_folders']
+        @config = Envoi::Mam::Cantemo::Agent.load_config_from_file(args)
+        cantemo_config = config[:cantemo] || config['cantemo']
+
+        @default_agent_class = Envoi::Mam::Cantemo::Agent
+
+        if cantemo_config
+          logger.debug { 'Initializing Default Cantemo Portal Agent.' }
+          @default_agent = @default_agent_class.new(args.merge({ config: cantemo_config }))
+          logger.debug { 'Default Cantemo Portal Agent Initialized.' }
+          @default_storages = @default_agent.agent_config_storages
+        else
+          @default_agent = nil
+        end
+
+        @watch_folder_defs = config[:watch_folders] || config['watch_folders']
+        if !@watch_folder_defs && cantemo_config
+          @watch_folder_defs = cantemo_config[:watch_folders] || cantemo_config['watch_folders']
+        end
 
         @ignored_file_paths_by_watch_folder = Hash.new { |h, k| h[k] = [] }
         @ignored_file_paths_lock            = Mutex.new
@@ -50,8 +63,6 @@ module Envoi::Mam::Cantemo
         @logger
       end
 
-      # @TODO Move most of this code into a watch folder class
-      #
       # @param [Hash] watch_folder_def
       # @option watch_folder_def [String] path
       # @option watch_folder_def [String] upload_to_storage_id
@@ -66,96 +77,6 @@ module Envoi::Mam::Cantemo
       # @option watch_folder_def [Integer|False] maximum_active_processors (@default_maximum_active_processors)
       # @option watch_folder_def [Hash] logging
       def process_watch_folder_def(watch_folder_def)
-        logger.debug { "Initializing Watch Folder #{watch_folder_def.inspect}" }
-
-        logger.debug { "Initializing parameter 'paths'." }
-        name = watch_folder_def['name']
-
-        path = watch_folder_def['path']
-
-        paths = watch_folder_def['paths'] ||= []
-        paths = [ paths ] if paths.is_a?(String)
-        paths.concat [*path] if path
-        paths.map! { |p| File.expand_path(p) }
-        if paths.empty?
-          name_as_path = File.expand_path(name)
-          paths.concat name_as_path if Dir.exist?(name_as_path)
-        end
-        paths.uniq!
-        watch_folder_def['paths'] = paths
-        # watch_folder_def['path'] ||= paths.first if paths.length == 1
-        watch_folder_def.delete('path')
-
-        if paths.empty?
-          logger.error { "Failed to initialize watch folder. No path found in watch folder definition." }
-          return false
-        end
-        logger.debug { "Parameter 'paths' initialized." }
-
-        logger.debug { "Initializing parameter 'includes'." }
-        include  = watch_folder_def['include']
-        includes = (watch_folder_def['includes'] ||= [])
-        includes.concat [*include] if include
-        includes.uniq!
-        includes.map! { |e| Regexp.try_convert(e) || e }
-        watch_folder_def['includes'] = includes
-        watch_folder_def.delete('include')
-        logger.debug { "Parameter `includes` initialized." }
-
-        logger.debug { "Initializing parameter 'excludes'." }
-        exclude  = watch_folder_def['exclude']
-        exclude  ||= '**/.*'
-        excludes = (watch_folder_def['excludes'] ||= [])
-        excludes.concat [*exclude] if exclude
-        excludes.uniq!
-        excludes.map! { |e| Regexp.try_convert(e) || e }
-        watch_folder_def['excludes'] = excludes
-        watch_folder_def.delete('exclude')
-        logger.debug { "Parameter `excludes` initialized." }
-
-
-        logger.debug { "Initializing parameter `quarantine directory path`." }
-        quarantine_directory_path = watch_folder_def['quarantine_directory_path'] || watch_folder_def['quarantine_path']
-        if quarantine_directory_path
-          quarantine_directory_path                     = File.expand_path(quarantine_directory_path)
-          watch_folder_def['quarantine_directory_path'] = quarantine_directory_path
-
-          unless Dir.exist?(quarantine_directory_path)
-            logger.warn { "Quarantine directory path '#{quarantine_directory_path}' does not exist. Files will be ignored instead." }
-          end
-        end
-        watch_folder_def.delete('quarantine_path')
-        logger.debug { "Parameter `quarantine directory path` initialized." }
-
-        logger.debug { "Initializing parameter 'completed directory path'." }
-        completed_directory_path = watch_folder_def['completed_directory_path'] || watch_folder_def['completed_path']
-        if completed_directory_path
-          completed_directory_path                     = File.expand_path(completed_directory_path)
-          watch_folder_def['completed_directory_path'] = completed_directory_path
-
-          unless Dir.exist?(completed_directory_path)
-            logger.warn { "Completed directory path '#{completed_directory_path}' does not exist. File will be ignored instead." }
-          end
-        end
-        watch_folder_def.delete('completed_path')
-        logger.debug { "Parameter 'completed directory path' initialized." }
-
-
-        logger.debug { "Initializing parameter `upload to storage id`." }
-        storage_id = watch_folder_def['upload_to_storage_id'] || watch_folder_def['storage_id']
-        watch_folder_def['upload_to_storage_id'] ||= storage_id
-        watch_folder_def.delete('storage_id')
-        unless storage_id
-          logger.warn { "No `upload to storage id` specified. Uploading will be skipped for this watch folder." }
-        end
-        logger.debug { "Parameter 'upload to storage id' initialized." }
-
-        maximum_active_processors = watch_folder_def['maximum_active_processors']
-        if maximum_active_processors.nil?
-          maximum_active_processors = @default_maximum_active_processors
-          watch_folder_def['maximum_active_processors'] = maximum_active_processors
-        end
-
         args_out              = {}
         logging               = watch_folder_def['logging'] || watch_folder_def
         log_to                = logging['log_to']
@@ -163,12 +84,11 @@ module Envoi::Mam::Cantemo
         args_out[:log_to]     ||= log_to if log_to && !log_to.empty?
         args_out[:log_level]  ||= log_level if log_level && !log_level.empty?
         args_out[:logger]     ||= logger.dup unless log_to
+        args_out[:default_agent] = default_agent
+        args_out[:default_agent_class] = default_agent_class
         args_out[:definition] = watch_folder_def
 
-        logger.debug { "Initializing Watch Folder Instance from Def. #{watch_folder_def}" }
-        watch_folder = LWF.new(args_out)
-        logger.debug { "Watch Folder Instance Created." }
-        watch_folder
+        Envoi::WatchFolderUtility::WatchFolder.new(args_out)
       end
 
       # Iterates through watch_folder_defs and populates @watch_folders with watch folders initialized from the watch
@@ -189,27 +109,30 @@ module Envoi::Mam::Cantemo
         logger.debug { 'Processing of watch folder definitions completed.' }
       end
 
-      # @param [Object] watch_folder
       # @param [Object] file
-      def add_to_ignore(watch_folder, file)
+      def add_to_ignore(file)
         logger.debug { "Adding File to Ignore Cache: '#{file.path}'" }
         @ignored_file_paths_lock.synchronize do
-          @ignored_file_paths_by_watch_folder[watch_folder] << file.path
+          @ignored_file_paths_by_watch_folder[file.watch_folder] << file.path
           file.ignore if file.respond_to?(:ignore)
         end
       end
 
-      # @param [Object] watch_folder
       # @param [Object] file
       # @return [FalseClass]
-      def process_file(watch_folder, file)
+      def process_file(file)
         file.processing = true
         file_name       = file.name || file.path
         logger.debug { "Processing File '#{file_name}'" }
+        watch_folder = file.watch_folder
+        agent = watch_folder.respond_to?(:agent) ? watch_folder.agent : default_agent
+        agent ||= default_agent
 
         storage_id                = watch_folder.definition['upload_to_storage_id']
         quarantine_directory_path = watch_folder.definition['quarantine_directory_path']
         completed_directory_path  = watch_folder.definition['completed_directory_path']
+        import_args               = watch_folder.definition['import_args']
+        import_options            = watch_folder.definition['import_options']
 
         # full_file_path = File.join(watch_folder.path, file.path)
         full_file_path = file.path
@@ -218,7 +141,8 @@ module Envoi::Mam::Cantemo
           return { success: false, message: 'Missing storage ID.' }
         end
 
-        _response = agent.upload(file_path: full_file_path, storage_id: storage_id)
+        _response = agent.upload(file_path: full_file_path,
+                                 storage_id: storage_id, import_args: import_args, import_options: import_options)
         _response = { success: _response } if _response == true || _response == false
 
         if _response[:success]
@@ -228,7 +152,7 @@ module Envoi::Mam::Cantemo
               FileUtils.mv full_file_path, completed_directory_path
             else
               logger.warn { "Completed directory path not found: '#{completed_directory_path}'" }
-              add_to_ignore(watch_folder, file)
+              add_to_ignore(file)
             end
           else
             FileUtils.rm full_file_path
@@ -239,7 +163,7 @@ module Envoi::Mam::Cantemo
             FileUtils.mv full_file_path, quarantine_directory_path
           else
             logger.warn { "Adding '#{full_file_path}' to the temporary ignore list." }
-            add_to_ignore(watch_folder, file)
+            add_to_ignore(file)
           end
         end
 
@@ -269,9 +193,14 @@ module Envoi::Mam::Cantemo
         includes = wf.definition['includes']
         excludes = wf.definition['excludes']
 
-        ignored_file_paths = @ignored_file_paths_by_watch_folder[wf]
+        ignored_file_paths = wf.ignored_file_paths if wf.respond_to?(:ingored_file_paths)
+        unless ignored_file_paths
+          ignored_file_paths = @ignored_file_paths_by_watch_folder[wf]
+        end
+
+
         stable_files.each do |file|
-          next if ignored_file_paths.include?(file.path)
+          next if file.respond_to?(:ignore?) ? file.ignore? : ignored_file_paths.include?(file.path)
           next if file.processing
           next if file.processed
 
@@ -319,11 +248,15 @@ module Envoi::Mam::Cantemo
       def poll
         stable_files_by_watch_folder = {} # Hash.new { |h, k| h[k] = [] }
         watch_folders.each do |watch_folder|
-          if !watch_folder.last_poll_time || (Time.now - watch_folder.last_poll_time) >= watch_folder.poll_interval
-            stable_files                               = watch_folder.poll
-            stable_files_by_watch_folder[watch_folder] = stable_files
-          end
+          next unless watch_folder.poll_interval_elapsed?
+
+          logger.debug { "Polling Watch Folder: #{watch_folder.name}" }
+          watch_folder.poll
+
+          stable_files = watch_folder.stable_files
+          stable_files_by_watch_folder[watch_folder] = stable_files
         end
+
         stable_files_by_watch_folder.each do |watch_folder, stable_files|
           process_watch_folder_stable_files(watch_folder, stable_files)
         end
@@ -357,14 +290,33 @@ module Envoi::Mam::Cantemo
         # AWF.run_once(watch_folders) { |wf| process_watch_folder(wf) }
       end
 
+      # Converts hash keys to symbols
+      #
+      # @param [Hash] value hash
+      # @param [Boolean] recursive Will recurse into any values that are hashes or arrays
+      def symbolize_keys (value, recursive = true)
+        case value
+        when Hash
+          Hash[value.map { |k,v| [ k.respond_to?(:to_sym) ? k.to_sym : k, recursive ? symbolize_keys(v, true) : v ] }]
+        when Array
+          value.map { |v| symbolize_keys(v, recursive) }
+        else
+          value
+        end
+        # symbolize_keys
+      end
+
       def self.run(args)
         w = self.new(args)
         w.run
       rescue => e
-        abort("An error occurred.\n#{e.message}\n#{e.message}")
+        abort("An error occurred. #{e.message}\n#{e.backtrace.join("\n")}")
       end
 
       def self.daemons_run_proc_with_cleanup(options, &block)
+        options[:dir_mode] = :normal
+        options[:dir]      = File.split(__FILE__)[0]
+
         if block_given?
           options[:mode] = :proc
           options[:proc] = block
@@ -404,19 +356,15 @@ module Envoi::Mam::Cantemo
       def self.run_as_daemon(args, options = {})
         # ARGV.unshift 'run' unless %w(start stop restart run zap killall status).include? ARGV.first
         require 'daemons'
-        # Daemons.run_proc('cantemo-portal-watch-folders', { force: true }) { self.run(args) }
-        app_name = 'cantemo-portal-watch-folders'
         proc     = Proc.new { self.run(args) }
+        app_name = 'cantemo-portal-watch-folders'
 
-        options[:app_name] = app_name
-        options[:mode]     = :proc
-        options[:dir_mode] = :normal
-        options[:dir]      = File.split(__FILE__)[0]
+        # options[:app_name] = app_name
+        # daemons_run_proc_with_cleanup(options, &proc)
 
-        daemons_run_proc_with_cleanup(options, &proc)
+        # options[:force] = true
+        Daemons.run_proc(app_name, options, &proc)
 
-        # app_controller = Daemons::Controller.new(options, ARGV)
-        # Daemons.run_proc(app_name, options, &proc)
       end
 
     end

data/lib/envoi/watch_folder_utility/watch_folder.rb

@@ -0,0 +1,307 @@
+require 'envoi/mam/cantemo/agent'
+require 'envoi/aspera/watch_service/watch_folder'
+require 'envoi/watch_folder_utility/watch_folder/handler/listen'
+
+module Envoi
+
+  module WatchFolderUtility
+
+    class WatchFolder
+
+      DEFAULT_POLL_INTERVAL = 15
+      DEFAULT_PROCESSOR_COUNT_LIMIT = 10
+
+      attr_accessor :logger, :definition, :agent, :handler
+
+      attr_accessor :processors
+
+      attr_accessor :last_poll_time,
+                    :min_stable_poll_count,
+                    :min_stable_time,
+                    :poll_interval
+
+
+      def initialize(args = { })
+        initialize_logger(args)
+        @definition = args[:definition].dup
+
+        logger.debug { "Initializing Watch Folder. #{Object.__id__}" }
+
+        @ignored_file_paths_lock = Mutex.new
+
+        @threaded = args.fetch(:threaded, true)
+
+        @default_maximum_active_processors = DEFAULT_PROCESSOR_COUNT_LIMIT
+        @processors = Hash.new { |h, k| h[k] = {} }
+
+        @default_handler_class = Envoi::WatchFolderUtility::WatchFolder::Handler::Listen
+        process_watch_folder_def
+
+        initialize_handler
+
+        @default_agent = args[:default_agent]
+        @default_agent_class = args[:default_agent_class] || @default_agent.class
+
+        process_agent_defs
+        logger.debug { "Watch Folder Initialized. #{Object.__id__}" }
+      end
+
+      def initialize_logger(args = {})
+        @logger   = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+        log_level = args[:log_level] = Logger::DEBUG
+        if log_level
+          @logger.level = log_level
+          args[:logger] = @logger
+        end
+        @logger
+      end
+
+      def initialize_agent(args = {})
+
+        @agent ||= begin
+          logger.debug { "Initializing Agent. #{@default_agent_class} #{args}" }
+          _agent = @default_agent_class.new(config: args)
+          logger.debug { "Agent Instance created." }
+          _agent
+        end
+      end
+
+      def ignored_file_paths
+        handler.ignored_files_map.keys
+      end
+
+      def process_agent_def(agent_def)
+        if @default_agent
+          _agent_def_storages = agent_def['storages'] || {}
+          if _agent_def_storages
+            agent_def['storages'] = default_agent.agent_config_storages.merge(_agent_def_storages)
+          end
+        end
+        initialize_agent(agent_def)
+      end
+
+      def name
+        @name ||= definition['name'] || definition['paths'] || definition['path'] || Object.__id__
+      end
+
+      def process_agent_defs
+        agent_defs = definition['agents']
+        if agent_defs
+          if agent_defs.is_a?(Hash)
+            _agents = agent_defs.map do |name, agent_def|
+              agent_def['name'] ||= name
+              # agent_def['type'] ||= name
+              process_agent_def(agent_def)
+            end
+          elsif agent_defs.is_a?(Array)
+            _agents = agent_defs.map { |agent_def| process_agent_def(agent_def) }
+          else
+
+          end
+        end
+        @agent ||= @default_agent
+      end
+
+      def initialize_handler(watch_folder_def = @definition)
+        args_out              = {}
+        logging               = watch_folder_def['logging'] || watch_folder_def
+        log_to                = logging['log_to']
+        log_level             = logging['log_level']
+        args_out[:log_to]     ||= log_to if log_to && !log_to.empty?
+        args_out[:log_level]  ||= log_level if log_level && !log_level.empty?
+        args_out[:logger]     ||= logger.dup unless log_to
+        args_out[:definition] = watch_folder_def
+
+        handler_class = @default_handler_class
+        logger.debug { "Creating Watch Folder Handler Instance. #{handler_class.name}" }
+        @handler = handler_class.new(args_out)
+        logger.debug { "Watch Folder Handler Instance Created. #{handler_class.name}" }
+      end
+
+      #
+      # @param [Hash] watch_folder_def
+      # @option watch_folder_def [String] path
+      # @option watch_folder_def [String] upload_to_storage_id
+      # @option watch_folder_def [String] name (path)
+      # @option watch_folder_def [Array<String>] paths ([path])
+      # @option watch_folder_def [String] exclude ('**/.*')
+      # @option watch_folder_def [Array<string>] excludes ([exclude])
+      # @option watch_folder_def [String] include
+      # @option watch_folder_def [Array<String>] includes ([include])
+      # @option watch_folder_def [String] quarantine_directory_path
+      # @option watch_folder_def [String] completed_directory_path
+      # @option watch_folder_def [Hash] import_args ({})
+      # @option watch_folder_def [Hash] import_options ({})
+      # @option watch_folder_def [Integer|False] maximum_active_processors (@default_maximum_active_processors)
+      # @option watch_folder_def [Hash] logging
+      def process_watch_folder_def(watch_folder_def = @definition)
+        logger.debug { "Initializing Watch Folder #{watch_folder_def.inspect}" }
+
+        logger.debug { "Initializing parameter 'paths'." }
+        name = watch_folder_def['name']
+
+        path = watch_folder_def['path']
+
+        paths = watch_folder_def['paths'] ||= []
+        paths = [ paths ] if paths.is_a?(String)
+        paths.concat [*path] if path
+        paths.map! { |p| File.expand_path(p) }
+        if paths.empty?
+          name_as_path = File.expand_path(name)
+          paths.concat name_as_path if Dir.exist?(name_as_path)
+        end
+        paths.uniq!
+        watch_folder_def['paths'] = paths
+        # watch_folder_def['path'] ||= paths.first if paths.length == 1
+        watch_folder_def.delete('path')
+
+        if paths.empty?
+          logger.error { "Failed to initialize watch folder. No path found in watch folder definition." }
+          return false
+        end
+        logger.debug { "Parameter 'paths' initialized." }
+
+        logger.debug { "Initializing parameter 'includes'." }
+        include  = watch_folder_def['include']
+        includes = (watch_folder_def['includes'] ||= [])
+        includes.concat [*include] if include
+        includes.uniq!
+        includes.map! { |e| Regexp.try_convert(e) || e }
+        watch_folder_def['includes'] = includes
+        watch_folder_def.delete('include')
+        logger.debug { "Parameter `includes` initialized." }
+
+        logger.debug { "Initializing parameter 'excludes'." }
+        exclude  = watch_folder_def['exclude']
+        exclude  ||= '**/.*'
+        excludes = (watch_folder_def['excludes'] ||= [])
+        excludes.concat [*exclude] if exclude
+        excludes.uniq!
+        excludes.map! { |e| Regexp.try_convert(e) || e }
+        watch_folder_def['excludes'] = excludes
+        watch_folder_def.delete('exclude')
+        logger.debug { "Parameter `excludes` initialized." }
+
+
+        logger.debug { "Initializing parameter `quarantine directory path`." }
+        quarantine_directory_path = watch_folder_def['quarantine_directory_path'] || watch_folder_def['quarantine_path']
+        if quarantine_directory_path
+          quarantine_directory_path                     = File.expand_path(quarantine_directory_path)
+          watch_folder_def['quarantine_directory_path'] = quarantine_directory_path
+
+          unless Dir.exist?(quarantine_directory_path)
+            logger.warn { "Quarantine directory path '#{quarantine_directory_path}' does not exist. Files will be ignored instead." }
+          end
+        end
+        watch_folder_def.delete('quarantine_path')
+        logger.debug { "Parameter `quarantine directory path` initialized." }
+
+        logger.debug { "Initializing parameter 'completed directory path'." }
+        completed_directory_path = watch_folder_def['completed_directory_path'] || watch_folder_def['completed_path']
+        if completed_directory_path
+          completed_directory_path                     = File.expand_path(completed_directory_path)
+          watch_folder_def['completed_directory_path'] = completed_directory_path
+
+          unless Dir.exist?(completed_directory_path)
+            logger.warn { "Completed directory path '#{completed_directory_path}' does not exist. File will be ignored instead." }
+          end
+        end
+        watch_folder_def.delete('completed_path')
+        logger.debug { "Parameter 'completed directory path' initialized." }
+
+
+        logger.debug { "Initializing parameter `upload to storage id`." }
+        storage_id = watch_folder_def['upload_to_storage_id'] || watch_folder_def['storage_id']
+        watch_folder_def['upload_to_storage_id'] ||= storage_id
+        watch_folder_def.delete('storage_id')
+        unless storage_id
+          logger.warn { "No `upload to storage id` specified. Uploading will be skipped for this watch folder." }
+        end
+        logger.debug { "Parameter 'upload to storage id' initialized." }
+
+        logger.debug { "Initializing parameter 'import args'." }
+        import_args = watch_folder_def['import_args'] || { }
+        import_options = watch_folder_def['import_options'] || { }
+
+        add_item_to_collection = import_options.fetch(:add_item_to_collection, import_args[:add_item_to_collection])
+        if add_item_to_collection.nil? || add_item_to_collection
+          _add_item_to_collection = false
+          collection_id = watch_folder_def['collection_id']
+          if collection_id
+            import_args[:collection_id] ||= collection_id
+            _add_item_to_collection = true
+            watch_folder_def.delete('collection_id')
+          else
+            collection_name = watch_folder_def['collection_name']
+            if collection_name
+              import_args[:collection_name] ||= collection_name
+              _add_item_to_collection = true
+              watch_folder_def.delete('collection_name')
+            else
+              file_path_collection_name_position = import_args[:file_path_collection_name_position]
+              if file_path_collection_name_position
+                import_args[:file_path_collection_name_position] = file_path_collection_name_position
+                _add_item_to_collection = true
+                watch_folder_def.delete('file_path_collection_name_position')
+              end
+            end
+          end
+          import_options[:add_item_to_collection] ||= _add_item_to_collection
+        end
+
+        metadata = watch_folder_def['metadata']
+        if metadata
+          import_args[:metadata] = metadata
+          watch_folder_def.delete('metadata')
+          metadata_map = watch_folder_def['metadata_map']
+          import_options[:metadata_map] ||= metadata_map if metadata_map
+        end
+        logger.debug { "Parameter 'import args' initialized." }
+
+
+        maximum_active_processors = watch_folder_def['maximum_active_processors']
+        if maximum_active_processors.nil?
+          maximum_active_processors = @default_maximum_active_processors
+          watch_folder_def['maximum_active_processors'] = maximum_active_processors
+        end
+
+        logger.debug { "Initializing parameter 'agents'." }
+        agent = watch_folder_def['agent']
+        agents = watch_folder_def['agents'] ||= [ ]
+        if agents.is_a?(Hash)
+          agents = agents.map { |k,v| v['name'] ||= k;  v }
+        end
+        if agent
+          if agent.is_a?(Hash)
+            if agent.keys.length == 1
+              agent = agent.map { |k,v| v['name'] ||= k; v }
+            end
+          end
+          agents.concat [*agent]
+          watch_folder_def.delete('agent')
+        end
+        logger.debug { "Parameter 'agent' initialized." }
+
+        @poll_interval = watch_folder_def['poll_interval'] ||= DEFAULT_POLL_INTERVAL
+      end
+
+      def poll
+        @previous_poll_time = @last_poll_time
+        @last_poll_time = Time.now
+
+        handler.poll if handler.respond_to?(:poll)
+      end
+
+      def poll_interval_elapsed?
+        !last_poll_time || (Time.now - last_poll_time) >= poll_interval
+      end
+
+      def stable_files
+        handler.stable_files
+      end
+
+    end
+
+  end
+
+end