Module: RunLoop

Defined in:
lib/run_loop/cli.rb,
lib/run_loop/core.rb,
lib/run_loop/lipo.rb,
lib/run_loop/device.rb,
lib/run_loop/version.rb,
lib/run_loop/xctools.rb,
lib/run_loop/instruments.rb,
lib/run_loop/plist_buddy.rb,
lib/run_loop/sim_control.rb

Defined Under Namespace

Modules: Core Classes: CLI, Device, IncompatibleArchitecture, Instruments, Lipo, PlistBuddy, SimControl, TimeoutError, Version, WriteFailedError, XCTools

Constant Summary collapse

VERSION = 
'1.2.2'

Class Method Summary collapse

Class Method Details

.default_script_for_uia_strategy(uia_strategy) ⇒ Object 



732
733
734
735
736
737
738
739
740
741
742
743
 
# File 'lib/run_loop/core.rb', line 732

def self.default_script_for_uia_strategy(uia_strategy)
  case uia_strategy
    when :preferences
      Core.script_for_key(:run_loop_fast_uia)
    when :host
      Core.script_for_key(:run_loop_host)
    when :shared_element
      Core.script_for_key(:run_loop_shared_element)
    else
      Core.script_for_key(:run_loop_basic)
  end
end

.log_info(logger, message) ⇒ Object 



890
891
892
893
894
895
896
897
 
# File 'lib/run_loop/core.rb', line 890

def self.log_info(logger, message)
  msg = "#{Time.now}: #{message}"
  if logger && logger.respond_to?(:info)
    logger.info(msg)
  else
    puts msg if ENV['DEBUG'] == '1'
  end
end

.run(options = {}) ⇒ Object 



745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
 
# File 'lib/run_loop/core.rb', line 745

def self.run(options={})

  if RunLoop::Instruments.new.instruments_app_running?
    msg =
          [
                "Please quit the Instruments.app.",
                "If Instruments.app is open, the instruments command line",
                "tool cannot take control of your application."
          ]
    raise msg.join("\n")
  end

  uia_strategy = options[:uia_strategy]
  if options[:script]
    script = validate_script(options[:script])
  else
    if uia_strategy
      script = default_script_for_uia_strategy(uia_strategy)
    else
      if options[:calabash_lite]
        uia_strategy = :host
        script = Core.script_for_key(:run_loop_host)
      else
        uia_strategy = :preferences
        script = default_script_for_uia_strategy(uia_strategy)
      end
    end
  end
  # At this point, 'script' has been chosen, but uia_strategy might not
  unless uia_strategy
    desired_script = options[:script]
    if desired_script.is_a?(String) #custom path to script
      uia_strategy = :host
    elsif desired_script == :run_loop_host
      uia_strategy = :host
    elsif desired_script == :run_loop_fast_uia
      uia_strategy = :preferences
    elsif desired_script == :run_loop_shared_element
      uia_strategy = :shared_element
    else
      raise "Inconsistent state: desired script #{desired_script} has not uia_strategy"
    end
  end
  # At this point script and uia_strategy selected

  options[:script] = script
  options[:uia_strategy] = uia_strategy

  Core.run_with_options(options)
end

.send_command(run_loop, cmd, options = {timeout: 60}, num_retries = 0, last_error = nil) ⇒ Object 



796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
 
# File 'lib/run_loop/core.rb', line 796

def self.send_command(run_loop, cmd, options={timeout: 60}, num_retries=0, last_error=nil)
  if num_retries > 3
    if last_error
      raise last_error
    else
      raise "Max retries exceeded #{num_retries} > 3. No error recorded."
    end
  end

  if options.is_a?(Numeric)
    options = {timeout: options}
  end

  if not cmd.is_a?(String)
    raise "Illegal command #{cmd} (must be a string)"
  end

  if not options.is_a?(Hash)
    raise "Illegal options #{options} (must be a Hash (or number for compatibility))"
  end

  timeout = options[:timeout] || 60
  logger = options[:logger]
  interrupt_retry_timeout = options[:interrupt_retry_timeout] || 25

  expected_index = run_loop[:index]
  result = nil
  begin
    expected_index = Core.write_request(run_loop, cmd, logger)
  rescue RunLoop::WriteFailedError, Errno::EINTR => write_error
    # Attempt recover from interrupt by attempting to read result (assuming write went OK)
    # or retry if attempted read result fails
    run_loop[:index] = expected_index # restore expected index in case it changed
    log_info(logger, "Core.write_request failed: #{write_error}. Attempting recovery...")
    log_info(logger, "Attempting read in case the request was received... Please wait (#{interrupt_retry_timeout})...")
    begin
      Timeout::timeout(interrupt_retry_timeout, TimeoutError) do
        result = Core.read_response(run_loop, expected_index)
      end
      # Update run_loop expected index since we succeeded in reading the index
      run_loop[:index] = expected_index + 1
      log_info(logger, "Did read response for interrupted request of index #{expected_index}... Proceeding.")
      return result
    rescue TimeoutError => _
      log_info(logger, "Read did not result in a response for index #{expected_index}... Retrying send_command...")
      return send_command(run_loop, cmd, options, num_retries+1, write_error)
    end
  end


  begin
    Timeout::timeout(timeout, TimeoutError) do
      result = Core.read_response(run_loop, expected_index)
    end
  rescue TimeoutError => _
    raise TimeoutError, "Time out waiting for UIAutomation run-loop for command #{cmd}. Waiting for index:#{expected_index}"
  end

  result
end

.stop(run_loop, out = Dir.pwd) ⇒ Object 



857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
 
# File 'lib/run_loop/core.rb', line 857

def self.stop(run_loop, out=Dir.pwd)
  return if run_loop.nil?
  results_dir = run_loop[:results_dir]
  dest = out

  RunLoop::Instruments.new.kill_instruments

  FileUtils.mkdir_p(dest)
  if results_dir
    pngs = Dir.glob(File.join(results_dir, 'Run 1', '*.png'))
  else
    pngs = []
  end
  FileUtils.cp(pngs, dest) if pngs and pngs.length > 0
end

.validate_script(script) ⇒ Object 



874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
 
# File 'lib/run_loop/core.rb', line 874

def self.validate_script(script)
  if script.is_a?(String)
    unless File.exist?(script)
      raise "Unable to find file: #{script}"
    end
  elsif script.is_a?(Symbol)
    script = Core.script_for_key(script)
    unless script
      raise "Unknown script for symbol: #{script}. Options: #{Core::SCRIPTS.keys.join(', ')}"
    end
  else
    raise "Script must be a symbol or path: #{script}"
  end
  script
end