chupa-text 1.1.9 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16a8f0167ee54c9339de2a91a3ca5dcd5550a19daac95228c57869a67e09f54c
-  data.tar.gz: 14d0a81b1f75aef784e20fc895037397c15f0dd88dbdcda0dbed58d7f7d16f58
+  metadata.gz: ae05a44da20490f2d7833d513cfc423819dd65ef5e1d6285e5a82db8482673fa
+  data.tar.gz: b202c67426ca48058422f169339c069cb6bc42e892a40fd9c72bda3463610b94
 SHA512:
-  metadata.gz: b6abd29982245d2817af96ef24bc2000ea99fcf89758c3eed0de8de70b3a1d25691d41898bc20c2661d5e521cb8c8d1b23fe6adeeea83b6f8515b3e9a298379f
-  data.tar.gz: 3afc26b51edff767f8b86a3cbfa55405e07217f2b42a69a00c698f97a3e0fc2b567ef0f25b39cf645d434876f52ad246ea00c1af71faa0fc926d3fe617b2143f
+  metadata.gz: 28126643d65dc7ef423dccc0f727be7b275db0005f66f4c40f0c8e5dafe8b159cdea2b6c8aeca98bf7e9979849cf531ddd5afad81f30c85d031dae925029e763
+  data.tar.gz: 498fb93a26bfd139d9fba1d15d00bbc17547b9e326c403301794b89f2548c78e8d000ed45c3404c3b0a00073e677c1783c64b1423357893c89326d60efeb07d3

data/doc/text/news.md

@@ -1,5 +1,12 @@
 # News
 
+## 1.2.0: 2019-03-03
+
+### Improvements
+
+  * Added support timeout for external command execution by
+    `CHUPA_TEXT_EXTERNAL_COMMAND_TIMEOUT` environment variable.
+
 ## 1.1.9: 2019-03-03
 
 ### Improvements

data/lib/chupa-text/external-command.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2014-2019  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2010  Yuto HAYAMIZU <y.hayamizu@gmail.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -20,6 +20,8 @@ require "pathname"
 
 module ChupaText
   class ExternalCommand
+    include Loggable
+
     attr_reader :path
     def initialize(path)
       @path = Pathname.new(path)
@@ -31,12 +33,11 @@ module ChupaText
       else
         options = {}
       end
-      spawn_options = options[:spawn_options] || {}
       pid = spawn(options[:env] || {},
                   @path.to_s,
                   *arguments,
-                  default_spawn_options.merge(spawn_options))
-      pid, status = Process.waitpid2(pid)
+                  spawn_options(options[:spawn_options]))
+      status = wait_process(pid, options[:timeout])
       status.success?
     end
 
@@ -51,101 +52,147 @@ module ChupaText
     end
 
     private
-    def default_spawn_options
-      SpawnLimitOptions.new.options
+    def spawn_options(user_options)
+      options = (user_options || {}).dup
+      apply_default_spawn_limit(options, :cpu, :int)
+      apply_default_spawn_limit(options, :as, :size)
+      options
     end
 
-    class SpawnLimitOptions
-      include Loggable
-
-      attr_reader :options
-      def initialize
-        @options = {}
-        set_default_options
+    def apply_default_spawn_limit(options, key, type)
+      # TODO: Workaround for Ruby 2.3.3p222
+      case key
+      when :cpu
+        option_key = :rlimit_cpu
+      when :as
+        option_key = :rlimit_as
+      else
+        option_key = :"rlimit_#{key}"
       end
+      return if options[option_key]
 
-      private
-      def set_default_options
-        set_option(:cpu, :int)
-        set_option(:as, :size)
+      tag = "[limit][#{key}]"
+      value =
+        ENV["CHUPA_TEXT_EXTERNAL_COMMAND_LIMIT_#{key.to_s.upcase}"] ||
+        # For backward compatibility
+        ENV["CHUPA_EXTERNAL_COMMAND_LIMIT_#{key.to_s.upcase}"]
+      value = send("parse_#{type}", tag, value)
+      return if value.nil?
+      rlimit_number = Process.const_get("RLIMIT_#{key.to_s.upcase}")
+      soft_limit, hard_limit = Process.getrlimit(rlimit_number)
+      if hard_limit < value
+        log_hard_limit_over_value(tag, value, hard_limit)
+        return nil
       end
+      limit_info = "soft-limit:#{soft_limit}, hard-limit:#{hard_limit}"
+      info("#{log_tag}#{tag}[set] <#{value}>(#{limit_info})")
 
