bidi2pdf 0.1.2 → 0.1.4

data/lib/bidi2pdf/bidi/session.rb

@@ -10,143 +10,208 @@ require_relative "user_context"
 module Bidi2pdf
   module Bidi
     class Session
-      SUBSCRIBE_EVENTS = [
-        "browsingContext",
-        "network",
-        "log",
-        "script",
-        "goog:cdp.Debugger.scriptParsed",
-        "goog:cdp.CSS.styleSheetAdded",
-        "goog:cdp.Runtime.executionContextsCleared",
-        # Tracing
-        "goog:cdp.Tracing.tracingComplete",
-        "goog:cdp.Network.requestWillBeSent",
-        "goog:cdp.Debugger.scriptParsed",
-        "goog:cdp.Page.screencastFrame"
-      ].freeze
-
-      attr_reader :session_uri, :started
-
-      def initialize(session_url:, headless: true)
+      SUBSCRIBE_EVENTS = %w[log script].freeze
+      DEFAULT_CHROME_ARGS = %w[--disable-gpu --disable-popup-blocking --disable-hang-monitor].freeze
+
+      attr_reader :session_uri, :started, :chrome_args
+
+      def initialize(session_url:, headless: true, chrome_args: DEFAULT_CHROME_ARGS)
         @session_uri = URI(session_url)
         @headless = headless
-        @client = nil
-        @browser = nil
-        @websocket_url = nil
         @started = false
+        @chrome_args = chrome_args.dup
       end
 
       def start
+        return if started?
+
         @started = true
         client
+      rescue StandardError => e
+        @started = false
+        raise e
       end
 
       def client
-        @client ||= @started ? create_client : nil
-      end
-
-      def close
-        client&.send_cmd_and_wait("session.end", {}) do |response|
-          Bidi2pdf.logger.debug "Session ended: #{response}"
-          @client = nil
-          @websocket_url = nil
-          @browser = nil
-        end
+        @client ||= started? ? create_client : nil
       end
 
       def browser
         @browser ||= create_browser
       end
 
-      def user_contexts
-        client&.send_cmd_and_wait("browser.getUserContexts", {}) do |response|
-          Bidi2pdf.logger.debug "User contexts: #{response}"
+      def close
+        return unless started?
+
+        2.times do |attempt|
+          client&.send_cmd_and_wait(Bidi2pdf::Bidi::Commands::SessionEnd.new, timeout: 1) do |response|
+            Bidi2pdf.logger.info "Session ended: #{response}"
+
+            cleanup
+          end
+          break
+        rescue CmdTimeoutError
+          Bidi2pdf.logger.error "Session end command timed out. Retrying... (#{attempt + 1})"
         end
       end
 
+      def user_contexts
+        send_cmd(Bidi2pdf::Bidi::Commands::GetUserContexts.new) { |resp| Bidi2pdf.logger.debug "User contexts: #{resp}" }
+      end
+
       def status
-        client&.send_cmd_and_wait("session.status", {}) do |response|
-          Bidi2pdf.logger.info "Session status: #{response.inspect}"
-        end
+        send_cmd(Bidi2pdf::Bidi::Commands::SessionStatus.new) { |resp| Bidi2pdf.logger.info "Session status: #{resp.inspect}" }
+      end
+
+      def started?
+        @started
+      end
+
+      def websocket_url
+        return @websocket_url if @websocket_url
+
+        @websocket_url = if %w[ws wss].include?(session_uri.scheme)
+                           session_uri.to_s
+                         else
+                           create_new_session
+                         end
       end
 
       private
 
+      def send_cmd(command, &block)
+        client&.send_cmd_and_wait(command, &block)
+      end
+
+      # rubocop: disable Metrics/AbcSize
       def create_browser
         start
-
-        @client.start
-        @client.wait_until_open
+        client.start
+        client.wait_until_open
 
         Bidi2pdf.logger.info "Subscribing to events"
 
-        event_client = Bidi::Client.new(websocket_url).tap(&:start)
-        event_client.wait_until_open
+        Bidi::Client.new(websocket_url).tap do |event_client|
+          event_client.start
+          event_client.wait_until_open
 
