run_loop 1.2.6 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab5bc95a6743db8faaae000d728b4af4c36401c2
-  data.tar.gz: b00267da35da54a4bafdff8f18587bf187aa78f5
+  metadata.gz: 2654e1672654ee6ae0af23cb582fec43864992df
+  data.tar.gz: d481bf34a098f76d83d94826575b021ace8232ca
 SHA512:
-  metadata.gz: 73d64d08b501e73dfa80e49c9446e164626d8bb39d7ccdc3fa1939d2db15163b14b7bbda41bd7bc53ea90c42b8cf97f17ab79c7e616d02ef6734015d6691c553
-  data.tar.gz: d0a3b4661b426fe09a64252dea9214de136b496af4ab46d900c284c1f9ec59f96c620aedde16719f7b63ae4b16532a962aff064eca89b7b64196589284b95fd9
+  metadata.gz: db03ba41012e7bf8f5d4cefa4833a36c478d16f9359339e415eae29dfa4faf62e6fb3491ad301d872941bcb30a1ebb71c1aabd55f95ceb01210119f2f57f00ff
+  data.tar.gz: 30e5ec4733c0ef6da15aa590c9390c46e3a9a6fa5ddb08f4e609602ace3a05579ea76d538a132f4667708ea1d4cf83307aeb243573b90635cbd6609c8b0e21d3

data/lib/run_loop.rb

@@ -1,10 +1,17 @@
+require 'run_loop/environment'
+require 'run_loop/process_terminator'
+require 'run_loop/process_waiter'
+require 'run_loop/lldb'
+require 'run_loop/dylib_injector'
 require 'run_loop/core'
 require 'run_loop/version'
 require 'run_loop/xctools'
 require 'run_loop/plist_buddy'
+require 'run_loop/app'
 require 'run_loop/sim_control'
 require 'run_loop/device'
 require 'run_loop/instruments'
 require 'run_loop/lipo'
 require 'run_loop/host_cache'
 require 'run_loop/monkey_patch'
+require 'run_loop/simctl/bridge'

data/lib/run_loop/app.rb

@@ -0,0 +1,67 @@
+module RunLoop
+  # A class for interacting with .app bundles.
+  class App
+
+    # @!attribute [r] path
+    # @return [String] The path to the app bundle .app
+    attr_reader :path
+
+    # Creates a new App instance.
+    #
+    # @note The `app_bundle_path` is expanded during initialization.
+    #
+    # @param [String] app_bundle_path A path to a .app
+    # @return [RunLoop::App] A instance of App with a path.
+    def initialize(app_bundle_path)
+      @path = File.expand_path(app_bundle_path)
+    end
+
+    # Is this a valid app?
+    def valid?
+      [File.exist?(path),
+       File.directory?(path),
+       File.extname(path) == '.app'].all?
+    end
+
+    # Returns the Info.plist path.
+    # @raise [RuntimeError] If there is no Info.plist.
+    def info_plist_path
+      info_plist = File.join(path, 'Info.plist')
+      unless File.exist?(info_plist)
+        raise "Expected an Info.plist at '#{path}'"
+      end
+      info_plist
+    end
+
+    # Inspects the app's Info.plist for the bundle identifier.
+    # @return [String] The value of CFBundleIdentifier.
+    # @raise [RuntimeError] If the plist cannot be read or the
+    #   CFBundleIdentifier is empty or does not exist.
+    def bundle_identifier
+      identifier = plist_buddy.plist_read('CFBundleIdentifier', info_plist_path)
+      unless identifier
+        raise "Expected key 'CFBundleIdentifier' in '#{info_plist_path}'"
+      end
+      identifier
+    end
+
+    # Inspects the app's Info.plist for the executable name.
+    # @return [String] The value of CFBundleIdentifier.
+    # @raise [RuntimeError] If the plist cannot be read or the
+    #   CFBundleExecutable is empty or does not exist.
+    def executable_name
+      identifier = plist_buddy.plist_read('CFBundleExecutable', info_plist_path)
+      unless identifier
+        raise "Expected key 'CFBundleExecutable' in '#{info_plist_path}'"
+      end
+      identifier
+    end
+
+    private
+
+    def plist_buddy
+      @plist_buddy ||= RunLoop::PlistBuddy.new
+    end
+
+  end
+end

