run_loop 1.5.6 → 2.0.0

data/lib/run_loop/device.rb

@@ -3,6 +3,33 @@ module RunLoop
 
     include RunLoop::Regex
 
+    # Starting in Xcode 7, iOS 9 simulators have a new "booting" state.
+    #
+    # The simulator must completely boot before run-loop tries to do things
+    # like installing an app or clearing an app sandbox.  Run-loop tries to
+    # wait for a the simulator stabilize by watching the checksum of the
+    # simulator directory and the simulator log.
+    #
+    # On resource constrained devices or CI systems, the default settings may
+    # not work.
+    #
+    # You can override these values if they do not work in your environment.
+    #
+    # For cucumber users, the best place to override would be in your
+    # features/support/env.rb.
+    #
+    # For example:
+    #
+    # RunLoop::Device::SIM_STABLE_STATE_OPTIONS[:timeout] = 60
+    SIM_STABLE_STATE_OPTIONS = {
+      # The maximum amount of time to wait for the simulator
+      # to stabilize.  No errors are raised if this timeout is
+      # exceeded - if the default 30 seconds has passed, the
+      # simulator is probably stable enough for subsequent
+      # operations.
+      :timeout => RunLoop::Environment.ci? ? 120 : 30
+    }
+
     attr_reader :name
     attr_reader :version
     attr_reader :udid
@@ -117,22 +144,12 @@ Please update your sources.))
     # Returns and instruments-ready device identifier that is a suitable value
     # for DEVICE_TARGET environment variable.
     #
-    # @note As of 1.5.0, the XCTools optional argument has become a non-optional
-    #  Xcode argument.
-    #
-    # @param [RunLoop::Xcode, RunLoop::XCTools] xcode The version of the active
+    # @param [RunLoop::Xcode] xcode The version of the active
     #  Xcode.
     # @return [String] An instruments-ready device identifier.
     # @raise [RuntimeError] If trying to obtain a instruments-ready identifier
     #  for a simulator when Xcode < 6.
     def instruments_identifier(xcode=SIM_CONTROL.xcode)
-      if xcode.is_a?(RunLoop::XCTools)
-        RunLoop.deprecated('1.5.0',
-                           %q(
-RunLoop::XCTools has been replaced with a non-optional RunLoop::Xcode argument.
-Please update your sources to pass an instance of RunLoop::Xcode))
-      end
-
       if physical_device?
         udid
       else
@@ -292,19 +309,27 @@ Please update your sources to pass an instance of RunLoop::Xcode))
     def simulator_wait_for_stable_state
       require 'securerandom'
 
+      # How long to wait between stability checks.
       delay = 0.5
 
       first_launch = false
 
+      # At launch there is a brief moment when the SHA and
+      # the log file are are stable.  Then a bunch of activity
+      # occurs.  This is the quiet time.
+      #
+      # Starting in iOS 9, simulators display at _booting_ screen
+      # at first launch.  At first launch, these simulators need
+      # a much longer quiet time.
       if version >= RunLoop::Version.new('9.0')
         first_launch = simulator_data_dir_size < 20
-        quiet_time = 2
+        quiet_time = 2.0
       else
-        quiet_time = 1
+        quiet_time = 1.0
       end
 
       now = Time.now
-      timeout = 30
+      timeout = SIM_STABLE_STATE_OPTIONS[:timeout]
       poll_until = now + timeout
       quiet = now + quiet_time
 
@@ -315,14 +340,21 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       sha_fn = lambda do |data_dir|
         begin
           # Typically, this returns in < 0.3 seconds.
-          Timeout.timeout(2, TimeoutError) do
-            RunLoop::Directory.directory_digest(data_dir)
+          Timeout.timeout(10, TimeoutError) do
+            # Errors are ignorable and users are confused by the messages.
+            options = { :handle_errors_by => :ignoring }
+            RunLoop::Directory.directory_digest(data_dir, options)
           end
         rescue => _
           SecureRandom.uuid
         end
       end
 
+      RunLoop.log_debug("Waiting for simulator to stabilize with timeout: #{timeout}")
+      if first_launch
+        RunLoop.log_debug("Detected the first launch of an iOS >= 9.0 Simulator")
+      end
+
       current_line = nil
 
       while Time.now < poll_until do

data/lib/run_loop/directory.rb

@@ -22,8 +22,27 @@ module RunLoop
     # Computes the digest of directory.
     #
     # @param path A path to a directory.
+    # @param options Control the behavior of the method.
+    # @option options :handle_errors_by (:raising) Controls what to do when
+    #   File.read causes an error.  The default behavior is to raise.  Other
+    #   options are: :logging and :ignoring.  Logging will only happen if
+    #   running in debug mode.
+    #
     # @raise ArgumentError When `path` is not a directory or path does not exist.
