playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/web_socket_client.rb

@@ -0,0 +1,167 @@
+require 'openssl'
+require 'socket'
+
+begin
+  require 'websocket/driver'
+rescue LoadError
+  raise "websocket-driver is required. Add `gem 'websocket-driver'` to your Gemfile"
+end
+
+# ref: https://github.com/rails/rails/blob/master/actioncable/lib/action_cable/connection/client_socket.rb
+# ref: https://github.com/cavalle/chrome_remote/blob/master/lib/chrome_remote/web_socket_client.rb
+module Playwright
+  class WebSocketClient
+    class SecureSocketFactory
+      def initialize(host, port)
+        @host = host
+        @port = port || 443
+      end
+
+      def create
+        tcp_socket = TCPSocket.new(@host, @port)
+        OpenSSL::SSL::SSLSocket.new(tcp_socket).tap(&:connect)
+      end
+    end
+
+    class DriverImpl # providing #url, #write(string)
+      def initialize(url)
+        @url = url
+
+        endpoint = URI.parse(url)
+        @socket =
+          if endpoint.scheme == 'wss'
+            SecureSocketFactory.new(endpoint.host, endpoint.port).create
+          else
+            TCPSocket.new(endpoint.host, endpoint.port)
+          end
+      end
+
+      attr_reader :url
+
+      def write(data)
+        @socket.write(data)
+      rescue Errno::EPIPE
+        raise EOFError.new('already closed')
+      rescue Errno::ECONNRESET
+        raise EOFError.new('closed by remote')
+      end
+
+      def readpartial(maxlen = 1024)
+        @socket.readpartial(maxlen)
+      rescue Errno::ECONNRESET
+        raise EOFError.new('closed by remote')
+      end
+
+      def disconnect
+        @socket.close
+      end
+    end
+
+    STATE_CONNECTING = 0
+    STATE_OPENED = 1
+    STATE_CLOSING = 2
+    STATE_CLOSED = 3
+
+    def initialize(url:, max_payload_size:, headers:)
+      @impl = DriverImpl.new(url)
+      @driver = ::WebSocket::Driver.client(@impl, max_length: max_payload_size)
+      headers.each do |key, value|
+        @driver.set_header(key, value)
+      end
+
+      setup
+    end
+
+    class TransportError < StandardError; end
+
+    private def setup
+      @ready_state = STATE_CONNECTING
+      @driver.on(:open) do
+        @ready_state = STATE_OPENED
+        handle_on_open
+      end
+      @driver.on(:close) do |event|
+        @ready_state = STATE_CLOSED
+        handle_on_close(reason: event.reason, code: event.code)
+      end
+      @driver.on(:error) do |event|
+        if !handle_on_error(error_message: event.message)
+          raise TransportError.new(event.message)
+        end
+      end
+      @driver.on(:message) do |event|
+        handle_on_message(event.data)
+      end
+    end
+
+    private def wait_for_data
+      @driver.parse(@impl.readpartial)
+    end
+
+    def start
+      @driver.start
+
+      Thread.new do
+        wait_for_data until @ready_state >= STATE_CLOSING
+      rescue EOFError
+        # Google Chrome was gone.
+        # We have nothing todo. Just finish polling.
+        if @ready_state < STATE_CLOSING
+          handle_on_close(reason: 'Going Away', code: 1001)
+        end
+      end
+    end
+
+    # @param message [String]
+    def send_text(message)
+      return if @ready_state >= STATE_CLOSING
+      @driver.text(message)
+    end
+
+    def close(code: 1000, reason: "")
+      return if @ready_state >= STATE_CLOSING
+      @ready_state = STATE_CLOSING
+      @driver.close(reason, code)
+    end
+
+    def on_open(&block)
+      @on_open = block
+    end
+
+    # @param block [Proc(reason: String, code: Numeric)]
+    def on_close(&block)
+      @on_close = block
+    end
+
+    # @param block [Proc(error_message: String)]
+    def on_error(&block)
+      @on_error = block
+    end
+
+    def on_message(&block)
+      @on_message = block
+    end
+
+    private def handle_on_open
+      @on_open&.call
+    end
+
+    private def handle_on_close(reason:, code:)
+      @on_close&.call(reason, code)
+      @impl.disconnect
+    end
+
+    private def handle_on_error(error_message:)
+      return false if @on_error.nil?
+
+      @on_error.call(error_message)
+      true
+    end
+
+    private def handle_on_message(data)
+      return if @ready_state != STATE_OPENED
+
+      @on_message&.call(data)
+    end
+  end
+end

