run_loop_tcc 2.1.3

data/lib/run_loop/dnssd.rb

@@ -0,0 +1,148 @@
+module RunLoop
+
+  # @!visibility private
+  # This class is a work in progress.
+  #
+  # At the moment, it is only useful for debugging the bonjour
+  # server that is started by DeviceAgent.
+  class DNSSD
+
+    # @!visibility private
+    def self.factory(json)
+      array = JSON.parse(json, {:symbolize_names => true})
+      array.map do |dns|
+        RunLoop::DNSSD.new(dns[:service],
+                           dns[:ip],
+                           dns[:port],
+                           dns[:txt])
+      end
+    end
+
+    # @!visibility private
+    attr_reader :service
+
+    # @!visibility private
+    attr_reader :ip
+
+    # @!visibility private
+    attr_reader :port
+
+    # @!visibility private
+    attr_reader :txt
+
+    # @!visibility private
+    def initialize(service, ip, port, txt)
+      @service = service
+      @ip = ip
+      @port = port
+      @txt = txt
+    end
+
+    # @!visibility private
+    def url
+      @url ||= "http://#{ip}:#{port}"
+    end
+
+    # @!visibility private
+    def to_s
+      "#<#{service}: #{url} TXT: #{txt}"
+    end
+
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
+    # @!visibility private
+    def ==(other)
+      service == other.service
+    end
+
+    DEVICE_AGENT = "_calabus._tcp"
+
+    def self.wait_for_new_device_agent(old, options={})
+      new = self.wait_for_device_agents(options)
+      new.find do |new_dns|
+        !old.include?(new_dns)
+      end
+    end
+
+    def self.wait_for_device_agents(options={})
+      default_opts = {
+        :timeout => 0.1,
+        :retries => 150,
+        :interval => 0.1
+      }
+
+      merged_opts = default_opts.merge(options)
+      timeout = merged_opts[:timeout]
+      retries = merged_opts[:retries]
+      interval = merged_opts[:interval]
+
+      start_time = Time.now
+
+      retries.times do |try|
+        time_diff = start_time + timeout - Time.now
+
+        if time_diff <= 0
+          elapsed = Time.now - start_time
+          RunLoop.log_debug("Timed out waiting after #{elapsed} seconds for DeviceAgents")
+          return []
+        end
+
+        agents = self.device_agents(timeout)
+
+        if !agents.empty?
+          elapsed = Time.now - start_time
+          RunLoop.log_debug("Found #{agents.count} DeviceAgents after #{elapsed} seconds")
+          return agents
+        end
+
+        sleep(interval)
+      end
+      []
+    end
+
+    def self.device_agents(timeout)
+      services = []
+      addresses = []
+      self.browse(DEVICE_AGENT, timeout) do |reply|
+        if reply.flags.add?
+          services << reply
+        end
+        next if reply.flags.more_coming?
+
+        services.each do |service|
+          resolved = service.resolve
+          addr = Socket.getaddrinfo(resolved.target, nil, Socket::AF_INET)
+          addr.each do |address|
+            match = addresses.find do |dns|
+              dns.service == service.name
+            end
+
+            if !match
+              dns = RunLoop::DNSSD.new(service.name,
+                                       addr[0][2],
+                                       resolved.port,
+                                       resolved.text_record)
+              addresses << dns
+            end
+          end
+        end
+      end
+      addresses
+    end
+
+    def self.browse(type, timeout)
+      domain = nil
+      flags = 0
+      interface = ::DNSSD::InterfaceAny
+      service = ::DNSSD::Service.browse(type, domain, flags, interface)
+      service.each(timeout) { |r| yield r }
+    ensure
+      service.stop if service
+    end
+
+  end
+end
+

data/lib/run_loop/dot_dir.rb

