run_loop 1.2.6 → 1.2.7

data/lib/run_loop/environment.rb

@@ -0,0 +1,15 @@
+module RunLoop
+  class Environment
+
+    # Returns the user's Unix uid.
+    # @return [Integer] The user's Unix uid as an integer.
+    def self.uid
+      `id -u`.strip.to_i
+    end
+
+    # Returns true if debugging is enabled.
+    def self.debug?
+      ENV['DEBUG'] == '1'
+    end
+  end
+end

data/lib/run_loop/host_cache.rb

@@ -23,7 +23,8 @@ module RunLoop
     # The directory where the cache is stored.
     # @return [String] Expanded path to the default cache directory.
     def self.default_directory
-      File.expand_path('/tmp/run-loop-host-cache')
+      uid = RunLoop::Environment.uid
+      File.expand_path("/tmp/com.xamarin.calabash.run-loop/host-cache/#{uid}")
     end
 
     # The default cache.

data/lib/run_loop/instruments.rb

@@ -3,8 +3,6 @@ module RunLoop
   # A class for interacting with the instruments command-line tool
   #
   # @note All instruments commands are run in the context of `xcrun`.
-  #
-  # @todo Detect Instruments.app is running and pop an alert.
   class Instruments
 
     # Returns an Array of instruments process ids.
@@ -38,31 +36,11 @@ module RunLoop
     #  what version of Xcode is active.
     def kill_instruments(xcode_tools = RunLoop::XCTools.new)
       kill_signal = kill_signal xcode_tools
-      # It is difficult to test using a block.
       instruments_pids.each do |pid|
-        begin
-          if ENV['DEBUG'] == '1' or ENV['DEBUG_UNIX_CALLS'] == '1'
-            puts "Sending '#{kill_signal}' to instruments process '#{pid}'"
-          end
-          Process.kill(kill_signal, pid.to_i)
-          Process.wait(pid, Process::WNOHANG)
-        rescue Exception => e
-          if ENV['DEBUG'] == '1' or ENV['DEBUG_UNIX'] == '1'
-            puts "Could not kill and wait for process '#{pid.to_i}' - ignoring exception '#{e}'"
-          end
-        end
-
-        # Process.wait or `wait` here is pointless.  The pid may or may not be
-        # a child of this Process.
-        begin
-          if ENV['DEBUG'] == '1' or ENV['DEBUG_UNIX_CALLS'] == '1'
-            puts "Waiting for instruments '#{pid}' to terminate"
-          end
-          wait_for_process_to_terminate(pid, {:timeout => 2.0})
-        rescue Exception => e
-          if ENV['DEBUG'] == '1' or ENV['DEBUG_UNIX_CALLS'] == '1'
-            puts "Ignoring #{e.message}"
-          end
+        terminator = RunLoop::ProcessTerminator.new(pid, kill_signal, 'instruments')
+        unless terminator.kill_process
+          terminator = RunLoop::ProcessTerminator.new(pid, 'KILL', 'instruments')
+          terminator.kill_process
         end
       end
     end
@@ -80,8 +58,59 @@ module RunLoop
       end
     end
 
+    # Spawn a new instruments process in the context of `xcrun` and detach.
+    #
+    # @param [String] automation_template The template instruments will use when
+    #  launching the application.
+    # @param [Hash] options The launch options.
+    # @param [String] log_file The file to log to.
+    # @return [Integer] Returns the process id of the instruments process.
+    # @todo Do I need to enumerate the launch options in the docs?
+    # @todo Should this raise errors?
+    # @todo Is this jruby compatible?
+    def spawn(automation_template, options, log_file)
+      splat_args = spawn_arguments(automation_template, options)
+      if ENV['DEBUG'] == '1'
+        puts  "#{Time.now} xcrun #{splat_args.join(' ')} >& #{log_file}"
+        $stdout.flush
+      end
+      pid = Process.spawn('xcrun', *splat_args, {:out => log_file, :err => log_file})
+      Process.detach(pid)
+      pid.to_i
+    end
+
     private
 
+    # @!visibility private
+    # Parses the run-loop options hash into an array of arguments that can be
+    # passed to `Process.spawn` to launch instruments.
+    def spawn_arguments(automation_template, options)
+      array = ['instruments']
+      array << '-w'
+      array << options[:udid]
+
+      trace = options[:results_dir_trace]
+      if trace
+        array << '-D'
+        array << trace
+      end
+
+      array << '-t'
+      array << automation_template
+
+      array << options[:bundle_dir_or_bundle_id]
+
+      {
+            'UIARESULTSPATH' => options[:results_dir],
+            'UIASCRIPT' => options[:script]
+      }.each do |key, value|
+        array << '-e'
+        array << key
+        array << value
+      end
+      array + options.fetch(:args, [])
+    end
+
     # @!visibility private
     #
     # ```