data/lib/playwright/web_socket_transport.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_transport.py
+  class WebSocketTransport
+    # @param ws_endpoint [String] EndpointURL of WebSocket
+    def initialize(ws_endpoint:, headers: {})
+      @ws_endpoint = ws_endpoint
+      @headers = headers
+      @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+    end
+
+    def on_message_received(&block)
+      @on_message = block
+    end
+
+    def on_driver_closed(&block)
+      @on_driver_closed = block
+    end
+
+    def on_driver_crashed(&block)
+      @on_driver_crashed = block
+    end
+
+    class AlreadyDisconnectedError < StandardError ; end
+
+    # @param message [Hash]
+    def send_message(message)
+      debug_send_message(message) if @debug
+      msg = JSON.dump(message)
+
+      @ws.send_text(msg)
+    rescue Errno::EPIPE, IOError
+      raise AlreadyDisconnectedError.new('send_message failed')
+    end
+
+    # Terminate playwright-cli driver.
+    def stop
+      return unless @ws
+
+      future = Concurrent::Promises.resolvable_future
+
+      @ws.on_close do
+        future.fulfill(nil)
+      end
+
+      begin
+        @ws.close
+      rescue EOFError => err
+        # ignore EOLError. The connection is already closed.
+        future.fulfill(err)
+      end
+
+      # Wait for closed actually.
+      future.value!(2)
+    end
+
+    # Start `playwright-cli run-driver`
+    #
+    # @note This method blocks until playwright-cli exited. Consider using Thread or Future.
+    def async_run
+      ws = WebSocketClient.new(
+        url: @ws_endpoint,
+        max_payload_size: 256 * 1024 * 1024, # 256MB
+        headers: @headers,
+      )
+      promise = Concurrent::Promises.resolvable_future
+      ws.on_open do
+        promise.fulfill(ws)
+      end
+      ws.on_error do |error_message|
+        promise.reject(WebSocketClient::TransportError.new(error_message))
+      end
+
+      # Some messages can be sent just after start, before setting @ws.on_message
+      # So set this handler before ws.start.
+      ws.on_message do |data|
+        handle_on_message(data)
+      end
+
+      ws.start
+      @ws = promise.value!
+      @ws.on_close do |reason, code|
+        puts "[WebSocketTransport] closed with code: #{code}, reason: #{reason}"
+        @on_driver_closed&.call(reason, code)
+      end
+      @ws.on_error do |error|
+        puts "[WebSocketTransport] error: #{error}"
+        @on_driver_crashed&.call
+      end
+    rescue Errno::ECONNREFUSED => err
+      raise WebSocketClient::TransportError.new(err)
+    end
+
+    private
+
+    def handle_on_message(data)
+      obj = JSON.parse(data)
+
+      debug_recv_message(obj) if @debug
+      @on_message&.call(obj)
+    end
+
+    def debug_send_message(message)
+      metadata = message.delete(:metadata)
+      puts "\x1b[33mSEND>\x1b[0m#{message}"
+      message[:metadata] = metadata
+    end
+
+    def debug_recv_message(message)
+      puts "\x1b[33mRECV>\x1b[0m#{message}"
+    end
+  end
+end

data/lib/playwright.rb

@@ -10,38 +10,215 @@ require 'concurrent'
 require 'playwright/errors'
 require 'playwright/events'
 require 'playwright/event_emitter'
+require 'playwright/event_emitter_proxy'
 require 'playwright/javascript'
 require 'playwright/utils'
 
+require 'playwright/api_implementation'
 require 'playwright/channel'
 require 'playwright/channel_owner'
+require 'playwright/http_headers'
 require 'playwright/input_files'
-require 'playwright/input_type'
 require 'playwright/connection'