data/lib/run_loop/core.rb

@@ -135,7 +135,8 @@ module RunLoop
       sim_control ||= options[:sim_control] || RunLoop::SimControl.new
       xctools ||= options[:xctools] || sim_control.xctools
 
-      RunLoop::Instruments.new.kill_instruments(xctools)
+      instruments = RunLoop::Instruments.new
+      instruments.kill_instruments
 
       device_target = options[:udid] || options[:device_target] || detect_connected_device || 'simulator'
       if device_target && device_target.to_s.downcase == 'device'
@@ -157,7 +158,6 @@ module RunLoop
 
       script = File.join(results_dir, '_run_loop.js')
 
-
       code = File.read(options[:script])
       code = code.gsub(/\$PATH/, results_dir)
       code = code.gsub(/\$READ_SCRIPT_PATH/, READ_SCRIPT_PATH)
@@ -186,10 +186,6 @@ module RunLoop
 
       args = options.fetch(:args, [])
 
-      inject_dylib = self.dylib_path_from_options options
-      # WIP This is brute-force call against all lldb processes.
-      self.ensure_lldb_not_running if inject_dylib
-
       log_file ||= File.join(results_dir, 'run_loop.out')
 
       after = Time.now
@@ -217,22 +213,11 @@ module RunLoop
 
       self.log_run_loop_options(merged_options, xctools)
 
-      cmd = instruments_command(merged_options, xctools)
+      automation_template = automation_template(xctools)
 
       log_header("Starting on #{device_target} App: #{bundle_dir_or_bundle_id}")
-      cmd_str = cmd.join(' ')
 
-      log(cmd_str) if ENV['DEBUG'] == '1'
-
-      if !jruby? && RUBY_VERSION && RUBY_VERSION.start_with?('1.8')
-        pid = fork do
-          exec(cmd_str)
-        end
-      else
-        pid = spawn(cmd_str)
-      end
-
-      Process.detach(pid)
+      pid = instruments.spawn(automation_template, merged_options, log_file)
 
       File.open(File.join(results_dir, 'run_loop.pid'), 'w') do |f|
         f.write pid
@@ -249,7 +234,6 @@ module RunLoop
 
       uia_timeout = options[:uia_timeout] || (ENV['UIA_TIMEOUT'] && ENV['UIA_TIMEOUT'].to_f) || 10
 
-      raw_lldb_output = nil
       before = Time.now
       begin
 
@@ -262,63 +246,25 @@ module RunLoop
             read_response(run_loop, 0, uia_timeout)
           end
         end
-
-        # inject_dylib will be nil or a path to a dylib
-        if inject_dylib
-          lldb_template_file = File.join(scripts_path, 'calabash.lldb.erb')
-          lldb_template = ::ERB.new(File.read(lldb_template_file))
-          lldb_template.filename = lldb_template_file
-
-          # Special!
-          # These are required by the ERB in calabash.lldb.erb
-          # noinspection RubyUnusedLocalVariable
-          cf_bundle_executable = find_cf_bundle_executable(bundle_dir_or_bundle_id)
-          # noinspection RubyUnusedLocalVariable
-          dylib_path_for_target = inject_dylib
-
-          lldb_cmd = lldb_template.result(binding)
-
-          tmpdir = Dir.mktmpdir('lldb_cmd')
-          lldb_script = File.join(tmpdir, 'lldb')
-
-          File.open(lldb_script, 'w') { |f| f.puts(lldb_cmd) }
-
-          if ENV['DEBUG'] == '1'
-            puts "lldb script #{lldb_script}"
-            puts "=== lldb script ==="
-            counter = 0
-            File.open(lldb_script, 'r').readlines.each { |line|
-              puts "#{counter} #{line}"
-              counter = counter + 1
-            }
-            puts "=== lldb script ==="
-          end
-
-          # Forcing a timeout.  Do not retry here.  If lldb is hanging,
-          # RunLoop::Core.run* needs to be called again.  Put another way,
-          # instruments and lldb must be terminated.
-          Retriable.retriable({:tries => 1, :timeout => 12, :interval => 1}) do
-            raw_lldb_output = `xcrun lldb -s #{lldb_script}`
-            if ENV['DEBUG'] == '1'
-              puts raw_lldb_output
-            end
-          end
-        end
       rescue TimeoutError => e
         if ENV['DEBUG'] == '1'
           puts "Failed to launch."
           puts "#{e}: #{e && e.message}"