-    def self.directory_digest(path)
+    # @raise ArgumentError When options[:handle_errors_by] has n unsupported value.
+    def self.directory_digest(path, options={})
+      default_options = {
+        :handle_errors_by => :raising
+      }
+
+      merged_options = default_options.merge(options)
+      handle_errors_by = merged_options[:handle_errors_by]
+      unless [:raising, :logging, :ignoring].include?(handle_errors_by)
+        raise ArgumentError,
+%Q{Expected :handle_errors_by to be :raising, :logging, or :ignoring;
+found '#{handle_errors_by}'
+}
+      end
 
       unless File.exist?(path)
         raise ArgumentError, "Expected '#{path}' to exist"
@@ -47,21 +66,26 @@ module RunLoop
           begin
             sha << File.read(file)
           rescue => e
-            if debug
-              RunLoop.log_warn(%Q{
-RunLoop::Directory.directory_digest raised an error:
-
-#{e}
-
-while trying to find the SHA of this file:
-
-#{file}
-
-Please report this here:
-
-https://github.com/calabash/run_loop/issues
-
-})
+            case handle_errors_by
+            when :logging
+              message =
+%Q{RunLoop::Directory.directory_digest raised an error:
+
+         #{e}
+
+       while trying to find the SHA of this file:
+
+         #{file}
+
+       This is not a fatal error; it can be ignored.
+}
+              RunLoop.log_debug(message)
+            when :raising
+              raise e.class, e.message
+            when :ignoring
+               # nop
+            else
+               # nop
             end
           end
         end

data/lib/run_loop/dylib_injector.rb

@@ -7,6 +7,16 @@ module RunLoop
   # Injects dylibs into running executables using lldb.
   class DylibInjector
 
+    # Options for controlling how often to retry dylib injection.
+    #
+    # Try 3 times for 10 seconds each try with a sleep of 2 seconds
+    # between tries.
+    RETRY_OPTIONS = {
+      :tries => 3,
+      :interval => 2,
+      :timeout => 10
+    }
+
     # @!attribute [r] process_name
     # The name of the process to inject the dylib into.  This should be obtained
     #  by inspecting the Info.plist in the app bundle.
@@ -18,6 +28,9 @@ module RunLoop
     # @return [String] The dylib_path
     attr_reader :dylib_path
 
+    # @!visibility private
+    attr_reader :xcrun
+
     # Create a new dylib injector.
     # @param [String] process_name The name of the process to inject the dylib
     #  into.  This should be obtained by inspecting the Info.plist in the app
@@ -25,92 +38,99 @@ module RunLoop
     # @param [String] dylib_path The path the dylib to inject.
     def initialize(process_name, dylib_path)
       @process_name = process_name
-      @dylib_path = dylib_path
+      @dylib_path = Shellwords.shellescape(dylib_path)
+    end
+
+    def xcrun
+      @xcrun ||= RunLoop::Xcrun.new
     end
 
     # Injects a dylib into a a currently running process.
-    def inject_dylib
-      debug_logging = RunLoop::Environment.debug?
-      puts "Starting lldb." if debug_logging
-
-      stderr_output = nil
-      lldb_status = nil
-      lldb_start_time = Time.now
-      Open3.popen3('sh') do |stdin, stdout, stderr, process_status|
-        stdin.puts 'xcrun lldb --no-lldbinit<<EOF'
-        stdin.puts "process attach -n '#{@process_name}'"
-        stdin.puts "expr (void*)dlopen(\"#{@dylib_path}\", 0x2)"
-        stdin.puts 'detach'
-        stdin.puts 'exit'
-        stdin.puts 'EOF'
-        stdin.close
-
-        puts "#{stdout.read}" if debug_logging
-
-        lldb_status = process_status
-        stderr_output = stderr.read.strip
-      end
+    def inject_dylib(timeout)
+      RunLoop.log_debug("Starting lldb injection with a timeout of #{timeout} seconds")
 
-      pid = lldb_status.pid
-      exit_status = lldb_status.value.exitstatus
+      script_path = write_script
 
-      if stderr_output == ''
-        if debug_logging
-          puts "lldb '#{pid}' exited with value '#{exit_status}'."
-          puts "Took #{Time.now-lldb_start_time} for lldb to inject calabash dylib."
-        end
-      else
-        puts "#{stderr_output}"
-        if debug_logging
-          puts "lldb '#{pid}' exited with value '#{exit_status}'."
-          puts "lldb tried for  #{Time.now-lldb_start_time} to inject calabash dylib before giving up."
-        end
-      end
+      start = Time.now
 
-      stderr_output == ''
-    end
+      options = {
+        :timeout => timeout,
+        :log_cmd => true
+      }
 
-    def inject_dylib_with_timeout(timeout)
+      hash = nil
       success = false
-      Timeout.timeout(timeout) do
-        success = inject_dylib
+      begin
+        hash = xcrun.exec(["lldb", "--no-lldbinit", "--source", script_path], options)
+        pid = hash[:pid]
+        exit_status = hash[:exit_status]
+        success = exit_status == 0
+
+        RunLoop.log_debug("lldb '#{pid}' exited with value '#{exit_status}'.")
+
+        success = exit_status == 0
+        elapsed = Time.now - start
+
+        if success
+          RunLoop.log_debug("Took #{elapsed} seconds for lldb to inject calabash dylib.")
+        else
+          RunLoop.log_debug("Could not inject dylib after #{elapsed} seconds.")
+          if hash[:out]
+            hash[:out].split("\n").each do |line|
+              RunLoop.log_debug(line)
+            end
+          else
+            RunLoop.log_debug("lldb returned no output to stdout or stderr")
+          end
+        end
+      rescue RunLoop::Xcrun::TimeoutError
+        elapsed = Time.now - start
+        RunLoop.log_debug("lldb tried for #{elapsed} seconds to inject calabash dylib before giving up.")
       end