@@ -0,0 +1,87 @@
+# A module for managing the ~/.run-loop directory.
+module RunLoop::DotDir
+
+  def self.directory
+    home = RunLoop::Environment.user_home_directory
+    dir = File.join(home, ".run-loop")
+    if !File.exist?(dir)
+      FileUtils.mkdir_p(dir)
+    end
+    dir
+  end
+
+  def self.make_results_dir
+    if RunLoop::Environment.xtc?
+      next_results_dir = Dir.mktmpdir("run_loop")
+    else
+      results_dir = File.join(self.directory, 'results')
+      next_results_dir = self.next_timestamped_dirname(results_dir)
+      FileUtils.mkdir_p(next_results_dir)
+
+      current = File.join(self.directory, "results", "current")
+      FileUtils.rm_rf(current)
+      FileUtils.ln_s(next_results_dir, current)
+    end
+
+    next_results_dir
+  end
+
+  def self.rotate_result_directories
+    return :xtc if RunLoop::Environment.xtc?
+
+    start = Time.now
+
+    glob = "#{self.directory}/results/*"
+
+    RunLoop.log_debug("Searching for run-loop results with glob: #{glob}")
+
+    directories = Dir.glob(glob).select do |path|
+      File.directory?(path) && !File.symlink?(path)
+    end
+
+    oldest_first = directories.sort_by { |f| File.mtime(f) }
+
+    RunLoop.log_debug("Found #{oldest_first.count} previous run-loop results")
+    oldest_first.pop(5)
+
+    RunLoop.log_debug("Will delete #{oldest_first.count} previous run-loop results")
+
+    oldest_first.each do |path|
+      FileUtils.rm_rf(path)
+    end
+
+    elapsed = Time.now - start
+
+    RunLoop.log_debug("Deleted #{oldest_first.count} previous results in #{elapsed} seconds")
+  rescue StandardError => e
+    RunLoop.log_error("While rotating previous results, encounterd: #{e}")
+  end
+
+  private
+
+  def self.timestamped_dirname(plus_seconds = 0)
+    (Time.now + plus_seconds).strftime("%Y-%m-%d_%H-%M-%S")
+  end
+
+  def self.next_timestamped_dirname(base_dir)
+    dir = File.join(base_dir, self.timestamped_dirname)
+    return dir if !File.exist?(dir)
+
+    # Rather than wait, just increment the second.  Per-second accuracy
+    # is not important; uniqueness is.
+    counter = 0
+    loop do
+      break if !File.exist?(dir)
+      break if counter == 4
+      counter = counter + 1
+      dir = File.join(base_dir, self.timestamped_dirname(counter))
+    end
+
+    # If all else fails, just return a unique UUID
+    if File.exist?(dir)
+      dir = File.join(base_dir, SecureRandom.uuid)
+    end
+    dir
+  end
+end
+

data/lib/run_loop/dylib_injector.rb

@@ -0,0 +1,145 @@
+module RunLoop
+
+  # @!visibility private
+  #
+  # This is experimental.
+  #
+  # 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.
+    #
+    # 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::DylibInjector::RETRY_OPTIONS[:timeout] = 60
+    RETRY_OPTIONS = {
+      :tries => 3,
+      :interval => 2,
+      :timeout => RunLoop::Environment.ci? ? 40 : 20
+    }
+
+    # @!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
+
+    # @!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
+    #  bundle.
+    # @param [String] dylib_path The path the dylib to inject.
+    def initialize(process_name, dylib_path)
+      @process_name = process_name
+      @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(timeout)
+      RunLoop.log_debug("Starting lldb injection with a timeout of #{timeout} seconds")
+
+      script_path = write_script
+
+      start = Time.now
+
+      options = {
+        :timeout => timeout,
+        :log_cmd => true
+      }
+
+      hash = nil
+      success = false
+      begin
+        hash = xcrun.run_command_in_context(["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={})
+      merged_options = RETRY_OPTIONS.merge(options)
+
+      tries = merged_options[:tries]
+      timeout = merged_options[:timeout]
+      interval = merged_options[:interval]
+
+      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
+
+      script
+    end
+  end
+end

data/lib/run_loop/encoding.rb

@@ -0,0 +1,56 @@
+
+module RunLoop
+  module Encoding
+
+    # Removes diacritic markers from string.
+    #
+    # The ruby Encoding tools cannot perform this action, they can only change
+    # convert one encodign to another by substituting characters.
+    #
+    # In ruby 1.9.3 we would have used Iconv, but that does not exist in 2.0.
+    #
+    # The Encoding::Convert in 2.0 does not work on string with UTF-16 characters.
+    def transliterate(string)
+			require "i18n"
+      locales = I18n.available_locales
+      if !locales.include?(:en)
+        I18n.available_locales = locales + [:en]
+      end
+      I18n.transliterate(string)
+    end
+
+    # Raised when a string cannot be coerced to UTF8
+    class UTF8Error < RuntimeError; end
+
+    # @!visibility private
+    def ensure_command_output_utf8(string, command)
+      return '' if !string
+
+      utf8 = string.force_encoding("UTF-8").chomp
+
+      return utf8 if utf8.valid_encoding?
+
+      encoded = utf8.encode("UTF-8", "UTF-8",
+                            invalid: :replace,
+                            undef: :replace,
+                            replace: "")
+
+      return encoded if encoded.valid_encoding?
+
+      raise UTF8Error, %Q{
+Could not force UTF-8 encoding on this string:
+
+#{string}
+
+which is the output of this command:
+
+#{command}
+
+Please file an issue with a stacktrace and the text of this error.
+
+https://github.com/calabash/run_loop/issues
+      }
+    end
+  end
+end
+