run_loop 1.5.1 → 1.5.2

data/lib/run_loop/device.rb

@@ -103,9 +103,9 @@ Please update your sources.))
     # @!visibility private
     def to_s
       if simulator?
-        "#<Simulator: #{name} #{udid} #{instruction_set}>"
+        "#<Simulator: #{name} (#{version.to_s}) #{udid} #{instruction_set}>"
       else
-        "#<Device: #{name} #{udid}>"
+        "#<Device: #{name} (#{version.to_s}) #{udid}>"
       end
     end
 
@@ -188,6 +188,28 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       end
     end
 
+    # @!visibility private
+    # The device `state` is reported by the simctl tool.
+    #
+    # The expected values from simctl are:
+    #
+    # * Booted
+    # * Shutdown
+    # * Shutting Down
+    #
+    # To handle exceptional cases, there are these two additional states:
+    #
+    # * Unavailable # Should never occur
+    # * Unknown     # A stub for future changes
+    def update_simulator_state
+      if physical_device?
+        raise RuntimeError, 'This method is available only for simulators'
+      end
+
+      @state = fetch_simulator_state
+    end
+
+    # @!visibility private
     def simulator_root_dir
       @simulator_root_dir ||= lambda {
         return nil if physical_device?
@@ -195,6 +217,7 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       }.call
     end
 
+    # @!visibility private
     def simulator_accessibility_plist_path
       @simulator_accessibility_plist_path ||= lambda {
         return nil if physical_device?
@@ -202,6 +225,7 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       }.call
     end
 
+    # @!visibility private
     def simulator_preferences_plist_path
       @simulator_preferences_plist_path ||= lambda {
         return nil if physical_device?
@@ -209,6 +233,7 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       }.call
     end
 
+    # @!visibility private
     def simulator_log_file_path
       @simulator_log_file_path ||= lambda {
         return nil if physical_device?
@@ -216,9 +241,200 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       }.call
     end
 
+    # @!visibility private
+    def simulator_device_plist
+      @simulator_device_plist ||= lambda do
+        return nil if physical_device?
+        File.join(simulator_root_dir, 'device.plist')
+      end.call
+    end
+
+    # @!visibility private
+    # Is this the first launch of this Simulator?
+    #
+    # TODO Needs unit and integration tests.
+    def simulator_first_launch?
+      megabytes = simulator_data_dir_size
+
+      if version >= RunLoop::Version.new('9.0')
+        megabytes < 20
+      elsif version >= RunLoop::Version.new('8.0')
+        megabytes < 12
+      else
+        megabytes < 8
+      end
+    end
+
+    # @!visibility private
+    # The size of the simulator data/ directory.
+    #
+    # TODO needs unit tests.
+    def simulator_data_dir_size
+      path = File.join(simulator_root_dir, 'data')
+      args = ['du', '-m', '-d', '0', path]
+      hash = xcrun.exec(args)
+      hash[:out].split(' ').first.to_i
+    end
+
+    # @!visibility private
+    #
+    # Waits for three conditions:
+    #
+    # 1. The SHA sum of the simulator data/ directory to be stable.
+    # 2. No more log messages are begin generated
+    # 3. 1 and 2 must hold for 2 seconds.
+    #
+    # When the simulator version is >= iOS 9 _and_ it is the first launch of
+    # the simulator after a reset or a new simulator install, a fourth condition
+    # is added:
+    #
+    # 4. The first three conditions must be met a second time.
+    def simulator_wait_for_stable_state
+      require 'securerandom'
+
+      quiet_time = 2
+      delay = 0.5
+
+      first_launch = false
+
+      if version >= RunLoop::Version.new('9.0')
+        first_launch = simulator_data_dir_size < 20
+      end
+
+      now = Time.now
+      timeout = 30
+      poll_until = now + timeout
+      quiet = now + quiet_time
+
+      is_stable = false
+
+      path = File.join(simulator_root_dir, 'data')
+      current_sha = nil
+      sha_fn = lambda do |data_dir|
+        begin
+          # Directory.directory_digest has a blocking read.  Typically, it
+          # returns in < 0.3 seconds.
+          Timeout.timeout(2, TimeoutError) do
+            RunLoop::Directory.directory_digest(data_dir)
+          end
+        rescue => e
+          RunLoop.log_error(e) if RunLoop::Environment.debug?
+          SecureRandom.uuid
+        end
+      end
+
+      current_line = nil
+
+      while Time.now < poll_until do
+        latest_sha = sha_fn.call(path)
+        latest_line = last_line_from_simulator_log_file
+
+        is_stable = current_sha == latest_sha && current_line == latest_line
+
+        if is_stable
+          if Time.now > quiet
+            if first_launch
+              RunLoop.log_debug('First launch detected - allowing additional time to stabilize')
+              first_launch = false
+              sleep 1.2
+              quiet = Time.now + quiet_time
+            else
+              break
+            end
+          else
+            quiet = Time.now + quiet_time
+          end
+        end
+
+        current_sha = latest_sha
+        current_line = latest_line
+        sleep delay
+      end
+
+      if is_stable
+        elapsed = Time.now - now
+        stabilized = elapsed - quiet_time
+        RunLoop.log_debug("Simulator stable after #{stabilized} seconds")
+        RunLoop.log_debug("Waited a total of #{elapsed} seconds for simulator to stabilize")
+      else
+        RunLoop.log_debug("Timed out: simulator not stable after #{timeout} seconds")
+      end
+    end
+
     private
 
