ferrum 0.1.0

data/lib/ferrum/browser/process.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "cliver"
+require "net/http"
+require "json"
+require "addressable"
+require "tmpdir"
+
+module Ferrum
+  class Browser
+    class Process
+      KILL_TIMEOUT = 2
+      PROCESS_TIMEOUT = 1
+      BROWSER_PATH = ENV["BROWSER_PATH"]
+      BROWSER_HOST = "127.0.0.1"
+      BROWSER_PORT = "0"
+      DEFAULT_OPTIONS = {
+        "headless" => nil,
+        "disable-gpu" => nil,
+        "hide-scrollbars" => nil,
+        "mute-audio" => nil,
+        "enable-automation" => nil,
+        "disable-web-security" => nil,
+        "disable-session-crashed-bubble" => nil,
+        "disable-breakpad" => nil,
+        "disable-sync" => nil,
+        "no-first-run" => nil,
+        "use-mock-keychain" => nil,
+        "keep-alive-for-test" => nil,
+        "disable-popup-blocking" => nil,
+        "disable-extensions" => nil,
+        "disable-hang-monitor" => nil,
+        "disable-features" => "site-per-process,TranslateUI",
+        "disable-translate" => nil,
+        "disable-background-networking" => nil,
+        "enable-features" => "NetworkService,NetworkServiceInProcess",
+        "disable-background-timer-throttling" => nil,
+        "disable-backgrounding-occluded-windows" => nil,
+        "disable-client-side-phishing-detection" => nil,
+        "disable-default-apps" => nil,
+        "disable-dev-shm-usage" => nil,
+        "disable-ipc-flooding-protection" => nil,
+        "disable-prompt-on-repost" => nil,
+        "disable-renderer-backgrounding" => nil,
+        "force-color-profile" => "srgb",
+        "metrics-recording-only" => nil,
+        "safebrowsing-disable-auto-update" => nil,
+        "password-store" => "basic",
+        # Note: --no-sandbox is not needed if you properly setup a user in the container.
+        # https://github.com/ebidel/lighthouse-ci/blob/master/builder/Dockerfile#L35-L40
+        # "no-sandbox" => nil,
+      }.freeze
+
+      NOT_FOUND = "Could not find an executable for chrome. Try to make it " \
+                  "available on the PATH or set environment varible for " \
+                  "example BROWSER_PATH=\"/Applications/Chromium.app/Contents/MacOS/Chromium\""
+
+
+      attr_reader :host, :port, :ws_url, :pid, :path, :options, :cmd
+
+      def self.start(*args)
+        new(*args).tap(&:start)
+      end
+
+      def self.process_killer(pid)
+        proc do
+          begin
+            if Ferrum.windows?
+              ::Process.kill("KILL", pid)
+            else
+              ::Process.kill("USR1", pid)
+              start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+              while ::Process.wait(pid, ::Process::WNOHANG).nil?
+                sleep 0.05
+                next unless (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start) > KILL_TIMEOUT
+                ::Process.kill("KILL", pid)
+                ::Process.wait(pid)
+                break
+              end
+            end
+          rescue Errno::ESRCH, Errno::ECHILD
+          end
+        end
+      end
+
+      def self.detect_browser_path
+        if RUBY_PLATFORM.include?("darwin")
+          [
+            "/Applications/Chromium.app/Contents/MacOS/Chromium",
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+          ].find { |path| File.exist?(path) }
+        else
+          %w[chromium google-chrome-unstable google-chrome-beta google-chrome chrome chromium-browser google-chrome-stable].reduce(nil) do |path, exe|
+            path = Cliver.detect(exe)
+            break path if path
+          end
+        end
+      end
+
+      def initialize(options)
+        @options = {}
+
+        @path = options[:browser_path] || BROWSER_PATH || self.class.detect_browser_path
+
+        if options[:url]
+          url = URI.join(options[:url].to_s, "/json/version")
+          response = JSON.parse(::Net::HTTP.get(url))
+          set_ws_url(response["webSocketDebuggerUrl"])
+          return
+        end
+
+        # Doesn't work on MacOS, so we need to set it by CDP as well
+        @options.merge!("window-size" => options[:window_size].join(","))
+
+        port = options.fetch(:port, BROWSER_PORT)
+        @options.merge!("remote-debugging-port" => port)
+
+        host = options.fetch(:host, BROWSER_HOST)
+        @options.merge!("remote-debugging-address" => host)
+
+        @options.merge!("user-data-dir" => Dir.mktmpdir)
+
+        @options = DEFAULT_OPTIONS.merge(@options)
+
+        unless options.fetch(:headless, true)
+          @options.delete("headless")
+          @options.delete("disable-gpu")
+        end
+
+        @process_timeout = options.fetch(:process_timeout, PROCESS_TIMEOUT)
+
+        @options.merge!(options.fetch(:browser_options, {}))
+
+        @logger = options[:logger]
+      end
+
+      def start
+        # Don't do anything as browser is already running as external process.
+        return if ws_url
+
+        begin
+          read_io, write_io = IO.pipe
+          process_options = { in: File::NULL }
+          process_options[:pgroup] = true unless Ferrum.windows?
+          if Ferrum.mri?
+            process_options[:out] = process_options[:err] = write_io
+          end
+
+          raise Cliver::Dependency::NotFound.new(NOT_FOUND) unless @path
+
+          redirect_stdout(write_io) do
+            @cmd = [@path] + @options.map { |k, v| v.nil? ? "--#{k}" : "--#{k}=#{v}" }
+            @pid = ::Process.spawn(*@cmd, process_options)
+            ObjectSpace.define_finalizer(self, self.class.process_killer(@pid))
+          end
+
+          parse_ws_url(read_io, @process_timeout)
+        ensure
+          close_io(read_io, write_io)
+        end
+      end
+
+      def stop
+        return unless @pid
+        kill
+        ObjectSpace.undefine_finalizer(self)
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      private
+
+      def redirect_stdout(write_io)
+        if Ferrum.mri?
+          yield
+        else
+          begin
+            prev = STDOUT.dup
+            $stdout = write_io
+            STDOUT.reopen(write_io)
+            yield
+          ensure
+            STDOUT.reopen(prev)
+            $stdout = STDOUT
+            prev.close
+          end
+        end
+      end
+
+      def kill
+        self.class.process_killer(@pid).call
+        @pid = nil
+      end
+
+      def parse_ws_url(read_io, timeout = PROCESS_TIMEOUT)
+        output = ""
+        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        max_time = start + timeout
+        regexp = /DevTools listening on (ws:\/\/.*)/
+        while (now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)) < max_time
+          begin
+            output += read_io.read_nonblock(512)
+          rescue IO::WaitReadable
+            IO.select([read_io], nil, nil, max_time - now)
+          else
+            if output.match(regexp)
+              set_ws_url(output.match(regexp)[1].strip)
+              break
+            end
+          end
+        end
+
+        unless ws_url
+          @logger.puts output if @logger
+          raise "Chrome process did not produce websocket url within #{timeout} seconds"
+        end
+      end
+
+      def set_ws_url(url)
+        @ws_url = Addressable::URI.parse(url)
+        @host = @ws_url.host
+        @port = @ws_url.port
+      end
+
+      def close_io(*ios)
+        ios.each do |io|
+          begin
+            io.close unless io.closed?
+          rescue IOError
+            raise unless RUBY_ENGINE == 'jruby'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ferrum/browser/subscriber.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module Ferrum
+  class Browser
+    class Subscriber
+      include Concurrent::Async
+
+      def initialize
+        super
+        @on = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def on(event, &block)
+        @on[event] << block
+        true
+      end
+
+      def call(message)
+        method, params = message.values_at("method", "params")
+        @on[method].each { |b| b.call(params) }
+      end
+    end
+  end
+end

