run_loop 1.5.1 → 1.5.2

data/lib/run_loop/life_cycle/core_simulator.rb

@@ -0,0 +1,544 @@
+module RunLoop
+  module LifeCycle
+
+    class CoreSimulator
+
+      require 'securerandom'
+
+      # @!visibility private
+      METADATA_PLIST = '.com.apple.mobile_container_manager.metadata.plist'
+
+      # @!visibility private
+      CORE_SIMULATOR_DEVICE_DIR = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
+
+      # @!visibility private
+      # Pattern.
+      # [ '< process name >', < send term first > ]
+      MANAGED_PROCESSES =
+            [
+                  # This process is a daemon, and requires 'KILL' to terminate.
+                  # Killing the process is fast, but it takes a long time to
+                  # restart.
+                  # ['com.apple.CoreSimulator.CoreSimulatorService', false],
+
+                  # Probably do not need to quit this, but it is tempting to do so.
+                  #['com.apple.CoreSimulator.SimVerificationService', false],
+
+                  # Started by Xamarin Studio, this is the parent process of the
+                  # processes launched by Xamarin's interaction with
+                  # CoreSimulatorBridge.
+                  ['csproxy', true],
+
+                  # Yes.
+                  ['SimulatorBridge', true],
+                  ['configd_sim', true],
+                  ['launchd_sim', true],
+
+                  # Does not always appear.
+                  ['CoreSimulatorBridge', true],
+
+                  # Xcode 7
+                  ['ids_simd', true]
+            ]
+
+      # @!visibility private
+      # How long to wait after the simulator has launched.
+      SIM_POST_LAUNCH_WAIT = RunLoop::Environment.sim_post_launch_wait || 1.0
+
+      # @!visibility private
+      # How long to wait for for a device to reach a state.
+      WAIT_FOR_DEVICE_STATE_OPTS =
+            {
+                  interval: 0.1,
+                  timeout: 5
+            }
+
+      # @!visibility private
+      # How long to wait for the CoreSimulator processes to start.
+      WAIT_FOR_SIMULATOR_PROCESSES_OPTS =
+            {
+                  timeout: 5,
+                  raise_on_timeout: true
+            }
+
+      attr_reader :app
+      attr_reader :device
+      attr_reader :sim_control
+      attr_reader :pbuddy
+
+      # @param [RunLoop::App] app The application.
+      # @param [RunLoop::Device] device The device.
+      def initialize(app, device, sim_control=RunLoop::SimControl.new)
+        @app = app
+        @device = device
+        @sim_control = sim_control
+
+        # In order to manage the app on the device, we need to manage the
+        # CoreSimulator processes.
+        RunLoop::SimControl.terminate_all_sims
+        terminate_core_simulator_processes
+      end
+
+      # Launch simulator without specifying an app.
+      def launch_simulator
+        sim_path = sim_control.send(:sim_app_path)
+        args = ['open', '-g', '-a', sim_path, '--args', '-CurrentDeviceUDID', device.udid]
+
+        RunLoop.log_debug("Launching #{device} with:")
+        RunLoop.log_unix_cmd("xcrun #{args.join(' ')}")
+
+        start_time = Time.now
+
+        pid = spawn('xcrun', *args)
+        Process.detach(pid)
+
+        sim_name = sim_control.send(:sim_name)
+
+        RunLoop::ProcessWaiter.new(sim_name, WAIT_FOR_SIMULATOR_PROCESSES_OPTS).wait_for_any
+
+        device.simulator_wait_for_stable_state
+
+        elapsed = Time.now - start_time
+        RunLoop.log_debug("Took #{elapsed} seconds to launch the simulator")
+
+        true
+      end
+
+      # @!visibility private
+      def pbuddy
+        @pbuddy ||= RunLoop::PlistBuddy.new
+      end
+
+      # @!visibility private
+      def sdk_gte_8?
+        device.version >= RunLoop::Version.new('8.0')
+      end
+
+      # The data directory for the the device.
+      #
+      # ~/Library/Developer/CoreSimulator/Devices/<UDID>/data
+      def device_data_dir
+        @device_data_dir ||= File.join(CORE_SIMULATOR_DEVICE_DIR, device.udid, 'data')
+      end
+
+      # The applications directory for the device.
+      #
+      # ~/Library/Developer/CoreSimulator/Devices/<UDID>/Containers/Bundle/Application
+      def device_applications_dir
+        @device_app_dir ||= lambda do
+          if sdk_gte_8?
+            File.join(device_data_dir, 'Containers', 'Bundle', 'Application')
+          else
+            File.join(device_data_dir, 'Applications')
+          end
+        end.call
+      end
+
+      # The sandbox directory for the app.
+      #
+      # ~/Library/Developer/CoreSimulator/Devices/<UDID>/Containers/Data/Application
+      #
+      # Contains Library, Documents, and tmp directories.
+      def app_sandbox_dir
+        app_install_dir = installed_app_bundle_dir
+        return nil if app_install_dir.nil?
+        if sdk_gte_8?
+          app_sandbox_dir_sdk_gte_8
+        else
+          app_install_dir
+        end
+      end
+
+      # The Library directory in the sandbox.
+      def app_library_dir
+        base_dir = app_sandbox_dir
+        if base_dir.nil?
+          nil
+        else
+          File.join(base_dir, 'Library')
+        end
+      end
+
+      # The Library/Preferences directory in the sandbox.
+      def app_library_preferences_dir
+        base_dir = app_library_dir
+        if base_dir.nil?
+          nil
+        else
+          File.join(base_dir, 'Preferences')
+        end
+      end
+
+      # The Documents directory in the sandbox.
+      def app_documents_dir
+        base_dir = app_sandbox_dir
+        if base_dir.nil?
+          nil
+        else
+          File.join(base_dir, 'Documents')
+        end
+      end
+
+      # The tmp directory in the sandbox.
+      def app_tmp_dir
+        base_dir = app_sandbox_dir
+        if base_dir.nil?
+          nil
+        else
+          File.join(base_dir, 'tmp')
+        end
+      end
+
+      # Is this app installed?
+      def app_is_installed?
+        !installed_app_bundle_dir.nil?
+      end
+
+      # The sha1 of the installed app.
+      def installed_app_sha1
+        installed_bundle = installed_app_bundle_dir
+        if installed_bundle
+          RunLoop::Directory.directory_digest(installed_bundle)
+        else
+          nil
+        end
+      end
+
+      # Is the app that is install the same as the one we have in hand?
+      def same_sha1_as_installed?
+        app.sha1 == installed_app_sha1
+      end
+
+      # @!visibility private
+      #
+      # Returns the path to the installed app bundle directory (.app).
+      #
+      # If this method returns nil, the app is not installed.
+      def installed_app_bundle_dir
+        sim_app_dir = device_applications_dir
+        return nil if !File.exist?(sim_app_dir)
+        Dir.glob("#{sim_app_dir}/**/*.app").find do |path|
+          RunLoop::App.new(path).bundle_identifier == app.bundle_identifier
+        end
+      end
+
+      # Uninstall the app on the device.
+      def uninstall
+        installed_app_bundle = installed_app_bundle_dir
+        if installed_app_bundle
+          uninstall_app_and_sandbox(installed_app_bundle)
+          :uninstalled
+        else
+          RunLoop.log_debug('App was not installed.  Nothing to do')
+          :not_installed
+        end
+      end
+
+      # Install the app on the device.
+      def install
+        installed_app_bundle = installed_app_bundle_dir
+
+        # App is not installed.
+        return install_new_app if installed_app_bundle.nil?
+
+        # App is installed but sha1 is different.
+        if !same_sha1_as_installed?
+          return reinstall_existing_app_and_clear_sandbox(installed_app_bundle)
+        end
+
+        RunLoop.log_debug('The installed app is the same as the app we are trying to install; skipping installation')
+        installed_app_bundle
+      end
+
+      # @!visibility private
+      #
+      # 1. Does nothing if the app is not installed.
+      # 2. Does nothing if the app the same as the app that is installed
+      # 3. Installs app if it is different from the installed app
+      #
+      # TODO needs unit tests and a better name?
+      def ensure_app_same
+        installed_app_bundle = installed_app_bundle_dir
+
+        if !installed_app_bundle
+          RunLoop.log_debug("App: #{app} is not installed")
+          return true
+        end
+
+        installed_sha = installed_app_sha1
+        app_sha = app.sha1
+
+        if installed_sha == app_sha
+          RunLoop.log_debug("Installed app is the same as #{app}")
+          return true
+        end
+
+        RunLoop.log_debug("The app you are trying to launch is not the same as the app that is installed.")
+        RunLoop.log_debug("  Installed app SHA: #{installed_sha}")
+        RunLoop.log_debug("  App to launch SHA: #{app_sha}")
+        RunLoop.log_debug("Will install #{app}")
+
+
+        FileUtils.rm_rf installed_app_bundle
+        RunLoop.log_debug('Deleted the existing app')
+
+        directory = File.expand_path(File.join(installed_app_bundle, '..'))
+        bundle_name = File.basename(app.path)
+        target = File.join(directory, bundle_name)
+
+        args = ['ditto', app.path, target]
+        RunLoop::Xcrun.new.exec(args, log_cmd: true)
+
+        RunLoop.log_debug("Installed #{app} on CoreSimulator #{device.udid}")
+
+        true
+      end
+
+      # Reset app sandbox.
+      def reset_app_sandbox
+        return true if !app_is_installed?
+
+        wait_for_device_state('Shutdown')
+
+        reset_app_sandbox_internal
+      end
+
+      private
+
+      def generate_uuid
+        SecureRandom.uuid.upcase!
+      end
+
+      def existing_app_container_uuids
+        if File.exist?(device_applications_dir)
+          Dir.entries(device_applications_dir)
+        else
+          []
+        end
+      end
+
+      def generate_unique_uuid(existing, timeout=1.0)
+        begin
+          Timeout::timeout(timeout, Timeout::Error) do
+          uuid = generate_uuid
+          loop do
+            break if !existing.include?(uuid)
+            uuid = generate_uuid
+          end
+          uuid
+          end
+        rescue Timeout::Error => _
+          raise RuntimeError,
+                "Expected to be able to generate a unique uuid in #{timeout} seconds"
+        end
+      end
+
+      def install_new_app
+        wait_for_device_state('Shutdown')
+
+        existing = existing_app_container_uuids
+        udid = generate_unique_uuid(existing)
+        directory = File.join(device_applications_dir, udid)
+
+        bundle_name = File.basename(app.path)
+        target = File.join(directory, bundle_name)
+
+        args = ['ditto', app.path, target]
+        RunLoop::Xcrun.new.exec(args, log_cmd: true)
+        target
+      end
+
+      def reinstall_existing_app_and_clear_sandbox(installed_app_bundle)
+        wait_for_device_state('Shutdown')
+
+        reset_app_sandbox_internal
+
+        if File.exist?(installed_app_bundle)
+          FileUtils.rm_rf(installed_app_bundle)
+          RunLoop.log_debug("Deleted app bundle: #{installed_app_bundle}")
+        end
+
+        directory = File.dirname(installed_app_bundle)
+        bundle_name = File.basename(app.path)
+        target = File.join(directory, bundle_name)
+
+        args = ['ditto', app.path, target]
+        RunLoop::Xcrun.new.exec(args, log_cmd: true)
+        installed_app_bundle
+      end
+
+      def uninstall_app_and_sandbox(installed_app_bundle)
+        wait_for_device_state('Shutdown')
+
+        if sdk_gte_8?
+          # Must delete the sandbox first.
+          directory = app_sandbox_dir
+          if File.exist?(directory)
+            FileUtils.rm_rf(directory)
+            RunLoop.log_debug("Deleted app sandbox: #{directory}")
+          end
+
+          directory = File.dirname(installed_app_bundle)
+          if File.exist?(directory)
+            FileUtils.rm_rf(directory)
+            RunLoop.log_debug("Deleted app container: #{directory}")
+          end
+        else
+          # Sandbox _is_ in the container.
+          directory = File.dirname(installed_app_bundle)
+          if File.exist?(directory)
+            FileUtils.rm_rf(directory)
+            RunLoop.log_debug("Deleted app container: #{directory}")
+          end
+        end
+      end
+
+      # @!visibility private
+      def app_sandbox_dir_sdk_gte_8
+        containers_data_dir = File.join(device_data_dir, 'Containers', 'Data', 'Application')
+        apps = Dir.glob("#{containers_data_dir}/**/#{METADATA_PLIST}")
+        match = apps.find do |metadata_plist|
+          pbuddy.plist_read('MCMMetadataIdentifier', metadata_plist) == app.bundle_identifier
+        end
+        if match
+          File.dirname(match)
+        else
+          nil
+        end
+      end
+
+      # @!visibility private
+      def terminate_core_simulator_processes
+        MANAGED_PROCESSES.each do |pair|
+          name = pair[0]
+          send_term = pair[1]
+          pids = RunLoop::ProcessWaiter.new(name).pids
+          pids.each do |pid|
+
+            if send_term
+              term = RunLoop::ProcessTerminator.new(pid, 'TERM', name)
+              killed = term.kill_process
+            else
+              killed = false
+            end
+
+            unless killed
+              term = RunLoop::ProcessTerminator.new(pid, 'KILL', name)
+              term.kill_process
+            end
+          end
+        end
+      end
+
+      # @!visibility private
+      def wait_for_device_state(target_state)
+        now = Time.now
+        timeout = WAIT_FOR_DEVICE_STATE_OPTS[:timeout]
+        poll_until = now + timeout
+        delay = WAIT_FOR_DEVICE_STATE_OPTS[:interval]
+        in_state = false
+        while Time.now < poll_until
+          in_state = device.update_simulator_state == target_state
+          break if in_state
+          sleep delay
+        end
+
+        elapsed = Time.now - now
+        RunLoop.log_debug("Waited for #{elapsed} seconds for device to have state: '#{target_state}'.")
+
+        unless in_state
+          raise "Expected '#{target_state} but found '#{device.state}' after waiting."
+        end
+        in_state
+      end
+
+      # @!visibility private
+      def reset_app_sandbox_internal_shared
+        [app_documents_dir, app_tmp_dir].each do |dir|
+          FileUtils.rm_rf dir
+          FileUtils.mkdir dir
+        end
+      end
+
+      # @!visibility private
+      def reset_app_sandbox_internal_sdk_gte_8
+        lib_dir = app_library_dir
+        RunLoop::Directory.recursive_glob_for_entries(lib_dir).each do |entry|
+          if entry.include?('Preferences')
+            # nop
+          else
+            if File.exist?(entry)
+              FileUtils.rm_rf(entry)
+            end
+          end
+        end
+
+        prefs_dir = app_library_preferences_dir
+        protected = ['com.apple.UIAutomation.plist',
+                     'com.apple.UIAutomationPlugIn.plist']
+        RunLoop::Directory.recursive_glob_for_entries(prefs_dir).each do |entry|
+          unless protected.include?(File.basename(entry))
+            if File.exist?(entry)
+              FileUtils.rm_rf entry
+            end
+          end
+        end
+      end
+
+      # @!visibility private
+      def reset_app_sandbox_internal_sdk_lt_8
+        prefs_dir = app_library_preferences_dir
+        RunLoop::Directory.recursive_glob_for_entries(prefs_dir).each do |entry|
+          if entry.end_with?('.GlobalPreferences.plist') ||
+                entry.end_with?('com.apple.PeoplePicker.plist')
+            # nop
+          else
+            if File.exist?(entry)
+              FileUtils.rm_rf entry
+            end
+          end
+        end
+
+        # app preferences lives in device Library/Preferences
+        device_prefs_dir = File.join(app_sandbox_dir, 'Library', 'Preferences')
+        app_prefs_plist = File.join(device_prefs_dir, "#{app.bundle_identifier}.plist")
+        if File.exist?(app_prefs_plist)
+          FileUtils.rm_rf(app_prefs_plist)
+        end
+      end
+
+      # @!visibility private
+      def reset_app_sandbox_internal
+        reset_app_sandbox_internal_shared
+
+        if sdk_gte_8?
+          reset_app_sandbox_internal_sdk_gte_8
+        else
+          reset_app_sandbox_internal_sdk_lt_8
+        end
+      end
+
+      # @!visibility private
+      # For testing.
+      def launch
+
+        install
+        launch_simulator
+
+        args = ['simctl', 'launch', device.udid, app.bundle_identifier]
+        hash = RunLoop::Xcrun.new.exec(args, log_cmd: true, timeout: 20)
+
+        exit_status = hash[:exit_status]
+
+        if exit_status != 0
+          err = hash[:err]
+          RunLoop.log_error(err)
+          raise RuntimeError, "Could not launch #{app.bundle_identifier} on #{device}"
+        end
+
+        RunLoop::ProcessWaiter.new(app.executable_name, WAIT_FOR_APP_LAUNCH_OPTS).wait_for_any
+        true
+      end
+    end
+  end
+end