+    # @!visibility private
+    # TODO write a unit test.
+    def last_line_from_simulator_log_file
+      file = simulator_log_file_path
+
+      return nil if !File.exist?(file)
+
+      debug = RunLoop::Environment.debug?
+
+      begin
+        io = File.open(file, 'r')
+        io.seek(-100, IO::SEEK_END)
+
+        line = io.readline
+      rescue StandardError => e
+        RunLoop.log_error("Caught #{e} while reading simulator log file") if debug
+      ensure
+        io.close if io && !io.closed?
+      end
+
+      line
+    end
+
+    # @!visibility private
+    def xcrun
+      RunLoop::Xcrun.new
+    end
+
+    # @!visibility private
+    def detect_state_from_line(line)
+
+      if line[/unavailable/, 0]
+        RunLoop.log_debug("Simulator state is unavailable: #{line}")
+        return 'Unavailable'
+      end
+
+      state = line[/(Booted|Shutdown|Shutting Down)/,0]
+
+      if state.nil?
+        RunLoop.log_debug("Simulator state is unknown: #{line}")
+        'Unknown'
+      else
+        state
+      end
+    end
+
+    # @!visibility private
+    def fetch_simulator_state
+      if physical_device?
+        raise RuntimeError, 'This method is available only for simulators'
+      end
+
+      args = ['simctl', 'list', 'devices']
+      hash = xcrun.exec(args)
+      out = hash[:out]
+
+      matched_line = out.split("\n").find do |line|
+        line.include?(udid)
+      end
+
+      if matched_line.nil?
+        raise RuntimeError,
+              "Expected a simulator with udid '#{udid}', but found none"
+      end
+
+      detect_state_from_line(matched_line)
+    end
+
+    # @!visibility private
     CORE_SIMULATOR_DEVICE_DIR = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
+
+    # @!visibility private
     CORE_SIMULATOR_LOGS_DIR = File.expand_path('~/Library/Logs/CoreSimulator')
 
     # TODO Is this a good idea?  It speeds up rspec tests by a factor of ~2x...

data/lib/run_loop/directory.rb

@@ -1,10 +1,10 @@
-require 'digest'
-require 'openssl'
-
 module RunLoop
 
   # Class for performing operations on directories.
   class Directory