data/lib/ferrum/browser/web_socket.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "websocket/driver"
+
+module Ferrum
+  class Browser
+    class WebSocket
+      WEBSOCKET_BUG_SLEEP = 0.01
+
+      attr_reader :url, :messages
+
+      def initialize(url, logger)
+        @url      = url
+        @logger   = logger
+        uri       = URI.parse(@url)
+        @sock     = TCPSocket.new(uri.host, uri.port)
+        @driver   = ::WebSocket::Driver.client(self)
+        @messages = Queue.new
+
+        @driver.on(:open,    &method(:on_open))
+        @driver.on(:message, &method(:on_message))
+        @driver.on(:close,   &method(:on_close))
+
+        @thread = Thread.new do
+          begin
+            while data = @sock.readpartial(512)
+              @driver.parse(data)
+            end
+          rescue EOFError, Errno::ECONNRESET
+            @messages.close
+          end
+        end
+
+        @thread.priority = 1
+
+        @driver.start
+      end
+
+      def on_open(_event)
+        # https://github.com/faye/websocket-driver-ruby/issues/46
+        sleep(WEBSOCKET_BUG_SLEEP)
+      end
+
+      def on_message(event)
+        data = JSON.parse(event.data)
+        @messages.push(data)
+        @logger&.puts("    ◀ #{event.data}\n")
+      end
+
+      def on_close(_event)
+        @messages.close
+        @thread.kill
+      end
+
+      def send_message(data)
+        json = data.to_json
+        @driver.text(json)
+        @logger&.puts("\n\n▶ #{json}")
+      end
+
+      def write(data)
+        @sock.write(data)
+      end
+
+      def close
+        @driver.close
+      end
+    end
+  end
+end

