dev_commands 0.0.38 → 0.0.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee6609a2668a49ad907533a4b1798373f216628f
-  data.tar.gz: 38827b7705161ae96bfa17e2c75c6dc7cca95a7b
+  metadata.gz: 7474a5054ce8e1846be673781d0418af177fbe82
+  data.tar.gz: c05e5655ac9b8bf7c1f5b6fffda3007e517659ba
 SHA512:
-  metadata.gz: 463b15a0bbe02aa586816a7e33c52ec454b47926dd3ddd07839bcba6c3f02735e3561f5a444fffaa5cc8a30256281daa3c3a1c9e448d44bea7201759957177ad
-  data.tar.gz: ec7ec0b2896dc8471f9f2d4c5c336b5c38a1bc6fa2ba1a612abf885de54baa54259ce546b51050f8b7c770403a4af30cf5cf643970fd4f6e6681475a48c911ff
+  metadata.gz: 463a0a95113d8d2a41bb244457c5493f340169842d003778005a48efa7dc8efd5b26fd347e07667704259522ff25428f4eec13946de643da14e7cfe166bcffa1
+  data.tar.gz: 22dea8db2b587cbeb0659de3f2401f7f515d4dd9c9e84d552cc4a6a74eadaaac5c420ef8e6e0f25f59163117e7bb996481ad68c2696da9859c0a4b283e509684

data/lib/command.rb

@@ -3,10 +3,13 @@ require_relative('./array.rb')
 require_relative('./hash.rb')
 require_relative('./timer.rb')
 
+BUFFER_SIZE=1024 if(!defined?(BUFFER_SIZE))
+            
+          
 class Command < Hash
 	def initialize command
 
-        self[:input] = ''
+    self[:input] = ''
 		self[:timeout] = 0
 		self[:directory] = ''
 		self[:exit_code] = 0
@@ -28,12 +31,19 @@ class Command < Hash
         end
 	end
 
+  def quiet?
+    (self.has_key?(:quiet) && self[:quiet])
+  end
+
 	def execute
-		puts "#{self[:input]}" if(!self.has_key?(:quiet) || !self[:quiet])
 		pwd=Dir.pwd
 		Dir.chdir(self[:directory]) if(self.has_key?(:directory) && File.exists?(self[:directory]))
 		self[:directory] = pwd if(self[:directory].length==0)
-		
+    if(self[:timeout] > 0)
+      puts "#{self[:input]} (#{self[:directory]}) timeout #{self[:timeout].to_s}" if(!quiet?)
+    else
+		  puts "#{self[:input]} (#{self[:directory]})" if(!quiet?)
+    end
 		self[:machine] = Command.machine
 		self[:user] = Command.user
 
@@ -53,10 +63,23 @@ class Command < Hash
 		  self[:end_time] = Time.now
 		else
 			begin
-        self[:output],self[:error],status= Open3.capture3(self[:input])
-        self[:exit_code]=status.to_i
-			  self[:elapsed] = timer.elapsed_str
-			  self[:end_time] = Time.now
+        if(self[:timeout] <= 0)
+          self[:output],self[:error],status= Open3.capture3(self[:input])
+          self[:exit_code]=status.to_i
+  			  self[:elapsed] = timer.elapsed_str
+  			  self[:end_time] = Time.now
+        else
+          require_relative 'timeout.rb'
+          self[:output] = run_with_timeout(self[:input], self[:timeout], 1)
+
+          self[:elapsed] = timer.elapsed_str
+          self[:end_time] = Time.now
+          
+          if(timer.elapsed >= self[:timeout])
+            self[:exit_code]=1 
+            self[:error] = self[:error] + "timed out"
+          end
+        end
 			rescue Exception => e
 			  self[:elapsed] = timer.elapsed_str
 			  self[:end_time] = Time.now
@@ -68,13 +91,10 @@ class Command < Hash
         Dir.chdir(pwd) if pwd != Dir.pwd
 
         if(self[:exit_code] != 0)
-          if(!self.has_key?(:quiet) || !self[:quiet])
-        	  puts ' '
+          if(!quiet?)
         	  puts "exit_code=#{self[:exit_code]}"
-        	  puts ' '
         	  puts self[:output]
         	  puts self[:error]
-        	  puts ' '
           end
         	if(!self.has_key?(:ignore_failure) || !self[:ignore_failure])
         		raise "#{self[:input]} failed" 

data/lib/timeout.rb

@@ -0,0 +1,48 @@
+############################################################################
+# The following code was copied from https://gist.github.com/lpar/1032297
+# Gist title: lpar/timeout.rb
+############################################################################
+# Runs a specified shell command in a separate thread.
+# If it exceeds the given timeout in seconds, kills it.
+# Returns any output produced by the command (stdout or stderr) as a String.
+# Uses Kernel.select to wait up to the tick length (in seconds) between 
+# checks on the command's status
+#
+# If you've got a cleaner way of doing this, I'd be interested to see it.
+# If you think you can do it with Ruby's Timeout module, think again.
+def run_with_timeout(command, timeout, tick)
+  output = ''
+  begin
+    # Start task in another thread, which spawns a process
+    stdin, stderrout, thread = Open3.popen2e(command)
+    # Get the pid of the spawned process
+    pid = thread[:pid]
+    start = Time.now
+
+    while (Time.now - start) < timeout and thread.alive?
+      # Wait up to `tick` seconds for output/error data
+      Kernel.select([stderrout], nil, nil, tick)
+      # Try to read the data
+      begin
+        output << stderrout.read_nonblock(BUFFER_SIZE)
+      rescue IO::WaitReadable
+        # A read would block, so loop around for another select
+      rescue EOFError
+        # Command has completed, not really an error...
+        break
+      end
+    end
+    # Give Ruby time to clean up the other thread
+    sleep 1
+
+    if thread.alive?
+      # We need to kill the process, because killing the thread leaves
+      # the process alive but detached, annoyingly enough.
+      Process.kill("TERM", pid)
+    end
+  ensure
+    stdin.close if stdin
+    stderrout.close if stderrout
+  end
+  return output
+end

data/spec/command_spec.rb

@@ -66,6 +66,12 @@ describe Command do
     expect(cmd2[:input]).to eq("ruby --version")
   end
 
+  it "should be able to timeout" do
+    cmd=Command.new({ :input => 'ftp', :timeout => 0.5, :ignore_failure => true, :quiet => true})
+    cmd.execute
+    expect(cmd[:exit_code]).not_to eq(0)
+  end
+
   it "should be able to execute rake command in specific directory" do
     dir="#{File.dirname(__FILE__)}/tmp/rake_test"
     FileUtils.mkdir_p(dir) if(!File.exists?(dir))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dev_commands
 version: !ruby/object:Gem::Version
-  version: 0.0.38
+  version: 0.0.39
 platform: ruby
 authors:
 - Lou Parslow
@@ -151,6 +151,7 @@ files:
 - lib/setup.rb
 - lib/test.rb
 - lib/text.rb
+- lib/timeout.rb
 - lib/timer.rb
 - lib/update.rb
 - lib/upgrade.rb