+
       success
     end
 
     def retriable_inject_dylib(options={})
-      default_options = {:tries => 3,
-                         :interval => 10,
-                         :timeout => 10}
-      merged_options = default_options.merge(options)
-
-      debug_logging = RunLoop::Environment.debug?
-
-      on_retry = Proc.new do |_, try, elapsed_time, next_interval|
-        if debug_logging
-          # Retriable 2.0
-          if elapsed_time && next_interval
-            puts "LLDB: attempt #{try} failed in '#{elapsed_time}'; will retry in '#{next_interval}'"
-          else
-            puts "LLDB: attempt #{try} failed; will retry in #{merged_options[:interval]}"
-          end
-        end
-        RunLoop::LLDB.kill_lldb_processes
-        RunLoop::ProcessWaiter.new('lldb').wait_for_none
-      end
+      merged_options = RETRY_OPTIONS.merge(options)
 
       tries = merged_options[:tries]
+      timeout = merged_options[:timeout]
       interval = merged_options[:interval]
-      retry_opts = RunLoop::RetryOpts.tries_and_interval(tries, interval, {:on_retry => on_retry})
 
-      # For some reason, :timeout does not work here;
-      # the lldb process can hang indefinitely.
-      Retriable.retriable(retry_opts) do
-        unless inject_dylib_with_timeout merged_options[:timeout]
-          raise RuntimeError, "Could not inject dylib"
-        end
+      success = false
+
+      tries.times do
+
+        success = inject_dylib(timeout)
+        break if success
+
+        sleep(interval)
+      end
+
+      if !success
+        raise RuntimeError, "Could not inject dylib"
+      end
+      success
+    end
+
+    private
+
+    def write_script
+      script = File.join(DotDir.directory, "inject-dylib.lldb")
+
+      if File.exist?(script)
+        FileUtils.rm_rf(script)
+      end
+
+      File.open(script, "w") do |file|
+        file.write("process attach -n \"#{process_name}\"\n")
+        file.write("expr (void*)dlopen(\"#{dylib_path}\", 0x2)\n")
+        file.write("detach\n")
+        file.write("exit\n")
       end
-      true
+
+      script
     end
   end
 end

data/lib/run_loop/environment.rb

@@ -80,32 +80,47 @@ module RunLoop
       end
     end
 
-    # Returns the value of CAL_SIM_POST_LAUNCH_WAIT
+    # Returns true if running in Jenkins CI
     #
-    # Controls how long to wait _after_ the simulator is opened.
-    #
-    # The default wait time is 1.0.  This was arrived at through testing.
+    # Checks the value of JENKINS_HOME
+    def self.jenkins?
+      value = ENV["JENKINS_HOME"]
+      return value && value != ''
+    end
+
+    # Returns true if running in Travis CI
     #
-    # In CoreSimulator environments, the iOS Simulator starts many async
-    # processes that must be allowed to finish before we start operating on the
-    # simulator.  Until we find the right combination of processes to wait for,
-    # this variable will give us the opportunity to control how long we wait.
+    # Checks the value of TRAVIS
+    def self.travis?
+      value = ENV["TRAVIS"]
+      return value && value != ''
+    end
+
+    # Returns true if running in Circle CI
     #
-    # Essential for managed envs like Travis + Jenkins and on slower machines.
-    def self.sim_post_launch_wait
-      value = ENV['CAL_SIM_POST_LAUNCH_WAIT']
-      float = nil
-      begin
-        float = value.to_f
-      rescue NoMethodError => _
+    # Checks the value of CIRCLECI
+    def self.circle_ci?
+      value = ENV["CIRCLECI"]
+      return value && value != ''
+    end
 
-      end
+    # Returns true if running in Teamcity
+    #
+    # Checks the value of TEAMCITY_PROJECT_NAME
+    def self.teamcity?
+      value = ENV["TEAMCITY_PROJECT_NAME"]
+      return value && value != ''
+    end
 
-      if float.nil? || float == 0.0
-        nil
-      else
-        float
-      end
+    # Returns true if running in a CI environment
+    def self.ci?
+      [
+        self.ci_var_defined?,
+        self.travis?,
+        self.jenkins?,
+        self.circle_ci?,
+        self.teamcity?
+      ].any?
     end
 
     # !@visibility private
@@ -124,5 +139,14 @@ module RunLoop
         block.call
       end
     end
+
+    private
+
+    # !@visibility private
+    def self.ci_var_defined?
+      value = ENV["CI"]
+      return value && value != ''
+    end
   end
 end
+