data/lib/ferrum/cookie.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Cookie
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def name
+      @attributes["name"]
+    end
+
+    def value
+      @attributes["value"]
+    end
+
+    def domain
+      @attributes["domain"]
+    end
+
+    def path
+      @attributes["path"]
+    end
+
+    def size
+      @attributes["size"]
+    end
+
+    def secure?
+      @attributes["secure"]
+    end
+
+    def httponly?
+      @attributes["httpOnly"]
+    end
+
+    def session?
+      @attributes["session"]
+    end
+
+    def expires
+      if @attributes["expires"] > 0
+        Time.at(@attributes["expires"])
+      end
+    end
+  end
+end

data/lib/ferrum/errors.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class NotImplemented < StandardError; end
+  class ModalNotFound < StandardError; end
+  class Error < StandardError; end
+  class NoSuchWindowError < Error; end
+  class EmptyTargetsError < Error; end
+  class NoExecutionContext < Error; end
+
+  class ClientError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(response["message"])
+    end
+  end
+
+  class BrowserError < ClientError
+    def code
+      response["code"]
+    end
+
+    def data
+      response["data"]
+    end
+  end
+
+  class JavaScriptError < ClientError
+    attr_reader :class_name, :message
+
+    def initialize(response)
+      super
+      @class_name, @message = response.values_at("className", "description")
+    end
+  end
+
+  class StatusFailError < ClientError
+    def message
+      "Request to #{response["url"]} failed to reach server, check DNS and/or server status"
+    end
+  end
+
+  class FrameNotFound < ClientError
+    def name
+      response["args"].first
+    end
+
+    def message
+      "The frame \"#{name}\" was not found."
+    end
+  end
+
+  class NodeError < ClientError
+    attr_reader :node
+
+    def initialize(node, response)
+      @node = node
+      super(response)
+    end
+  end
+
+  class ObsoleteNode < NodeError
+    def message
+      "The element you are trying to interact with is either not part of the DOM, or is " \
+      "not currently visible on the page (perhaps display: none is set). " \
+      "It is possible the element has been replaced by another element and you meant to interact with " \
+      "the new element. If so you need to do a new find in order to get a reference to the " \
+      "new element."
+    end
+  end
+
+  class TimeoutError < Error
+    def message
+      "Timed out waiting for response. It's possible that this happened " \
+      "because something took a very long time (for example a page load " \
+      "was slow). If so, setting the :timeout option to a higher value might " \
+      "help."
+    end
+  end
+
+  class ScriptTimeoutError < Error
+    def message
+      "Timed out waiting for evaluated script to return a value"
+    end
+  end
+
+  class DeadBrowser < Error
+    def initialize(message = "Browser is dead")
+      super
+    end
+  end
+end