@@ -96,7 +125,7 @@ module RunLoop
     # $ ps x -o pid,command | grep -v grep | grep instruments
     # 98082 /Xcode/6.0.1/Xcode.app/Contents/Developer/usr/bin/instruments -w < args >
     # ```
-    FIND_PIDS_CMD = 'ps x -o pid,command | grep -v grep | grep instruments'
+    INSTRUMENTS_FIND_PIDS_CMD = 'ps x -o pid,command | grep -v grep | grep instruments'
 
     # @!visibility private
     #
@@ -106,7 +135,7 @@ module RunLoop
     #  processes.
     # @return [String] A ps-style list of process details.  The details returned
     #  are controlled by the `ps_cmd`.
-    def ps_for_instruments(ps_cmd=FIND_PIDS_CMD)
+    def ps_for_instruments(ps_cmd=INSTRUMENTS_FIND_PIDS_CMD)
       `#{ps_cmd}`.strip
     end
 
@@ -117,8 +146,7 @@ module RunLoop
     # @return [Boolean] True if the details describe an instruments process.
     def is_instruments_process?(ps_details)
       return false if ps_details.nil?
-      (ps_details[/\/usr\/bin\/instruments/, 0] or
-            ps_details[/sh -c xcrun instruments/, 0]) != nil
+      ps_details[/\/usr\/bin\/instruments/, 0] != nil
     end
 
     # @!visibility private
@@ -129,7 +157,7 @@ module RunLoop
     #  processes.
     # @return [Array<Integer>] An array of integer pids for instruments
     #  processes.  Returns an empty list if no instruments process are found.
-    def pids_from_ps_output(ps_cmd=FIND_PIDS_CMD)
+    def pids_from_ps_output(ps_cmd=INSTRUMENTS_FIND_PIDS_CMD)
       ps_output = ps_for_instruments(ps_cmd)
       lines = ps_output.lines("\n").map { |line| line.strip }
       lines.map do |line|
@@ -166,39 +194,5 @@ module RunLoop
     def kill_signal(xcode_tools = RunLoop::XCTools.new)
       xcode_tools.xcode_version_gte_6? ? 'QUIT' : 'TERM'
     end
-
-    # @!visibility private
-    # Wait for Unix process with id `pid` to terminate.
-    #
-    # @param [Integer] pid The id of the process we are waiting on.
-    # @param [Hash] options Values to control the behavior of this method.
-    # @option options [Float] :timeout (2.0) How long to wait for the process to
-    #  terminate.
-    # @option options [Float] :interval (0.1) The polling interval.
-    # @option options [Boolean] :raise_on_no_terminate (false) Should an error
-    #  be raised if process does not terminate.
-    # @raise [RuntimeError] If process does not terminate and
-    #  options[:raise_on_no_terminate] is truthy.
-    def wait_for_process_to_terminate(pid, options={})
-      default_opts = {:timeout => 2.0,
-                      :interval => 0.1,
-                      :raise_on_no_terminate => false}
-      merged_opts = default_opts.merge(options)
-
-      cmd = "ps #{pid} -o pid | grep #{pid}"
-      poll_until = Time.now + merged_opts[:timeout]
-      delay = merged_opts[:interval]
-      has_terminated = false
-      while Time.now < poll_until
-        has_terminated = `#{cmd}`.strip == ''
-        break if has_terminated
-        sleep delay
-      end
-
-      if merged_opts[:raise_on_no_terminate] and not has_terminated
-        details = `ps -p #{pid} -o pid,comm | grep #{pid}`.strip
-        raise RuntimeError, "Waited #{merged_opts[:timeout]} s for process '#{details}' to terminate"
-      end
-    end
   end
 end

data/lib/run_loop/lldb.rb