+    require 'digest'
+    require 'openssl'
+    require 'pathname'
 
     # Dir.glob ignores files that start with '.', but we often need to find
     # dotted files and directories.
@@ -39,10 +39,27 @@ module RunLoop
         raise ArgumentError, "Expected a non-empty dir at '#{path}' found '#{entries}'"
       end
 
+      debug = RunLoop::Environment.debug?
+
       sha = OpenSSL::Digest::SHA256.new
       self.recursive_glob_for_entries(path).each do |file|
-        unless File.directory?(file)
-          sha << File.read(file)
+        if File.directory?(file)
+          # skip directories
+        elsif !Pathname.new(file).exist?
+          # skip broken symlinks
+        else
+          case File.ftype(file)
+            when 'fifo'
+              RunLoop.log_warn("SHA1 SKIPPING FIFO #{file}") if debug
+            when 'socket'
+              RunLoop.log_warn("SHA1 SKIPPING SOCKET #{file}") if debug
+            when 'characterSpecial'
+              RunLoop.log_warn("SHA1 SKIPPING CHAR SPECIAL #{file}") if debug
+            when 'blockSpecial'
+              RunLoop.log_warn("SHA1 SKIPPING BLOCK SPECIAL #{file}") if debug
+            else
+              sha << File.read(file)
+          end
         end
       end
       sha.hexdigest

data/lib/run_loop/environment.rb

@@ -95,5 +95,15 @@ module RunLoop
         float
       end
     end
+
+    def self.with_debugging(&block)
+      original_value = ENV['DEBUG']
+      ENV['DEBUG'] = '1'
+      begin
+        block.call
+      ensure
+        ENV['DEBUG'] = original_value
+      end
+    end
   end
 end

data/lib/run_loop/instruments.rb

@@ -13,6 +13,10 @@ module RunLoop
       @xcode ||= RunLoop::Xcode.new
     end
 
+    def xcrun
+      RunLoop::Xcrun.new
+    end
+
     # @!visibility private
     def to_s
       "#<Instruments #{version.to_s}>"
@@ -106,10 +110,10 @@ Please update your sources to pass an instance of RunLoop::Xcode))
     # @return [RunLoop::Version] A version object.
     def version
       @instruments_version ||= lambda do
-        execute_command([]) do |_, stderr, _|
-          version_str = stderr.read[VERSION_REGEX, 0]
-          RunLoop::Version.new(version_str)
-        end
+        args = ['instruments']
+        hash = xcrun.exec(args, log_cmd: true)
+        version_str = hash[:err][VERSION_REGEX, 0]
+        RunLoop::Version.new(version_str)
       end.call
     end
 
@@ -129,54 +133,41 @@ Please update your sources to pass an instance of RunLoop::Xcode))
     # @return [Array<String>] Instruments.app templates.
     def templates
       @instruments_templates ||= lambda do
+        args = ['instruments', '-s', 'templates']
+        hash = xcrun.exec(args, log_cmd: true)
         if xcode.version_gte_6?
-          execute_command(['-s', 'templates']) do |stdout, stderr, _|
-            filter_stderr_spam(stderr)
-            stdout.read.chomp.split("\n").map do |elm|
-              stripped = elm.strip.tr('"', '')
-              if stripped == '' || stripped == 'Known Templates:'
-                nil
-              else
-                stripped
-              end
-            end.compact
-          end
-        elsif xcode.version_gte_51?
-          execute_command(['-s', 'templates']) do |stdout, stderr, _|
-            err = stderr.read
-            if !err.nil? || err != ''
-              $stderr.puts stderr.read
+          hash[:out].chomp.split("\n").map do |elm|
+            stripped = elm.strip.tr('"', '')
+            if stripped == '' || stripped == 'Known Templates:'
+              nil
+            else
+              stripped
             end