-        event_client.on_event(*SUBSCRIBE_EVENTS) do |data|
-          Bidi2pdf.logger.debug "Received event: #{data["method"]}, params: #{data["params"]}"
+          event_client.on_event(*SUBSCRIBE_EVENTS) do |data|
+            Bidi2pdf.logger.debug "Received event: #{data["method"]}, params: #{data["params"]}"
+          end
         end
 
-        Bidi::Browser.new(@client)
+        Bidi::Browser.new(client)
       end
 
+      # rubocop: enable Metrics/AbcSize
+
       def create_client
         Bidi::Client.new(websocket_url).tap(&:start)
       end
 
-      # rubocop:disable Metrics/AbcSize
-      def websocket_url
-        return @websocket_url if @websocket_url
+      def create_new_session
+        session_data = exec_api_call(session_request)
+        Bidi2pdf.logger.debug "Session data: #{session_data}"
 
-        if %w[ws wss].include?(session_uri.scheme)
-          @websocket_url = session_uri.to_s
-          return @websocket_url
-        end
+        value = session_data["value"]
+        handle_error(value) if value.nil? || value["error"]
 
-        args = %w[
-          --disable-gpu
-          --disable-popup-blocking
-          --disable-hang-monitor
-        ]
+        session_id = value["sessionId"]
+        ws_url = value["capabilities"]["webSocketUrl"]
 
-        args << "--headless" if @headless
+        Bidi2pdf.logger.info "Created session with ID: #{session_id}"
+        Bidi2pdf.logger.info "WebSocket URL: #{ws_url}"
+        ws_url
+      end
 