@@ -0,0 +1,55 @@
+module RunLoop
+
+  # A class for interacting with the lldb command-line tool
+  class LLDB
+
+    # Returns a list of lldb pids.
+    # @return [Array<Integer>] An array of integer pids.
+    def self.lldb_pids
+      ps_output = `#{LLDB_FIND_PIDS_CMD}`.strip
+      lines = ps_output.lines("\n").map { |line| line.strip }
+      lldb_processes = lines.select { |line| self.is_lldb_process?(line) }
+      lldb_processes.map do |ps_description|
+        tokens = ps_description.strip.split(' ').map { |token| token.strip }
+        pid = tokens.fetch(0, nil)
+        if pid.nil?
+          nil
+        else
+          pid.to_i
+        end
+      end.compact.sort
+    end
+
+    # @!visibility private
+    # Is the process described an lldb process?
+    #
+    # @param [String] ps_details Details about a process as returned by `ps`
+    # @return [Boolean] True if the details describe an lldb process.
+    def self.is_lldb_process?(ps_details)
+      return false if ps_details.nil?
+      ps_details[/Contents\/Developer\/usr\/bin\/lldb/, 0] != nil
+    end
+
+    # Attempts to gracefully kill all running lldb processes.
+    def self.kill_lldb_processes
+      self.lldb_pids.each do |pid|
+        unless self.kill_with_signal(pid, 'TERM')
+          unless self.kill_with_signal(pid, 'QUIT')
+            self.kill_with_signal(pid, 'KILL')
+          end
+        end
+      end
+    end
+
+    private
+
+    # @!visibility private
+    LLDB_FIND_PIDS_CMD = 'ps x -o pid,command | grep -v grep | grep lldb'
+
+    # @!visibility private
+    def self.kill_with_signal(pid, signal)
+      RunLoop::ProcessTerminator.new(pid, signal, 'lldb').kill_process
+    end
+
+  end
+end

data/lib/run_loop/plist_buddy.rb

@@ -68,6 +68,23 @@ module RunLoop
       res == ''
     end
 
+    # Creates an new empty plist at `path`.
+    #
+    # Is not responsible for creating directories or ensuring write permissions.
+    #
+    # @param [String] path Where to create the new plist.
+    def create_plist(path)
+      File.open(path, 'w') do |file|
+        file.puts "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        file.puts "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">"
+        file.puts "<plist version=\"1.0\">"
+        file.puts '<dict>'
+        file.puts '</dict>'
+        file.puts '</plist>'
+      end
+      path
+    end
+
     private
 
     # returns the path to the PlistBuddy executable
@@ -168,6 +185,5 @@ module RunLoop
 
       "#{plist_buddy} -c #{cmd_part} \"#{file}\""
     end
-
   end
-end
+end

data/lib/run_loop/process_terminator.rb

@@ -0,0 +1,140 @@
+module RunLoop
+
+  # A class for terminating processes and waiting for them to die.
+  class ProcessTerminator
+
+    # @!attribute [r] pid
+    # The process id of the process.
+    # @return [Integer] The pid.
+    attr_reader :pid
+
+    # @!attribute [r] kill_signal
+    # The kill signal to send to the process. Can be a Unix signal name or an
+    #   Integer.
+    # @return [Integer, String] The kill signal.
+    attr_reader :kill_signal
+
+    # @!attribute [r] display_name
+    # The process name to use log messages and exceptions.  Not used to find
+    #   or otherwise interact with the process.
+    # @return [String] The display name.
+    attr_reader :display_name
+
+    # @!attribute [r] options
+    # Options to control the behavior of `kill_process`.
+    # @return [Hash] A hash of options.
+    attr_reader :options
+
+    # Create a new process terminator.
+    #
+    # @param[String,Integer] pid The process pid.
+    # @param[String, Integer] kill_signal The kill signal to send to the process.
+    # @param[String] display_name The name of the process to kill. Used only
+    #  in log messages and exceptions.
+    # @option options [Float] :timeout (2.0) How long to wait for the process to
+    #  terminate.
+    # @option options [Float] :interval (0.1) The polling interval.
+    # @option options [Boolean] :raise_on_no_terminate (false) Should an error
+    #  be raised if process does not terminate.
+    def initialize(pid, kill_signal, display_name, options={})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @pid = pid.to_i
+      @kill_signal = kill_signal
+      @display_name = display_name
+    end
+
+    # Try to kill the process identified by `pid`.
+    #
+    # After sending  `kill_signal` to `pid`, wait for the process to terminate.
+    #
+    # @return [Boolean] Returns true if the process was terminated or is no
+    #  longer alive.
+    # @raise [SignalException] Raised on an unhandled `Process.kill` exception.
+    #   Errno:ESRCH and Errno:EPERM are _handled_ exceptions; all others will
+    #   be raised.
+    def kill_process
+      return true unless process_alive?
+
+      debug_logging = RunLoop::Environment.debug?
+      begin
+        if debug_logging
+          puts "Sending '#{kill_signal}' to #{display_name} process '#{pid}'"
+        end
+        Process.kill(kill_signal, pid.to_i)
+        # Don't wait.
+        # We might not own this process and a WNOHANG would be a nop.
+        # Process.wait(pid, Process::WNOHANG)
+      rescue Errno::ESRCH
+        if debug_logging
+          puts "Process with pid '#{pid}' does not exist; nothing to do."
+        end
+        # Return early; there is no need to wait if the process does not exist.
+        return true
+      rescue Errno::EPERM
+        if debug_logging
+          puts "Cannot kill process '#{pid}' with '#{kill_signal}'; not a child of this process"
+        end
+      rescue SignalException => e
+        raise e.message
+      end
+
+      if debug_logging
+        puts "Waiting for #{display_name} '#{pid}' to terminate"
+      end
+      wait_for_process_to_terminate
+    end
+
+    # Is the process `pid` alive?
+    # @return [Boolean] Returns true if the process is still alive.
+    def process_alive?
+      begin
+        Process.kill(0, pid.to_i)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+    end
+
+    private
+
+    # @!visibility private
+    # The default options for waiting on a process to terminate.
+    DEFAULT_OPTIONS =
+          {
+                :timeout => 2.0,
+                :interval => 0.1,
+                :raise_on_no_terminate => false
+          }
+
+    # @!visibility private
+    # The details of the process reported by `ps`.
+    def ps_details
+      `xcrun ps -p #{pid} -o pid,comm | grep #{pid}`.strip
+    end
+
+    # @!visibility private
+    # Wait for the process to terminate by polling.
+    def wait_for_process_to_terminate
+      now = Time.now
+      poll_until = now + options[:timeout]
+      delay = options[:interval]
+      has_terminated = false
+      while Time.now < poll_until
+        has_terminated = !process_alive?
+        break if has_terminated
+        sleep delay
+      end
+
+      if RunLoop::Environment.debug?
+        puts "Waited for #{Time.now - now} seconds for #{display_name} with '#{pid}' to terminate"
+      end
+
+      if @options[:raise_on_no_terminate] and !has_terminated
+        raise "Waited #{options[:timeout]} seconds for #{display_name} (#{ps_details}) to terminate"
+      end
+      has_terminated
+    end
+  end
+end