-      def set_option(key, type)
-        value =
-          ENV["CHUPA_TEXT_EXTERNAL_COMMAND_LIMIT_#{key.to_s.upcase}"] ||
-          # For backward compatibility
-          ENV["CHUPA_EXTERNAL_COMMAND_LIMIT_#{key.to_s.upcase}"]
-        return if value.nil?
-        return if value.empty?
-        value = send("parse_#{type}", key, value)
-        return if value.nil?
-        rlimit_number = Process.const_get("RLIMIT_#{key.to_s.upcase}")
-        soft_limit, hard_limit = Process.getrlimit(rlimit_number)
-        if hard_limit < value
-          log_hard_limit_over_value(key, value, hard_limit)
-          return nil
-        end
-        limit_info = "soft-limit:#{soft_limit}, hard-limit:#{hard_limit}"
-        info("#{log_tag}[#{key}][set] <#{value}>(#{limit_info})")
-
-        # TODO: Workaround for Ruby 2.3.3p222
-        case key
-        when :cpu
-          @options[:rlimit_cpu] = value
-        when :as
-          @options[:rlimit_as] = value
-        else
-          @options[:"rlimit_#{key}"] = value
-        end
+      options[option_key] = value
+    end
+
+    def log_hard_limit_over_value(tag, value, hard_limit)
+      warn("#{log_tag}#{tag}[large] " +
+           "<#{value}>(hard-limit:#{hard_limit})")
+    end
+
+    def parse_int(tag, value)
+      return nil if value.nil?
+      return nil if value.empty?
+      begin
+        Integer(value)
+      rescue ArgumentError
+        log_invalid_value(tag, value, type, "int")
+        nil
       end
+    end
 
-      def parse_int(key, value)
-        begin
-          Integer(value)
-        rescue ArgumentError
-          log_invalid_value(key, value, type, "int")
-          nil
-        end
+    def parse_size(tag, value)
+      return nil if value.nil?
+      return nil if value.empty?
+      scale = 1
+      case value
+      when /GB?\z/i
+        scale = 1024 ** 3
+        number = $PREMATCH
+      when /MB?\z/i
+        scale = 1024 ** 2
+        number = $PREMATCH
+      when /KB?\z/i
+        scale = 1024 ** 1
+        number = $PREMATCH
+      when /B?\z/i
+        number = $PREMATCH
+      else
+        number = value
       end
+      begin
+        number = Float(number)
+      rescue ArgumentError
+        log_invalid_value(tag, value, "size")
+        return nil
+      end
+      (number * scale).to_i
+    end
 
-      def parse_size(key, value)
-        return nil if value.nil?
-        scale = 1
-        case value
-        when /GB?\z/i
-          scale = 1024 ** 3
-          number = $PREMATCH
-        when /MB?\z/i
-          scale = 1024 ** 2
-          number = $PREMATCH
-        when /KB?\z/i
-          scale = 1024 ** 1
-          number = $PREMATCH
-        when /B?\z/i
-          number = $PREMATCH
-        else
-          number = value
-        end
-        begin
-          number = Float(number)
-        rescue ArgumentError
-          log_invalid_value(key, value, "size")
-          return nil
-        end
-        (number * scale).to_i
+    def parse_time(tag, value)
+      return nil if value.nil?
+      return nil if value.empty?
+      scale = 1
+      case value
+      when /h\z/i
+        scale = 60 * 60
+        number = $PREMATCH
+      when /m\z/i
+        scale = 60
+        number = $PREMATCH
+      when /s\z/i
+        number = $PREMATCH
+      else
+        number = value
+      end
+      begin
+        number = Float(number)
+      rescue ArgumentError
+        log_invalid_value(tag, value, "time")
+        return nil
       end
+      (number * scale).to_f
+    end
+
+    def log_invalid_value(tag, value, type)
+      warn("#{log_tag}#{tag}[invalid] <#{value}>(#{type})")
+    end
 
-      def log_hard_limit_over_value(key, value, hard_limit)
-        warn("#{log_tag}[#{key}][large] <#{value}>(hard-limit:#{hard_limit})")
+    def wait_process(pid, timeout)
+      if timeout.nil?
+        timeout_env = ENV["CHUPA_TEXT_EXTERNAL_COMMAND_TIMEOUT"]
+        timeout = parse_time("[timeout]", timeout_env) if timeout_env
       end
 
-      def log_invalid_value(key, value, type)
-        warn("#{log_tag}[#{key}][invalid] <#{value}>(#{type})")
+      if timeout
+        status = wait_process_timeout(pid, timeout)
+        return status if status
+        Process.kill(:TERM, pid)
+        status = wait_process_timeout(pid, 5)
+        return status if status
+        Process.kill(:KILL, pid)
       end
+      _, status = Process.waitpid2(pid)
+      status
+    end
 
-      def log_tag
-        "[external-command][limit]"
+    def wait_process_timeout(pid, timeout)
+      limit = Time.now + timeout
+      while Time.now < limit
+        _, status = Process.waitpid2(pid, Process::WNOHANG)
+        return status if status
+        sleep(1)
       end
+      nil
+    end
+
+    def log_tag
+      "[external-command]"
     end
   end
 end

data/lib/chupa-text/version.rb

@@ -15,5 +15,5 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 module ChupaText
-  VERSION = "1.1.9"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chupa-text
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.2.0
 platform: ruby
 authors:
 - Kouhei Sutou