-
-            stdout.read.strip.split("\n").delete_if do |path|
-              not path =~ /tracetemplate/
-            end.map { |elm| elm.strip }
-          end
+          end.compact
         else
-          raise "Xcode version '#{xcode.version}' is not supported."
+          hash[:out].strip.split("\n").delete_if do |path|
+            not path =~ /tracetemplate/
+          end.map { |elm| elm.strip }
         end
       end.call
     end
 
-    # Returns an array the available physical devices.
+    # Returns an array of the available physical devices.
     #
     # @return [Array<RunLoop::Device>] All the devices will be physical
     #  devices.
     def physical_devices
       @instruments_physical_devices ||= lambda do
-        execute_command(['-s', 'devices']) do |stdout, stderr, _|
-          filter_stderr_spam(stderr)
-          all = stdout.read.chomp.split("\n")
-          valid = all.select do |device|
-            device =~ DEVICE_UDID_REGEX
-          end
-          valid.map do |device|
-            udid = device[DEVICE_UDID_REGEX, 0]
-            version = device[VERSION_REGEX, 0]
-            name = device.split('(').first.strip
+        fetch_devices[:out].chomp.split("\n").map do |line|
+          udid = line[DEVICE_UDID_REGEX, 0]
+          if udid
+            version = line[VERSION_REGEX, 0]
+            name = line.split('(').first.strip
             RunLoop::Device.new(name, version, udid)
+          else
+            nil
           end
-        end
+        end.compact
       end.call
     end
 
@@ -195,35 +186,39 @@ Please update your sources to pass an instance of RunLoop::Xcode))
     # @return [Array<RunLoop::Device>] All the devices will be simulators.
     def simulators
       @instruments_simulators ||= lambda do
-        execute_command(['-s', 'devices']) do |stdout, stderr, _|
-          filter_stderr_spam(stderr)
-          lines = stdout.read.chomp.split("\n")
-          lines.map do |line|
-            stripped = line.strip
-            if line_is_simulator?(stripped) &&
-                  !line_is_simulator_paired_with_watch?(stripped)
-
-              version = stripped[VERSION_REGEX, 0]
-
-              if line_is_xcode5_simulator?(stripped)
-                name = line
-                udid = line
-              else
-                name = stripped.split('(').first.strip
-                udid = line[CORE_SIMULATOR_UDID_REGEX, 0]
-              end
-
-              RunLoop::Device.new(name, version, udid)
+        fetch_devices[:out].chomp.split("\n").map do |line|
+          stripped = line.strip
+          if line_is_simulator?(stripped) &&
+                !line_is_simulator_paired_with_watch?(stripped)
+
+            version = stripped[VERSION_REGEX, 0]
+
+            if line_is_xcode5_simulator?(stripped)
+              name = line
+              udid = line
             else
-              nil
+              name = stripped.split('(').first.strip
+              udid = line[CORE_SIMULATOR_UDID_REGEX, 0]
             end
-          end.compact
-        end
+
+            RunLoop::Device.new(name, version, udid)
+          else
+            nil
+          end
+        end.compact
       end.call
     end
 
     private
 
+    # @!visibility private
+    def fetch_devices
+      @device_hash ||= lambda do
+        args = ['instruments', '-s', 'devices']
+        xcrun.exec(args, log_cmd: true)
+      end.call
+    end
+
     # @!visibility private
     #
     # ```
@@ -354,18 +349,6 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       end
     end
 
-    # @!visibility private
-    #
-    # Filters `instruments` spam.
-    def filter_stderr_spam(stderr)
-      # Xcode 6 GM is spamming "WebKit Threading Violations"
-      stderr.read.strip.split("\n").each do |line|
-        unless line[/WebKit Threading Violation/, 0]
-          $stderr.puts line
-        end
-      end
-    end
-
     # @!visibility private
     def line_is_simulator?(line)
       line_is_core_simulator?(line) || line_is_xcode5_simulator?(line)