cantemo-portal-agent 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 941c3be4e0b16164d64637173764d3fcaacc01f1
-  data.tar.gz: 1531dde6210f28ce51e5c7bdd514c85d03910f3b
+  metadata.gz: 7c2c43f547f0f607e087665ce93f3a5c63dd4d5a
+  data.tar.gz: 96c2cc23d5b30fa48abbc3d329e01287782b343e
 SHA512:
-  metadata.gz: 114af11cb4e03732296cd5d5c39727042bedc457440d7cbd89b5842233004da96c0442a97df73cc8fed297745b3ea2a1a87f9a67539a2ebab7c18c2038cdadbd
-  data.tar.gz: ff6261efd8fc22cc8019b7bee7a36fba60f61d22d87202604f39d9dc39a610feb0965500dd5ba5f338ca3f6469651f98373c786ba0278e4e8ef720e1f545c679
+  metadata.gz: 16d67112efc3e3748edbb090c97e86c5874945e18c17bedd34184ac0b9709f5771bccd7fc40b1f6c2ec382e17dc551c041c3ab33d901e6d809632ef183c9a60f
+  data.tar.gz: 8d93bcc5a774aba3a369e3dbe77c09a9c4dfe2b05d71572bfa0c5e387be9f4220c26f3beac924771e5e7541be06fb85123530fb2d9e1254cf22376f320542c28

data/lib/cantemo/portal/agent/cli/commands/watch_folders.rb

@@ -11,7 +11,6 @@ require 'envoi/mam/agent/cli'
 require 'envoi/mam/cantemo/agent'
 require 'envoi/mam/cantemo/agent/watch_folder_manager'
 