-          if raw_lldb_output
-            puts "LLDB OUTPUT: #{raw_lldb_output}"
-          end
         end
         raise TimeoutError, "Time out waiting for UIAutomation run-loop to Start. \n Logfile #{log_file} \n\n #{File.read(log_file)}\n"
       end
 
-      after = Time.now()
-
       if ENV['DEBUG']=='1'
-        puts "Launching took #{after-before} seconds"
+        puts "Launching took #{Time.now-before} seconds"
+      end
+
+      dylib_path = self.dylib_path_from_options(merged_options)
+
+      if dylib_path
+        RunLoop::LLDB.kill_lldb_processes
+        app = RunLoop::App.new(options[:app])
+        lldb = RunLoop::DylibInjector.new(app.executable_name, dylib_path)
+        lldb.retriable_inject_dylib
       end
 
       run_loop
@@ -392,15 +338,6 @@ module RunLoop
       dylib_path
     end
 
-    def self.find_cf_bundle_executable(bundle_dir_or_bundle_id)
-      unless File.directory?(bundle_dir_or_bundle_id)
-        raise "Injecting dylibs currently only works with simulator and app bundles"
-      end
-      info_plist = Dir[File.join(bundle_dir_or_bundle_id, 'Info.plist')].first
-      raise "Unable to find Info.plist in #{bundle_dir_or_bundle_id}" if info_plist.nil?
-      `/usr/libexec/PlistBuddy -c "Print :CFBundleExecutable" "#{info_plist}"`.strip
-    end
-
     # Returns the a default simulator to target.  This default needs to be one
     # that installed by default in the current Xcode version.
     #
@@ -409,7 +346,9 @@ module RunLoop
     # @param [RunLoop::XCTools] xcode_tools Used to detect the current xcode
     #  version.
     def self.default_simulator(xcode_tools=RunLoop::XCTools.new)
-      if xcode_tools.xcode_version_gte_62?
+      if xcode_tools.xcode_version_gte_63?
+        'iPhone 5s (8.3 Simulator)'
+      elsif xcode_tools.xcode_version_gte_62?
         'iPhone 5s (8.2 Simulator)'
       elsif xcode_tools.xcode_version_gte_61?
         'iPhone 5s (8.1 Simulator)'
@@ -615,40 +554,6 @@ module RunLoop
       RunLoop::Instruments.new.instruments_pids(&block)
     end
 
-    def self.instruments_command_prefix(udid, results_dir_trace)
-      instruments_path = 'xcrun instruments'
-      if udid
-        instruments_path = "#{instruments_path} -w \"#{udid}\""
-      end
-      instruments_path << " -D \"#{results_dir_trace}\"" if results_dir_trace
-      instruments_path
-    end
-
-
-    def self.instruments_command(options, xctools=RunLoop::XCTools.new)
-      udid = options[:udid]
-      results_dir_trace = options[:results_dir_trace]
-      bundle_dir_or_bundle_id = options[:bundle_dir_or_bundle_id]
-      results_dir = options[:results_dir]
-      script = options[:script]
-      log_file = options[:log_file]
-      args= options[:args] || []
-
-      instruments_prefix = instruments_command_prefix(udid, results_dir_trace)
-      cmd = [
-          instruments_prefix,
-          '-t', "\"#{automation_template(xctools)}\"",
-          "\"#{bundle_dir_or_bundle_id}\"",
-          '-e', 'UIARESULTSPATH', results_dir,
-          '-e', 'UIASCRIPT', script,
-          args.join(' ')
-      ]
-      if log_file
-        cmd << "&> #{log_file}"
-      end
-      cmd
-    end
-
     def self.automation_template(xctools, candidate = ENV['TRACE_TEMPLATE'])
       unless candidate && File.exist?(candidate)
         candidate = default_tracetemplate xctools
