derelict 0.4.2.travis.118 → 0.4.2.travis.120

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NGRhZDE3YWQyNDRhZmZlYzQwMDYyZWVhN2M3MTU2MjM0ZTJjOTY2MA==
+    ODAwZWNlOGQwZjUzMTI0MjBlODhhZmE4YzlmYjU2MDY3ZDgzNTdkMA==
   data.tar.gz: !binary |-
-    NjliY2FlNzI2OTQxOWI3OGQyMWMwMThlMmYzNzJjZjBhYWM0ZGE1Ng==
+    YjAxYmQ1YWEzN2ZkNDU0Y2U3ZWZiYmZmZmEwZDE3NTcxZjM2NTg4YQ==
 SHA512:
   metadata.gz: !binary |-
-    OGE3OWJmZDQ2NmYwMWEwYWQwMTI5ZDk4NjRmMWFhZGNhMjdmMjE0MmFkOGM2
-    NTJmMDA0YTBkZWI4ZjdjNzY4N2JmZDkxMTA0ZjM0NTk2NDFlMTg3NmI5ZWM2
-    MjgxMzU2NDdiZWMxNTUyZTUwZDdjM2QzZmEyNDI5ZmJjNzM3YjY=
+    MTk5MjBkNzhiZWI1OTA5ZWVjNjM5ODkzMTE1ODA4YTk0NzA4YmQwNTA5ZWZi
+    ODNjY2ViYTJmZjQ0ODk3OWVhYjEyYjcxMjJjNWEzYTJjOGM3ODMyYzRiMDUx
+    NGUzNmVhNTlkMDc2MjdhMmFkNTk2ZTg2M2JkMDRiYThmNjA3MWI=
   data.tar.gz: !binary |-
-    NzZiYjNlOTQxNDFjNTQ3OWQ3YWFjNjhjMDA0MjE0NGZmNGM5NjQxYjMwYmJl
-    Zjc3OTU1YmM1Y2MzNDEzMmU3YTRiN2E4ZTMwYmIxNjQ3NDI2YjgwMjc0NzJl
-    N2RhN2UzNTQxOTE5ZGY1YzBkOGZhMThmNWEzY2ZmMGFmNTk2MDk=
+    MjE5MDE0ZGUyM2EzNjVmZGMwMjA4YjNmNmM1NGJjMDM2ZWRkMmI5OGU3ZjNi
+    ODVmZDcxZjIyZGI0ZDIxMDU0MTFhMDFkNjMyN2FkNTE3NTNiZTFkMTM2OTA3
+    NzljZjI0MmQ3MWRkMmZkZTgwM2JhMWY5NGMyY2I1N2MyOTE2YmQ=

data/lib/derelict/executer.rb

@@ -4,7 +4,10 @@ module Derelict
   # The safety involved is mainly ensuring that the command is
   # gracefully terminated if this process is about to terminate.
   class Executer
-    attr_reader :stdout, :stderr
+    # Include "logger" method to get a logger for this class
+    include Utils::Logger
+
+    attr_reader :stdout, :stderr, :pid
 
     # Executes <tt>command</tt> and returns after execution
     #
@@ -43,6 +46,8 @@ module Derelict
     def initialize(options = {})
       @options = {:mode => :lines, :no_buffer => false}.merge(options)
 
+      logger.info "Initializing with options: #{@options.inspect}"
+
       if @options[:mode] == :chars
         @reader = proc {|s| s.getc }
       else
@@ -61,12 +66,22 @@ module Derelict
     #              second parameter is stderr; only one will contain
     #              data, the other will be nil)
     def execute(command, &block)
+      logger.info "Executing command '#{command}'"
       reset
-      pid, stdin, stdout, stderr = Open4::popen4(command)
+      pid, stdin, stdout_stream, stderr_stream = Open4::popen4(command)
+      @pid = pid
+      stdin.close rescue nil
 
       save_exit_status(pid)
-      forward_signals_to(pid) { handle_streams stdout, stderr, &block }
+      forward_signals_to(pid) do
+        handle_streams stdout_stream, stderr_stream, &block
+      end
+
       self
+    ensure
+      logger.debug "Closing stdout and stderr streams for process"
+      stdout.close rescue nil
+      stderr.close rescue nil
     end
 
     # Determines whether the last command was successful or not
@@ -84,9 +99,11 @@ module Derelict
       # This is done when first initialising, and just before a command
       # is run, to get rid of the previous command's data.
       def reset