data/lib/run_loop/process_waiter.rb

@@ -0,0 +1,85 @@
+module RunLoop
+
+  # A class for waiting on processes.
+  class ProcessWaiter
+
+    attr_reader :process_name
+
+    def initialize(process_name, options={})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @process_name = process_name
+    end
+
+    # Collect a list of Integer pids.
+    # @return [Array<Integer>] An array of integer pids for the `process_name`
+    def pids
+      process_info = `ps x -o pid,comm | grep -v grep | grep #{process_name}`
+      process_array = process_info.split("\n")
+      process_array.map { |process| process.split(' ').first.strip.to_i }
+    end
+
+    # Is the `process_name` a running?
+    def running_process?
+      !pids.empty?
+    end
+
+    # Wait for `process_name` to start.
+    def wait_for_any
+      return true if running_process?
+
+      now = Time.now
+      poll_until = now + @options[:timeout]
+      delay = @options[:interval]
+      is_alive = false
+      while Time.now < poll_until
+        is_alive = running_process?
+        break if is_alive
+        sleep delay
+      end
+
+      if RunLoop::Environment.debug?
+        puts "Waited for #{Time.now - now} seconds for '#{process_name}' to start."
+      end
+
+      if @options[:raise_on_timeout] and !is_alive
+        raise "Waited #{@options[:timeout]} seconds for '#{process_name}' to start."
+      end
+      is_alive
+    end
+
+    # Wait for all `process_name` to finish.
+    def wait_for_none
+      return true if !running_process?
+
+      now = Time.now
+      poll_until = now + @options[:timeout]
+      delay = @options[:interval]
+      has_terminated = false
+      while Time.now < poll_until
+        has_terminated = !self.running_process?
+        break if has_terminated
+        sleep delay
+      end
+
+      if RunLoop::Environment.debug?
+        puts "Waited for #{Time.now - now} seconds for '#{process_name}' to die."
+      end
+
+      if @options[:raise_on_timeout] and !has_terminated
+        raise "Waited #{@options[:timeout]} seconds for '#{process_name}' to die."
+      end
+      has_terminated
+    end
+
+    private
+
+    # @!visibility private
+    DEFAULT_OPTIONS =
+          {
+                :timeout => 10.0,
+                :interval => 0.1,
+                :raise_on_timeout => false
+          }
+  end
+end
+