@@ -710,22 +615,6 @@ module RunLoop
     def self.instruments_pids
       RunLoop::Instruments.new.instruments_pids
     end
-
-    # @todo This is a WIP
-    # @todo Needs rspec test
-    def self.ensure_lldb_not_running
-      descripts = `xcrun ps x -o pid,command | grep "lldb" | grep -v grep`.strip.split("\n")
-      descripts.each do |process_desc|
-        pid = process_desc.split(' ').first
-        Open3.popen3("xcrun kill -9 #{pid} && xcrun wait #{pid}") do |_, stdout, stderr, _|
-          out = stdout.read.strip
-          err = stderr.read.strip
-          next if out.to_s.empty? and err.to_s.empty?
-          # there lots of 'ownership' problems trying to kill the lldb process
-          #puts "kill process '#{pid}' => stdout: '#{out}' | stderr: '#{err}'"
-        end
-      end
-    end
   end
 
   def self.default_script_for_uia_strategy(uia_strategy)

data/lib/run_loop/device.rb

@@ -4,17 +4,29 @@ module RunLoop
     attr_reader :name
     attr_reader :version
     attr_reader :udid
+    attr_reader :state
 
-    def initialize(name, version, udid)
+    # Create a new device.
+    #
+    # @param [String] name The name of the device.  For sims this should be
+    #  'iPhone 5s' and for physical devices it will be the name the user gave
+    #  to the device.
+    # @param [String, RunLoop::Version] version The iOS version that is running
+    #  on the device.  Can be a string or a Version instance.
+    # @param [String] udid The device identifier.
+    # @param [String] state (nil) This a simulator only value.  It refers to
+    #  the Booted/Shutdown/Creating state of the simulator.  For pre-Xcode 6
+    #  simulators, this value should be nil.
+    def initialize(name, version, udid, state=nil)
       @name = name
+      @udid = udid
+      @state = state
 
       if version.is_a? String
         @version = RunLoop::Version.new version
       else
         @version = version
       end
-
-      @udid = udid
     end
 
     # Returns and instruments-ready device identifier that is a suitable value

data/lib/run_loop/dylib_injector.rb

@@ -0,0 +1,125 @@
+module RunLoop
+
+  # @!visibility private
+  #
+  # This is experimental.
+  #
+  # Injects dylibs into running executables using lldb.
+  class DylibInjector
+
+    # @!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.
+    # @return [String] The process_name
+    attr_reader :process_name
+
+    # @!attribute [r] dylib_path
+    # The path to the dylib that is to be injected.
+    # @return [String] The dylib_path
+    attr_reader :dylib_path
+
+    # 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
+    #  bundle.
+    # @param [String] dylib_path The path the dylib to inject.
+    def initialize(process_name, dylib_path)
+      @process_name = process_name
+      @dylib_path = dylib_path
+    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
+
+      pid = lldb_status.pid
+      exit_status = lldb_status.value.exitstatus
+
+      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
+
+      stderr_output == ''
+    end
+
+    def inject_dylib_with_timeout(timeout)
+      success = false
+      Timeout.timeout(timeout) do
+        success = inject_dylib
+      end
+      success
+    end
+
+    def retriable_inject_dylib(options={})
+      merged_options = RETRIABLE_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
+
+      # For some reason, :timeout does not work here - the lldb process can
+      # hang indefinitely.  Seems to work when
+      Retriable.retriable({:tries => merged_options[:retries],
+                           # Retriable 2.0
+                           :interval => merged_options[:interval],
+                           :base_interval => merged_options[:interval],
+                           :on_retry => on_retry}) do
+        #unless inject_dylib_with_timeout merged_options[:timeout]
+        unless inject_dylib_with_timeout merged_options[:timeout]
+          raise RuntimeError, "Could not inject dylib"
+        end
+      end
+      true
+    end
+
+    private
+
+    RETRIABLE_OPTIONS =
+          {
+                :retries => 3,
+                :timeout => 10,
+                # Retriable 2.0 replaces :interval with :base_interval
+                :interval => 2,
+                :base_interval => 2
+          }
+  end
+end