+        logger.debug "Resetting executer state"
         @stdout = ''
         @stderr = ''
         @success = nil
+        @pid = nil
       end
 
       # Waits for the exit status of a process (in a thread) saving it
@@ -94,9 +111,13 @@ module Derelict
       # This will set the @status instance variable to true if the exit
       # status was 0, or false if the exit status was anything else.
       def save_exit_status(pid)
+        logger.debug "Spawning thread to monitor process ID #{pid}"
+        @success = nil
         Thread.start do
-          @success = nil
-          @success = (Process.waitpid2(pid).last.exitstatus == 0)
+          logger.debug "Thread started, waiting for PID #{pid}"
+          status = Process.waitpid2(pid).last.exitstatus
+          logger.debug "Process exited with status #{status}"
+          @success = (status == 0)
         end
       end
 
@@ -107,26 +128,41 @@ module Derelict
       #              defaults to SIGINT only)
       def forward_signals_to(pid, signals = %w[INT])
         # Set up signal handlers
+        logger.debug "Setting up signal handlers for #{signals.inspect}"
+        signal_count = 0
         signals.each do |signal|
-          Signal.trap(signal) { Process.kill signal, pid }
+          Signal.trap(signal) do
+            Process.kill signal, pid rescue nil
+
+            # If this is the second time we've received and forwarded
+            # on the signal, make sure next time we just give up.
+            reset_handlers_for signals if ++signal_count >= 2
+          end
         end
 
         # Run the block now that the signals are being forwarded
         yield
+      ensure
+        # Always good to make sure we clean up after ourselves
+        reset_handlers_for signals
+      end
 
-        # Reset signal handlers
-        signals.each do |signal|
-          Signal.trap signal, "DEFAULT"
-        end
+      # Resets the handlers for particular signals to the default
+      #
+      #   * signals: An array of signal names to reset the handlers for
+      def reset_handlers_for(signals)
+        logger.debug "Resetting signal handlers for #{signals.inspect}"
+        signals.each {|signal| Signal.trap signal, "DEFAULT" }
       end
 
       # Manages reading from the stdout and stderr streams
       #
-      #   * stdout: The process' stdout stream
-      #   * stderr: The process' stderr stream
-      #   * block:  The block to pass any read data to (optional)
-      def handle_streams(stdout, stderr, &block)
-        streams = [stdout, stderr]
+      #   * stdout_stream: The process' stdout stream
+      #   * stderr_stream: The process' stderr stream
+      #   * block:         The block to pass output to (optional)
+      def handle_streams(stdout_stream, stderr_stream, &block)
+        logger.debug "Monitoring stdout/stderr streams for output"
+        streams = [stdout_stream, stderr_stream]
         until streams.empty?
           # Find which streams are ready for reading, timeout 0.1s
           selected, = select(streams, nil, nil, 0.1)
@@ -136,14 +172,21 @@ module Derelict
 
           selected.each do |stream|
             if stream.eof?
-              streams.delete(stream) unless @success.nil?
+              logger.debug "Stream reached end-of-file"
+              if @success.nil?
+                logger.debug "Process hasn't finished, keeping stream"
+              else
+                logger.debug "Removing stream"
+                streams.delete(stream)
+              end
               next
             end
 
             while data = @reader.call(stream)
               data = ((@options[:mode] == :chars) ? data.chr : data)
-              stream_name = (stream == stdout) ? :stdout : :stderr
+              stream_name = (stream == stdout_stream) ? :stdout : :stderr
               output data, stream_name, &block unless block.nil?
+              buffer data, stream_name unless @options[:no_buffer]
             end
           end
         end
@@ -167,14 +210,18 @@ module Derelict
         else
           yield data if stream_name == :stdout
         end
+      end
 
-        # Add to the buffers
-        unless @options[:no_buffer]
-          if stream_name == :stdout
-            @stdout += data
-          else
-            @stderr += data
-          end
+      # Buffers data for a stream into this object to retrieve it later
+      #
+      #   * data:        The data that should be added to the buffer
+      #   * stream_name: Which stream the data came from (:stdout or
+      #                  :stderr)
+      def buffer(data, stream_name)
+        if stream_name == :stdout
+          @stdout += data
+        else
+          @stderr += data
         end
       end
   end

data/lib/derelict/utils/logger.rb