+require 'playwright/har_router'
+require 'playwright/raw_headers'
+require 'playwright/route_handler'
 require 'playwright/select_option_values'
 require 'playwright/timeout_settings'
 require 'playwright/transport'
 require 'playwright/url_matcher'
 require 'playwright/version'
-require 'playwright/wait_helper'
+require 'playwright/video'
+require 'playwright/waiter'
 
 require 'playwright/playwright_api'
 # load generated files
 Dir[File.join(__dir__, 'playwright_api', '*.rb')].each { |f| require f }
 
 module Playwright
+  class Execution
+    def initialize(connection, playwright, browser = nil)
+      @connection = connection
+      @playwright = playwright
+      @browser = browser
+    end
+
+    def stop
+      @browser&.close
+      @connection.stop
+    end
+
+    attr_reader :playwright, :browser
+  end
+
+  class AndroidExecution
+    def initialize(connection, playwright, device = nil)
+      @connection = connection
+      @playwright = playwright
+      @device = device
+    end
+
+    def stop
+      @device&.close
+      @connection.stop
+    end
+
+    attr_reader :playwright, :device
+  end
+
+
+  # Recommended to call this method with block.
+  #
+  # Playwright.create(...) do |playwright|
+  #   browser = playwright.chromium.launch
+  #   ...
+  # end
+  #
+  # When we use this method without block, an instance of Playwright::Execution is returned
+  # and we *must* call execution.stop on the end.
+  # The instance of playwright is available by calling execution.playwright
   module_function def create(playwright_cli_executable_path:, &block)
-    raise ArgumentError.new("block must be provided") unless block
+    transport = Transport.new(playwright_cli_executable_path: playwright_cli_executable_path)
+    connection = Connection.new(transport)
+    connection.async_run
+
+    execution =
+      begin
+        playwright = connection.initialize_playwright
+        Execution.new(connection, PlaywrightApi.wrap(playwright))
+      rescue
+        connection.stop
+        raise
+      end
+
+    if block
+      begin
+        block.call(execution.playwright)
+      ensure
+        execution.stop
+      end
+    else
+      execution
+    end
+  end
+
+  # @Deprecated. Playwright >= 1.54 does not support this method.
+  module_function def connect_to_playwright_server(ws_endpoint, &block)
+    if Gem::Version.new(COMPATIBLE_PLAYWRIGHT_VERSION) >= Gem::Version.new('1.54.0')
+      raise NotImplementedError, 'connect_to_playwright_server is deprecated and not supported in Playwright >= 1.54. Use connect_to_browser_server instead.'
+    end
+
+    require 'playwright/web_socket_client'
+    require 'playwright/web_socket_transport'
+
+    transport = WebSocketTransport.new(ws_endpoint: ws_endpoint)
+    connection = Connection.new(transport)
+    connection.async_run
+
+    execution =
+      begin
+        playwright = connection.initialize_playwright
+        Execution.new(connection, PlaywrightApi.wrap(playwright))
+      rescue
+        connection.stop
+        raise
+      end
+
+    if block
+      begin
+        block.call(execution.playwright)
+      ensure
+        execution.stop
+      end
+    else
+      execution
+    end
+  end
+
+  # Connects to Playwright server, launched by `npx playwright launch-server --browser chromium` or `npx playwright run-server`
+  #
+  # Playwright.connect_to_browser_server('ws://....') do |browser|
+  #   page = browser.new_page
+  #   ...
+  # end
+  #
+  # @experimental
+  module_function def connect_to_browser_server(ws_endpoint, browser_type: 'chromium', &block)
+    known_browser_types = ['chromium', 'firefox', 'webkit']
+    unless known_browser_types.include?(browser_type)
+      raise ArgumentError, "Unknown browser type: #{browser_type}. Known types are: #{known_browser_types.join(', ')}"
+    end
+
+    require 'playwright/web_socket_client'
+    require 'playwright/web_socket_transport'
+
+    transport = WebSocketTransport.new(
+      ws_endpoint: ws_endpoint,
+      headers: { 'x-playwright-browser' => browser_type },
+    )
+    connection = Connection.new(transport)
+    connection.mark_as_remote
+    connection.async_run
+
+    execution =
+      begin
+        playwright = connection.initialize_playwright
+        browser = playwright.send(:pre_launched_browser)
+        browser.send(:connect_to_browser_type, playwright.send(browser_type), nil)
+        browser.send(:should_close_connection_on_close!)
+        Execution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(browser))
+      rescue
+        connection.stop
+        raise
+      end
+
+    if block
+      begin
+        block.call(execution.browser)
+      ensure
+        execution.stop
+      end
+    else
+      execution
+    end
+  end
+
+  # Connects to Playwright server, launched by `npx playwright launch-server --browser _android` or `playwright._android.launchServer()`
+  #
+  # Playwright.connect_to_android_server('ws://....') do |browser|
+  #   page = browser.new_page
+  #   ...
+  # end
+  #
+  # @experimental
+  module_function def connect_to_android_server(ws_endpoint, &block)
+    require 'playwright/web_socket_client'
+    require 'playwright/web_socket_transport'
+
+    transport = WebSocketTransport.new(ws_endpoint: ws_endpoint)
+    connection = Connection.new(transport)
+    connection.mark_as_remote
+    connection.async_run
 