-
 Envoi::Mam::Agent::CLI::CONFIG_FILE_PATHS.clear
 Envoi::Mam::Agent::CLI::CONFIG_FILE_PATHS.concat [
    './cantemo-portal-agent-config.json',
@@ -21,7 +20,6 @@ Envoi::Mam::Agent::CLI::CONFIG_FILE_PATHS.concat [
 ]
 default_config_file_paths = Envoi::Mam::Agent::CLI::CONFIG_FILE_PATHS
 current_command = ARGV.shift
-ARGV << 'run' if ARGV.empty?
 # ARGV << '--help' if ARGV.empty?
 
 @args = {
@@ -47,12 +45,13 @@ op.load
 op.parse!
 
 sub_command = (ARGV.first || 'run').downcase
+sub_command.tr('-_', '')
+
 if sub_command == 'help'
   puts op
   exit
 end
 
-
 config_file_path = args[:config_file_path]
 if config_file_path.is_a?(Array)
   args[:config_file_path].map! { |v| File.expand_path(v) }
@@ -95,25 +94,72 @@ module Application
     require 'win32/daemon'
     class Watcher < Win32::Daemon
 
-      def service_init
+      LOG_FILE_PATH = 'C:\\tmp\\win32_daemon_test.log'
+      log_file_dir_path = File.dirname(LOG_FILE_PATH)
+      Dir.mkdir_p(log_file_dir_path) unless Dir.exist?(log_file_dir_path)
 
+      def write_log(message = nil, &block)
+        if block_given?
+          begin
+            f = File.open(LOG_FILE_PATH, 'a')
+            yield f
+          ensure
+            f.close if f && f.open?
+          end
+        else
+          File.open(LOG_FILE_PATH, 'a') { |f| f.puts(message) }
+        end
+      end
+
+      def service_init
+        @process_thread = nil
       end
 
       def service_main(*args)
-        @WatchFolderManager = WATCH_FOLDER_MANAGER_CLASS.new(args)
-        @WatchFolderManager.run
+        msg = 'service_main entered at: ' + Time.now.to_s
+
+        write_log{ |f|
+          f.puts msg
+          f.puts "Args: " + args.join(',')
+        }
+
+        @watch_folder_manager = nil
+        @process_thread = Thread.new(@watch_folder_manager, args) do |watch_folder_manager, args|
+          watch_folder_manager = WATCH_FOLDER_MANAGER_CLASS.new(args)
+          watch_folder_manager.run
+        end
+
+        while running?
+          if state == RUNNING
+            sleep 20
+            msg = 'Service is running as of: ' + Time.now.to_s
+            write_log { |f| f.puts msg }
+          else # PAUSED or IDLE
+            sleep 0.5
+          end
+        end
+
+
+        # We've left the loop, the daemon is about to exit.
+
+        write_log{ |f| f.puts "STATE: #{state}" }
+
+        msg = 'service_main left at: ' + Time.now.to_s
+
+        write_log{ |f| f.puts msg }
+
       end
 
       def service_stop
-        @WatchFolderManager.stop
+        @watch_folder_manager.stop
       end
 
       def service_pause
-        @WatchFolderManager.pause
+        @watch_folder_manager.pause
       end
 
       def service_resume
-        @WatchFolderManager.resume
+        @watch_folder_manager.resume
       end
 
       # Watcher - Windows
@@ -230,6 +276,8 @@ module Application
   end
 
 end
+
+
 # Options:
 #    install    - Installs the service.
 #    start      - Starts the service.
@@ -245,8 +293,6 @@ include RbConfig
 
 SERVICE_NAME = 'cantemo_portal_watch_folder_agent'
 SERVICE_DISPLAYNAME = 'Cantemo Portal Watch Folder Agent'
-EXECUTABLE_NAME = __FILE__
-
 
 # You must provide at least one argument.
 abort('No argument provided.') unless sub_command
@@ -255,10 +301,11 @@ abort('Service not installed.') unless Service.exists?(SERVICE_NAME) || sub_comm
 
 case sub_command
 when 'runasservice'
-  Application::Watcher.mainloop(args)
+  Application::Watcher.mainloop
 when 'start'
   if Service.status(SERVICE_NAME).current_state != 'running'
-    Service.start(SERVICE_NAME, nil)
+    # Service.start(SERVICE_NAME, nil, args)
+    Service.start(SERVICE_NAME)
     while Service.status(SERVICE_NAME).current_state != 'running'
       puts 'One moment...' + Service.status(SERVICE_NAME).current_state
       sleep 1
@@ -305,8 +352,9 @@ when 'status'
 when 'install'
   # Quote the full path to deal with possible spaces in the path name.
   ruby = File.join(CONFIG['bindir'], CONFIG['ruby_install_name']).tr('/', '\\')
-  path = %Q(#{File.dirname(File.expand_path($0)).tr('/', '\\')}\\#{EXECUTABLE_NAME})
-  cmd = %Q("#{ruby}" "#{path}" runasservice --config-file-path "#{config_file_path}")
+  path = __FILE__.tr('/', '\\')
+  # cmd = %Q("#{ruby}" "#{path}" runasservice --config-file-path "#{config_file_path}")
+  cmd = %Q("#{ruby}" "#{path}" run-as-service)
 
   Service.new(
       :service_name     => SERVICE_NAME,

data/lib/cantemo/portal/agent/version.rb

@@ -1,7 +1,7 @@
 module Cantemo
   module Portal
     class Agent
-      VERSION = '1.3.2'.freeze
+      VERSION = '1.3.3'.freeze
     end
   end
 end

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

@@ -18,7 +18,13 @@ module Envoi::Mam::Cantemo
 
         %w(log debug info warn error fatal unknown level=).each do |m|
           define_method(m) do |*args, &block|
-            @targets.map { |t| t.send(m, *args, &block) }
+            @current_message = nil
+            if block
+              @targets.map { |t| t.send(m, *args) { @current_message ||= block.call }}
+            else
+              @targets.map { |t| t.send(m, *args) }
+            end
+
           end
         end
       end
@@ -140,166 +146,32 @@ module Envoi::Mam::Cantemo
         logger.debug { 'Processing of watch folder definitions completed.' }
       end
 
-      # @param [Object] 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[file.watch_folder] << file.path
-          file.ignore if file.respond_to?(:ignore)
-        end
-      end
-
-      # @param [Object] file
-      # @return [Hash]
-      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']
-
-        unless storage_id
-          logger.warn { "Skipping processing of file because of missing storage ID." }
-          return { success: false, message: 'Missing storage ID.' }
-        end
-
-        quarantine_directory_path = watch_folder.definition['quarantine_directory_path']
-        completed_directory_path  = watch_folder.definition['completed_directory_path']
-        watch_folder_upload_args  = watch_folder.definition['upload_args']
-
-        # full_file_path = File.join(watch_folder.path, file.path)
-        full_file_path = file.path
-
-        upload_args = {
-          file_path: full_file_path,
-          storage_id: storage_id
-        }
-        upload_args.merge!(watch_folder_upload_args) if watch_folder_upload_args.is_a?(Hash)
-
-        logger.debug { "Executing Upload. #{upload_args}" }
-        _response = agent.upload(upload_args)
-        _response = { success: _response } if _response == true || _response == false
-
-        if _response[:success]
-          if completed_directory_path
-            if Dir.exist?(completed_directory_path)
-              logger.debug { "Moving '#{full_file_path}' to completed directory path '#{completed_directory_path}'" }
-              FileUtils.mv full_file_path, completed_directory_path
-            else
-              logger.warn { "Completed directory path not found: '#{completed_directory_path}'" }
-              add_to_ignore(file)
-            end
-          else
-            FileUtils.rm full_file_path
-          end
-        else
-          if quarantine_directory_path && Dir.exist?(quarantine_directory_path)
-            logger.warn { "Moving '#{full_file_path}' to quarantine directory path '#{quarantine_directory_path}'" }
-            FileUtils.mv full_file_path, quarantine_directory_path
-          else
-            logger.warn { "Adding '#{full_file_path}' to the temporary ignore list." }
-            add_to_ignore(file)
-          end
-        end
-
-        file.processed = true
-
-        _response
-      rescue => e
-        file.exception = e
-        raise e
-      ensure
-        file.processing = false
-      end
-
-      # Used to compare file to patterns
-      def find_in_patterns(patterns, file)
-        patterns.find do |pattern|
-            matched = pattern.is_a?(Regexp) ? pattern.match(file.path) : File.fnmatch(pattern, file.path)
-            logger.debug { "#{pattern} #{matched ? 'matched' : "didn't match"} #{file.path}" }
-            matched
-        end
-      end
-
-      # This should be part of the watch folder but it is here to track active processors globally
-      def process_watch_folder_stable_files(wf)
-        stable_files = wf.stable_files
-        active_processors         = @processors_by_watch_folder[wf]
-        maximum_active_processors = wf.definition['maximum_active_processors']
-
-        includes = wf.definition['includes']
-        excludes = wf.definition['excludes']
-
-        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|
-          file.watch_folder ||= wf
-          next if file.respond_to?(:ignore?) ? file.ignore? : ignored_file_paths.include?(file.path)
-          next if file.processing || file.processed
-
-          if includes && !includes.empty?
-            should_include = find_in_patterns(includes, file)
-            unless should_include
-              add_to_ignore(file)
-              next
-            end
-          end
-
-          should_exclude = find_in_patterns(excludes, file)
-          if should_exclude
-            add_to_ignore(file)
-            next
+      def poll
+        watch_folders_with_stable_files = [ ]
+        watch_folders.each do |watch_folder|
+          if watch_folder.respond_to?(:poll_interval_elapsed?)
+            next unless watch_folder.poll_interval_elapsed?
           end
 
-          if @threaded
-            active_processors.keep_if { |k, v| k.processing }
-            if active_processors.length >= maximum_active_processors
-              logger.debug { "Maximum number of active processors reached for watch folder. #{wf.name || wf.paths}" }
-              break
-            end
-            t = Thread.new(file) do |file|
-              wf = file.watch_folder
-              begin
-                process_file(file)
-              rescue => e
-                logger.error { "Exception '#{e.message}' in thread for `#{wf.name || wf.paths}` `#{file.path}`. " }
-                raise e
-              ensure
-                file.processing = false rescue nil
-              end
-            end
-            t.join
-            active_processors[file] = t if file.processing
-          else
-            process_file(file)
+          if watch_folder.respond_to?(:poll)
+            logger.debug { "Polling Watch Folder: #{watch_folder.name}" }
+            watch_folder.poll
           end
 
+          watch_folders_with_stable_files << watch_folder unless watch_folder.stable_files.empty?
         end
 
-      end
+        # @TODO create processor/worker pool to limit total file processing across all watch folders
+        watch_folders_with_stable_files.each do |watch_folder|
+          #process_watch_folder_stable_files(watch_folder)
 
-      # @TODO Thread this
-      def poll
-        stable_files_by_watch_folder = {} # Hash.new { |h, k| h[k] = [] }
-        watch_folders.each do |watch_folder|
-          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
+          total_active_processors = watch_folders.inject(0) { |sum, wf| sum + wf.processors.length }
+          watch_folder.process_stable_files
+          logger.debug { "Total active processors #{total_active_processors}" }
         end
 
-        stable_files_by_watch_folder.each do |watch_folder, stable_files|
-          process_watch_folder_stable_files(watch_folder)
-        end
+        # Thread.list.each {|t| t.join unless t == Thread.current }
+        # @processors_by_watch_folder.each { |wf, ap| ap.each { |f, t| t.join } } if @threaded
       end
 
       def run_once

data/lib/envoi/watch_folder_utility/watch_folder.rb

@@ -13,7 +13,7 @@ module Envoi
 
       attr_accessor :logger, :definition, :agent, :handler
 
-      attr_accessor :processors, :active_processors
+      attr_accessor :processors
 
       attr_accessor :last_poll_time,
                     :min_stable_poll_count,
@@ -26,12 +26,15 @@ module Envoi
 
         logger.debug { "Initializing Watch Folder. #{Object.__id__}" }
 
+        @ignored_file_paths = [ ]
         @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] = {} }
+        @processors = { }
+        # @processors = Hash.new { |h, k| h[k] = {} }
+
 
         @default_handler_class = Envoi::WatchFolderUtility::WatchFolder::Handler::Listen
         process_watch_folder_def
@@ -70,7 +73,6 @@ module Envoi
       end
 
       def initialize_agent(args = {})
-
         @agent ||= begin
           logger.debug { "Initializing Agent. #{@default_agent_class} #{args}" }
           _agent = @default_agent_class.new(config: args, logger: logger, default_preserve_file_path: false)
@@ -79,10 +81,50 @@ module Envoi
         end
       end
 
+      def initialize_handler(watch_folder_def = @definition)
+        args_out              = {}
+        args_out[:logger]     ||= logger.dup
+        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 [Object] file
+      def add_file_to_ignored_file_paths(file)
+        logger.debug { "Adding File to Ignore Cache: '#{file.path}'" }
+        @ignored_file_paths_lock.synchronize do
+          @ignored_file_paths << file.path
+          file.ignore if file.respond_to?(:ignore)
+        end
+      end
+
+      # Used to compare file to patterns
+      def find_in_patterns(patterns, file)
+        patterns.find do |pattern|
+          matched = pattern.is_a?(Regexp) ? pattern.match(file.path) : File.fnmatch(pattern, file.path)
+          logger.debug { "#{pattern} #{matched ? 'matched' : "didn't match"} #{file.path}" }
+          matched
+        end
+      end
+
       def ignored_file_paths
         handler.ignored_files_map.keys
       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 process_agent_def(agent_def)
         if @default_agent
           _agent_def_storages = agent_def['storages'] || {}
@@ -115,17 +157,6 @@ module Envoi
         @agent ||= @default_agent
       end
 
-      def initialize_handler(watch_folder_def = @definition)
-        args_out              = {}
-        args_out[:logger]     ||= logger.dup
-        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
@@ -190,7 +221,6 @@ module Envoi
         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
@@ -217,7 +247,6 @@ module Envoi
         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
@@ -325,15 +354,116 @@ module Envoi
         @poll_interval = watch_folder_def['poll_interval'] ||= DEFAULT_POLL_INTERVAL
       end
 
-      def poll
-        @previous_poll_time = @last_poll_time
-        @last_poll_time = Time.now
+      def process_stable_file(file)
+        file.processing = true
+        file_name       = file.name || file.path
+        logger.debug { "Processing File '#{file_name}'" }
 
-        handler.poll if handler.respond_to?(:poll)
+        storage_id                = definition['upload_to_storage_id']
+
+        unless storage_id
+          logger.warn { "Skipping processing of file because of missing storage ID." }
+          return { success: false, message: 'Missing storage ID.' }
+        end
+
+        quarantine_directory_path = definition['quarantine_directory_path']
+        completed_directory_path  = definition['completed_directory_path']
+        watch_folder_upload_args  = definition['upload_args']
+
+        # full_file_path = File.join(watch_folder.path, file.path)
+        full_file_path = file.path
+
+        upload_args = {
+            file_path: full_file_path,
+            storage_id: storage_id
+        }
+        upload_args.merge!(watch_folder_upload_args) if watch_folder_upload_args.is_a?(Hash)
+
+        logger.debug { "Executing Upload. #{upload_args}" }
+        _response = agent.upload(upload_args)
+        _response = { success: _response } if _response == true || _response == false
+
+        if _response[:success]
+          if completed_directory_path
+            if Dir.exist?(completed_directory_path)
+              logger.debug { "Moving '#{full_file_path}' to completed directory path '#{completed_directory_path}'" }
+              FileUtils.mv full_file_path, completed_directory_path
+            else
+              logger.warn { "Completed directory path not found: '#{completed_directory_path}'" }
+              add_file_to_ignored_file_paths(file)
+            end
+          else
+            FileUtils.rm full_file_path
+          end
+        else
+          if quarantine_directory_path && Dir.exist?(quarantine_directory_path)
+            logger.warn { "Moving '#{full_file_path}' to quarantine directory path '#{quarantine_directory_path}'" }
+            FileUtils.mv full_file_path, quarantine_directory_path
+          else
+            logger.warn { "Adding '#{full_file_path}' to the temporary ignore list." }
+            add_file_to_ignored_file_paths(file)
+          end
+        end
+
+        file.processed = true
+
+        _response
+      rescue => e
+        file.exception = e
+        raise e
+      ensure
+        file.processing = false
       end
 
-      def poll_interval_elapsed?
-        !last_poll_time || (Time.now - last_poll_time) >= poll_interval
+
+      def process_stable_files
+        maximum_active_processors = definition['maximum_active_processors']
+
+        includes = definition['includes']
+        excludes = definition['excludes']
+
+        stable_files.each do |file|
+          file.watch_folder ||= self
+          next if file.respond_to?(:ignore?) ? file.ignore? : ignored_file_paths.include?(file.path)
+          next if file.processing || file.processed
+
+          if includes && !includes.empty?
+            should_include = find_in_patterns(includes, file)
+            unless should_include
+              add_file_to_ignored_file_paths(file)
+              next
+            end
+          end
+
+          should_exclude = find_in_patterns(excludes, file)
+          if should_exclude
+            add_file_to_ignored_file_paths(file)
+            next
+          end
+
+          if @threaded
+            processors.keep_if { |k, v| k.processing }
+            if processors.length >= maximum_active_processors
+              logger.debug { "Maximum number of active processors reached for watch folder. #{wf.name || wf.paths}" }
+              break
+            end
+            t = Thread.new(file) do |file|
+              begin
+                process_stable_file(file)
+              rescue => e
+                logger.error { "Exception '#{e.message}' in thread for `#{name}` `#{file.path}`. " }
+                raise e
+              ensure
+                file.processing = false rescue nil
+              end
+            end
+            # t.join
+            processors[file] = t if file.processing
+          else
+            process_stable_file(file)
+          end
+
+        end
       end
 
       def run

data/lib/envoi/watch_folder_utility/watch_folder/handler/listen.rb

@@ -33,13 +33,13 @@ module Envoi
 
             def stable?
               return false if deleted?
-              return false if !exist?
+              return false unless exist?
 
               _min_stable_time = min_stable_time
               if _min_stable_time
-                 return ((Time.now - self[:event_timestamp]) >= _min_stable_time)
+                 ((Time.now - self[:event_timestamp]) >= _min_stable_time)
               else
-                return (self[:stable_poll_count] >= min_stable_poll_count)
+                (self[:stable_poll_count] >= min_stable_poll_count)
               end
             end
 
@@ -200,6 +200,7 @@ module Envoi
 
           # Really this is just for debugging as polling isn't used to determine file stability
           def poll(options = { })
+            # return if @min_stable_time
             should_increment_counter = options.fetch(:should_increment_counter, true)
 
             @previous_poll_time = @last_poll_time
@@ -208,7 +209,10 @@ module Envoi
             lock.synchronize do
               @known_path_map.each do |fp, f|
                 next if f.ignore?
-                next unless f.exist?
+                unless f.exist?
+                  logger.debug { "Skipping Missing File. #{f.summary}" }
+                  next
+                end
 
                 logger.debug { "Incrementing Stable Stats: #{f.summary}" }
                 f.last_poll_time = Time.now

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cantemo-portal-agent
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - John Whitson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-18 00:00:00.000000000 Z
+date: 2019-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asperalm
@@ -71,6 +71,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.5
   type: :runtime
@@ -78,6 +81,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.5
 - !ruby/object:Gem::Dependency