-        session_request = {
+      def session_request
+        session_chrome_args = chrome_args.dup
+        session_chrome_args << "--headless" if @headless
+
+        {
           "capabilities" => {
             "alwaysMatch" => {
               "browserName" => "chrome",
-              "goog:chromeOptions" => {
-                "args" => args
-              },
+              "goog:chromeOptions" => { "args" => session_chrome_args },
               "goog:prerenderingDisabled" => true,
-              "unhandledPromptBehavior" => {
-                default: "ignore"
-              },
+              "unhandledPromptBehavior" => { default: "ignore" },
               "acceptInsecureCerts" => true,
               "webSocketUrl" => true
             }
           }
         }
+      end
 
-        response = Net::HTTP.post(session_uri, session_request.to_json, "Content-Type" => "application/json")
+      def exec_api_call(payload)
+        response = Net::HTTP.post(session_uri, payload.to_json, "Content-Type" => "application/json")
+        body = response.body
+        code = response.code.to_i
 
-        Bidi2pdf.logger.debug "Response code: #{response.code}"
-        Bidi2pdf.logger.debug "Response body: #{response.body}"
+        if code != 200
+          log_api_error("Failed to create session", code, body)
+          return build_error("Session creation failed", "Response code: #{code}")
+        end
 
-        session_data = JSON.parse(response.body)
+        JSON.parse(body)
+      rescue StandardError => e
+        error_type = error_category(e)
+        build_error(error_type, "#{error_description(error_type)} #{e.message}", e.backtrace)
+      end
 
-        Bidi2pdf.logger.debug "Session data: #{session_data}"
+      def log_api_error(message, code, body)
+        Bidi2pdf.logger.error "#{message}. Response code: #{code}"
+        Bidi2pdf.logger.error "Response body: #{body}"
+      end
 
-        session_id = session_data["value"]["sessionId"]
-        @websocket_url = session_data["value"]["capabilities"]["webSocketUrl"]
+      def error_category(exception)
+        case exception
+        when Errno::ECONNREFUSED then "Connection refused"
+        when JSON::ParserError then "Invalid JSON response"
+        else "Unknown error"
+        end
+      end
 
-        Bidi2pdf.logger.info "Created session with ID: #{session_id}"
-        Bidi2pdf.logger.info "WebSocket URL: #{@websocket_url}"
+      def error_description(type)
+        {
+          "Connection refused" => "Could not connect to the session URL:",
+          "Invalid JSON response" => "Could not parse the response:",
+          "Unknown error" => "An unknown error occurred:"
+        }[type]
+      end
 
-        @websocket_url
+      def build_error(error, message, backtrace = nil)
+        {
+          "value" => {
+            "error" => error,
+            "message" => message,
+            "stacktrace" => backtrace&.join("\n")
+          }.compact
+        }
       end
 
-      # rubocop:enable Metrics/AbcSize
+      def handle_error(value)
+        error = value["error"]
+        return unless error
+
+        msg = value["message"]
+        trace = value["stacktrace"]
+
+        Bidi2pdf.logger.error "Error: #{error} message: #{msg}"
+        Bidi2pdf.logger.error "Stacktrace: #{trace}" if trace
+
+        if msg =~ /probably user data directory is already in use/
+          Bidi2pdf.logger.info "Container detected with headless-only support, ensure xvfb is started" unless @headless
+          Bidi2pdf.logger.info "Check chromedriver permissions and --user-data-dir"
+        end
+
+        raise SessionNotStartedError,
+              "Session not started. Check logs for more details. Error: #{error} message: #{msg}"
+      end
+
+      def cleanup
+        @client&.close
+        @client = @websocket_url = @browser = nil
+      end
     end
   end
 end

data/lib/bidi2pdf/bidi/user_context.rb

@@ -14,14 +14,16 @@ module Bidi2pdf
 
       def context_id
         @context_id ||= begin
-          res = client.send_cmd_and_wait("browser.createUserContext", {}) do |response|
-            response["result"]["userContext"]
-          end
+                          res = client.send_cmd_and_wait(Bidi2pdf::Bidi::Commands::BrowserCreateUserContext.new) do |response|
+                            raise "Error creating user context: #{response.inspect}" if response["error"]
 
-          Bidi2pdf.logger.debug "User context created: #{res.inspect}"
+                            response["result"]["userContext"]
+                          end
 
-          res
-        end
+                          Bidi2pdf.logger.debug "User context created: #{res.inspect}"
+
+                          res
+                        end
       end
 
       def set_cookie(
@@ -35,36 +37,28 @@ module Bidi2pdf
         same_site: "strict",
         ttl: 30
       )
-        expiry = Time.now.to_i + ttl
-        client.send_cmd_and_wait("storage.setCookie", {
-          cookie: {
-            name: name,
-            value: {
-              type: "string",
-              value: value
-            },
-            domain: domain,
-            path: path,
-            secure: secure,
-            httpOnly: http_only,
-            sameSite: same_site,
-            expiry: expiry
-          },
-          partition: {
-            type: "storageKey",
-            userContext: context_id,
-            sourceOrigin: source_origin
-          }
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::SetUsercontextCookie.new(
+          user_context_id: context_id,
+          source_origin: source_origin,
+          name: name,
+          value: value,
+          domain: domain,
+          path: path,
+          secure: secure,
+          http_only: http_only,
+          same_site: same_site,
+          ttl: ttl
+        )
+
+        client.send_cmd_and_wait(cmd) do |response|
           Bidi2pdf.logger.debug "Cookie set: #{response.inspect}"
         end
       end
 
       def create_browser_window
-        client.send_cmd_and_wait("browsingContext.create", {
-          type: "window",
-          userContext: context_id
-        }) do |response|
+        cmd = Bidi2pdf::Bidi::Commands::CreateWindow.new(user_context_id: context_id)
+
+        client.send_cmd_and_wait(cmd) do |response|
           browsing_context_id = response["result"]["context"]
 
           BrowserTab.new(client, browsing_context_id, context_id)

data/lib/bidi2pdf/bidi/web_socket_dispatcher.rb

@@ -42,6 +42,8 @@ module Bidi2pdf
 
       def remove_error_listener(block) = socket_events.off(:error, block)
 
+      private
+
       def setup_message_handler
         that = self
 

data/lib/bidi2pdf/chromedriver_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "chromedriver/binary"
+require "securerandom"
 
 module Bidi2pdf
   class ChromedriverManager
@@ -55,9 +56,11 @@ module Bidi2pdf
 
       close_session
 
-      term_chromedriver
+      debug_show_all_children
+
+      old_childprocesses = term_chromedriver
 
-      detect_zombie_processes
+      detect_zombie_processes old_childprocesses
 
       return unless process_alive?
 
@@ -68,14 +71,10 @@ module Bidi2pdf
 
     private
 
-    # rubocop:disable Metrics/AbcSize
-    def detect_zombie_processes
-      debug_show_all_children
+    def detect_zombie_processes(old_childprocesses)
+      Bidi2pdf.logger.debug "Old child processes for #{@pid}: #{old_childprocesses.map(&:pid).join(", ")}"
 
-      child_processes = Bidi2pdf::ProcessTree.new(@pid).children(@pid)
-      Bidi2pdf.logger.debug "Found child processes: #{child_processes.map(&:pid).join(", ")}"
-
-      zombie_processes = child_processes.select { |child| process_alive? child.pid }
+      zombie_processes = old_childprocesses.select { |child| process_alive? child.pid }
 
       return if zombie_processes.empty?
 
@@ -83,9 +82,18 @@ module Bidi2pdf
       printable_zombie_processes_str = printable_zombie_processes.join(", ")
 
       Bidi2pdf.logger.error "Zombie Processes detected #{printable_zombie_processes_str}"
+
+      term_zombie_processes zombie_processes
     end
 
-    # rubocop:enable Metrics/AbcSize
+    def term_zombie_processes(zombie_processes)
+      Bidi2pdf.logger.info "Terminating zombie processes: #{zombie_processes.map(&:pid).join(", ")}"
+
+      zombie_processes.each do |child|
+        Bidi2pdf.logger.debug "Terminating PID #{child.pid} (#{child.name})"
+        Process.kill("TERM", child.pid)
+      end
+    end
 
     def debug_show_all_children
       Bidi2pdf::ProcessTree.new(@pid).traverse do |process, level|
@@ -103,9 +111,11 @@ module Bidi2pdf
     end
 
     def term_chromedriver
-      Bidi2pdf.logger.info "Stopping Chromedriver (PID #{@pid})"
+      Bidi2pdf::ProcessTree.new(@pid).children(@pid).tap do |_child_processes|
+        Bidi2pdf.logger.info "Stopping Chromedriver (PID #{@pid})"
 
-      Process.kill("TERM", @pid)
+        Process.kill("TERM", @pid)
+      end
     rescue Errno::ESRCH
       Bidi2pdf.logger.debug "Process already gone"
       @pid = nil
@@ -131,7 +141,7 @@ module Bidi2pdf
 
     def build_cmd
       bin = Chromedriver::Binary::ChromedriverDownloader.driver_path
-      user_data_dir = File.join(Dir.tmpdir, "bidi2pdf", "user_data")
+      user_data_dir = File.join(Dir.tmpdir, "bidi2pdf", "user_data", SecureRandom.hex(8))
 
       cmd = [bin]
       cmd << "--port=#{@port}" unless @port.zero?

data/lib/bidi2pdf/cli.rb

@@ -122,7 +122,7 @@ module Bidi2pdf
     end
 
     def validate_print_options(opts)
-      Bidi2pdf::Bidi::PrintParametersValidator.validate!(opts)
+      Bidi2pdf::Bidi::Commands::PrintParametersValidator.validate!(opts)
     rescue ArgumentError => e
       raise Thor::Error, "Invalid print option: #{e.message}"
     end
@@ -177,7 +177,6 @@ module Bidi2pdf
     end
 
     def launcher
-      # rubocop:disable Layout/BeginEndAlignment
       @launcher ||= begin
                       username, password = parse_auth(merged_options[:auth]) if merged_options[:auth]
 
@@ -195,7 +194,6 @@ module Bidi2pdf
                         print_options: print_options
                       )
                     end
-      # rubocop:enable Layout/BeginEndAlignment
     end
 
     # rubocop:enable Metrics/AbcSize

data/lib/bidi2pdf/launcher.rb

@@ -21,6 +21,7 @@ module Bidi2pdf
       @wait_network_idle = wait_network_idle
       @print_options = print_options || {}
       @remote_browser_url = remote_browser_url
+      @custom_session = nil
     end
 
     # rubocop:enable Metrics/ParameterLists
@@ -42,13 +43,14 @@ module Bidi2pdf
 
     def stop
       @manager&.stop
+      @custom_session&.close
     end
 
     private
 
     def session
       if @remote_browser_url
-        Bidi::Session.new(session_url: @remote_browser_url, headless: @headless)
+        @custom_session = Bidi::Session.new(session_url: @remote_browser_url, headless: @headless)
       else
         @manager = ChromedriverManager.new(port: @port, headless: @headless)
         @manager.start

data/lib/bidi2pdf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bidi2pdf
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/bidi2pdf.rb

@@ -10,6 +10,18 @@ require "logger"
 module Bidi2pdf
   class Error < StandardError; end
 
+  class SessionNotStartedError < Error; end
+
+  class WebsocketError < Error; end
+
+  class ClientError < WebsocketError; end
+
+  class CmdError < ClientError; end
+
+  class CmdResponseNotStoredError < ClientError; end
+
+  class CmdTimeoutError < ClientError; end
+
   @logger = Logger.new($stdout)
   @logger.level = Logger::DEBUG
 

data/sig/bidi2pdf/bidi/command_manager.rbs

@@ -0,0 +1,41 @@
+module Bidi2pdf
+  module Bidi
+    class CommandManager
+      self.@id: untyped
+
+      self.@id_mutex: untyped
+
+      @socket: untyped
+
+      @logger: untyped
+
+      @pending_responses: untyped
+
+      @initiated_cmds: untyped
+
+      def self.initialize_counter: () -> untyped
+
+      def self.next_id: () -> untyped
+
+      def initialize: (untyped socket, logger: untyped) -> void
+
+      def send_cmd: (untyped cmd, ?store_response: bool) -> untyped
+
+      def send_cmd_and_wait: (untyped cmd, ?timeout: untyped) ?{ (untyped) -> untyped } -> untyped
+
+      def pop_response: (untyped id, timeout: untyped) -> untyped
+
+      def handle_response: (untyped data) -> (true | untyped | false)
+
+      private
+
+      def init_queue_for: (untyped id) -> untyped
+
+      def next_id: () -> untyped
+
+      def redact_sensitive_fields: (untyped obj, ?::Array[untyped] sensitive_keys) -> untyped
+
+      def raise_timeout_error: (untyped id, untyped cmd) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/add_intercept.rbs

@@ -0,0 +1,21 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class AddIntercept
+        include Base
+
+        BEFORE_REQUEST: String
+        RESPONSE_STARTED: String
+        AUTH_REQUIRED: String
+
+        @context: String
+        @phases: Array[String]
+        @url_patterns: Array[String]
+
+        def initialize: (context: String, phases: Array[String], url_patterns: Array[String]) -> void
+
+        def validate_phases!: () -> void
+      end
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/base.rbs

@@ -0,0 +1,27 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      module Base
+        def method_name: () -> String
+
+        def params: () -> Hash[Symbol, untyped]
+
+        def as_payload: (untyped id) -> Hash[Symbol, untyped]
+
+        def ==: (untyped other) -> bool
+
+        def eql?: (untyped other) -> bool
+
+        def hash: () -> Integer
+
+        def inspect: () -> String
+
+        private
+
+        def redact_sensitive_fields: (untyped obj, Array[String] sensitive_keys) -> untyped
+
+        def raise_timeout_error: (untyped id, String method, Hash[Symbol, untyped] params) -> void
+      end
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/browser_close.rbs

@@ -0,0 +1,9 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowserClose
+        include Commands::Base
+      end
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/browser_create_user_context.rbs

@@ -0,0 +1,9 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowserCreateUserContext
+        include Base
+      end
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/browsing_context_close.rbs

@@ -0,0 +1,11 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowsingContextClose
+        include Commands::Base
+
+        def initialize: (context: String) -> void
+      end
+    end
+  end
+end

data/sig/bidi2pdf/bidi/commands/browsing_context_navigate.rbs

@@ -0,0 +1,15 @@
+module Bidi2pdf
+  module Bidi
+    module Commands
+      class BrowsingContextNavigate
+        include Commands::Base
+
+        def initialize: (
+            url: String,
+            context: String,
+            ?wait: String
+          ) -> void
+      end
+    end
+  end
+end