-    connection = Connection.new(playwright_cli_executable_path: playwright_cli_executable_path)
+    execution =
+      begin
+        playwright = connection.initialize_playwright
+        android_device = playwright.send(:pre_connected_android_device)
+        android_device.should_close_connection_on_close!
+        AndroidExecution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(android_device))
+      rescue
+        connection.stop
+        raise
+      end
 
-    playwright_promise = connection.async_wait_for_object_with_known_name('Playwright')
-    Thread.new { connection.run }
-    playwright = PlaywrightApi.from_channel_owner(playwright_promise.value!)
-    begin
-      block.call(playwright)
-    ensure
-      connection.stop
+    if block
+      begin
+        block.call(execution.device)
+      ensure
+        execution.stop
+      end
+    else
+      execution
     end
   end
 end

data/lib/playwright_api/android.rb

@@ -1,33 +1,68 @@
 module Playwright
-  # @nodoc
+  #
+  # Playwright has **experimental** support for Android automation. This includes Chrome for Android and Android WebView.
+  #
+  # *Requirements*
+  # - Android device or AVD Emulator.
+  # - [ADB daemon](https://developer.android.com/studio/command-line/adb) running and authenticated with your device. Typically running `adb devices` is all you need to do.
+  # - [`Chrome 87`](https://play.google.com/store/apps/details?id=com.android.chrome) or newer installed on the device
+  # - "Enable command line on non-rooted devices" enabled in `chrome://flags`.
+  #
+  # *Known limitations*
+  # - Raw USB operation is not yet supported, so you need ADB.
+  # - Device needs to be awake to produce screenshots. Enabling "Stay awake" developer mode will help.
+  # - We didn't run all the tests against the device, so not everything works.
+  #
+  # *How to run*
+  #
+  # An example of the Android automation script would be:
   class Android < PlaywrightApi
 
+    #
+    # This methods attaches Playwright to an existing Android device.
+    # Use [`method: Android.launchServer`] to launch a new Android server instance.
+    def connect(wsEndpoint, headers: nil, slowMo: nil, timeout: nil)
+      raise NotImplementedError.new('connect is not implemented yet.')
+    end
+
+    #
+    # Returns the list of detected Android devices.
+    def devices(host: nil, omitDriverInstall: nil, port: nil)
+      wrap_impl(@impl.devices(host: unwrap_impl(host), omitDriverInstall: unwrap_impl(omitDriverInstall), port: unwrap_impl(port)))
+    end
+
+    #
+    # This setting will change the default maximum time for all the methods accepting `timeout` option.
+    def set_default_timeout(timeout)
+      wrap_impl(@impl.set_default_timeout(unwrap_impl(timeout)))
+    end
+    alias_method :default_timeout=, :set_default_timeout
+
     # @nodoc
-    def devices
-      wrap_impl(@impl.devices)
+    def set_default_navigation_timeout(timeout)
+      wrap_impl(@impl.set_default_navigation_timeout(unwrap_impl(timeout)))
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+      event_emitter_proxy.off(event, callback)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end