@@ -22,8 +22,9 @@ module Derelict
       private
         # A block that can be passed to #execute to log the output
         def shell_log_block
-          Proc.new do |line|
-            logger(:type => :external).info line
+          Proc.new do |stdout, stderr|
+            # Only stdout or stderr is populated, the other will be nil
+            logger(:type => :external).info(stdout || stderr)
           end
         end
 

data/lib/derelict/virtual_machine.rb

@@ -160,15 +160,6 @@ module Derelict
         connection.execute! *arguments, &block
       end
 
-      # A block that can be passed to #execute to log the output
-      def shell_log_block
-        Proc.new do |stdout, stderr|
-          # Only stdout or stderr is populated, the other will be nil
-          logger(:type => :external).info(stdout || stderr)
-        end
-      end
-      memoize :shell_log_block
-
       # Retrieves the arguments for a particular action
       #
       #   * action: The symbol representing the action (one of :up,

data/spec/derelict/box/manager_spec.rb

@@ -71,7 +71,7 @@ describe Derelict::Box::Manager do
     subject { manager.add box_name, source, :log => log }
 
     before do
-      expect(instance).to receive(:execute!).with(:box, "add", box_name, source).and_yield("test").and_return(result)
+      expect(instance).to receive(:execute!).with(:box, "add", box_name, source).and_yield("test", nil).and_return(result)
     end
 
     it { should be result }
@@ -103,7 +103,7 @@ describe Derelict::Box::Manager do
     subject { manager.remove box_name, :provider => provider, :log => log }
 
     before do
-      expect(instance).to receive(:execute!).with(:box, "remove", box_name, provider).and_yield("test").and_return(result)
+      expect(instance).to receive(:execute!).with(:box, "remove", box_name, provider).and_yield("test", nil).and_return(result)
     end
 
     it { should be result }

data/spec/derelict/executer_spec.rb

@@ -55,6 +55,30 @@ describe Derelict::Executer do
         let(:command) { "false" }
         its(:success?) { should be_false }
       end
+
+      # Unfortunately this part is even worse. It seems to work though!
+      # The basic idea is for a thread to kill *this* process once the
+      # sub-process has started. It's still relatively fast, and is at
+      # least an accurate way to model the real-world use.
+      context "when main process is receives a signal" do
+        subject {
+          Thread.new do
+            # Wait for the sub-process to start
+            sleep 0.01 while executer.pid.nil?
+
+            # Send SIGINT to this process, it should get forwarded on
+            # to the sub-process
+            Process.kill "INT", Process.pid
+          end
+
+          # Start the sub-process
+          executer.execute "sleep 10"
+        }
+
+        specify "the sub-process should get killed" do
+          expect(subject.success?).to be_false
+        end
+      end
     end
 
     context "with a block" do

data/spec/derelict/plugin/manager_spec.rb

@@ -91,7 +91,7 @@ describe Derelict::Plugin::Manager do
     subject { manager.install plugin_name, :version => version, :log => log }
 
     before do
-      expect(instance).to receive(:execute!).with(:plugin, "install", plugin_name, '--plugin-version', version).and_yield("test").and_return(result)
+      expect(instance).to receive(:execute!).with(:plugin, "install", plugin_name, '--plugin-version', version).and_yield("test", nil).and_return(result)
     end
 
     it { should be result }
@@ -122,7 +122,7 @@ describe Derelict::Plugin::Manager do
     subject { manager.uninstall plugin_name, :log => log }
 
     before do
-      expect(instance).to receive(:execute!).with(:plugin, "uninstall", plugin_name).and_yield("test").and_return(result)
+      expect(instance).to receive(:execute!).with(:plugin, "uninstall", plugin_name).and_yield("test", nil).and_return(result)
     end
 
     it { should be result }
@@ -153,7 +153,7 @@ describe Derelict::Plugin::Manager do
     subject { manager.update plugin_name, :log => log }
 
     before do
-      expect(instance).to receive(:execute!).with(:plugin, "update", plugin_name).and_yield("test").and_return(result)
+      expect(instance).to receive(:execute!).with(:plugin, "update", plugin_name).and_yield("test", nil).and_return(result)
     end
 
     it { should be result }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: derelict
 version: !ruby/object:Gem::Version
-  version: 0.4.2.travis.118
+  version: 0.4.2.travis.120
 platform: ruby
 authors:
 - Brad Feehan