bidi2pdf 0.1.3 → 0.1.5

data/lib/bidi2pdf/bidi/session.rb

@@ -10,134 +10,208 @@ require_relative "user_context"
 module Bidi2pdf
   module Bidi
     class Session
-      SUBSCRIBE_EVENTS = %w[
-        log
-        script
-      ].freeze
+      SUBSCRIBE_EVENTS = %w[log script].freeze
+      DEFAULT_CHROME_ARGS = %w[--disable-gpu --disable-popup-blocking --disable-hang-monitor].freeze
 
-      attr_reader :session_uri, :started
+      attr_reader :session_uri, :started, :chrome_args
 
-      def initialize(session_url:, headless: true)
+      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&.close
-          @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"]
+
+        Bidi2pdf.logger.info "Created session with ID: #{session_id}"
+        Bidi2pdf.logger.info "WebSocket URL: #{ws_url}"
+        ws_url
+      end
 
-        args << "--headless" if @headless
+      def session_request
+        session_chrome_args = chrome_args.dup
+        session_chrome_args << "--headless" if @headless
 
-        session_request = {
+        {
           "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
+
+      def build_error(error, message, backtrace = nil)
+        {
+          "value" => {
+            "error" => error,
+            "message" => message,
+            "stacktrace" => backtrace&.join("\n")
+          }.compact
+        }
+      end
 
-        @websocket_url
+      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
 
-      # rubocop:enable Metrics/AbcSize
+      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
@@ -140,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

@@ -31,6 +31,10 @@ module Bidi2pdf
     USAGE
 
     option :url, desc: "The URL to render"
+    # of course, it's possible to render a local file via: --url file:///path/to/the/file.html
+    # but this should showcase the scenario that you render a string within ruby as pdf without the need
+    # to store it on disc
+    option :html_file, desc: "The local HTML file to render"
     option :output, default: "output.pdf", desc: "Filename for the output PDF", aliases: "-o"
     option :cookie, type: :array, default: [], banner: "name=value", desc: "One or more cookies", aliases: "-C"
     option :header, type: :array, default: [], banner: "name=value", desc: "One or more custom headers", aliases: "-H"
@@ -63,7 +67,7 @@ module Bidi2pdf
     def render
       load_config
 
-      validate_required_options! :url
+      validate_required_options!
 
       configure
 
@@ -115,14 +119,16 @@ module Bidi2pdf
       YAML.load_file(options[:config]).transform_keys(&:to_sym)
     end
 
-    def validate_required_options!(*keys)
-      keys.each do |key|
-        raise Thor::Error, "Missing required option: --#{key.to_s.tr("_", "-")}" unless merged_options[key]
+    def validate_required_options!
+      if merged_options[:url].nil? && merged_options[:html_file].nil?
+        raise Thor::Error, "Missing required option --url or --html_file needs to be specified"
+      elsif merged_options[:html_file] && !File.readable?(merged_options[:html_file])
+        raise Thor::Error, "HTML file '#{merged_options[:html_file]}' not found or not readable"
       end
     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,12 +183,12 @@ module Bidi2pdf
     end
 
     def launcher
-      # rubocop:disable Layout/BeginEndAlignment
       @launcher ||= begin
                       username, password = parse_auth(merged_options[:auth]) if merged_options[:auth]
 
                       Bidi2pdf::Launcher.new(
                         url: merged_options[:url],
+                        inputfile: merged_options[:hmtl_file],
                         output: merged_options[:output],
                         cookies: parse_key_values(merged_options[:cookie]),
                         headers: parse_key_values(merged_options[:header]),
@@ -195,7 +201,6 @@ module Bidi2pdf
                         print_options: print_options
                       )
                     end
-      # rubocop:enable Layout/BeginEndAlignment
     end
 
     # rubocop:enable Metrics/AbcSize

data/lib/bidi2pdf/dsl.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "bidi2pdf"
+
+module Bidi2pdf
+  module DSL
+    # rubocop: disable  Metrics/AbcSize
+    def self.with_tab(remote_browser_url: nil, port: 0, headless: true, chrome_args: Bidi2pdf::Bidi::Session::DEFAULT_CHROME_ARGS.dup)
+      manager = nil
+      session = nil
+      tab = nil
+
+      begin
+        session = if remote_browser_url
+                    Bidi2pdf::Bidi::Session.new(
+                      session_url: remote_browser_url,
+                      headless: true, # remote is always headless
+                      chrome_args: chrome_args
+                    )
+                  else
+                    manager = Bidi2pdf::ChromedriverManager.new(port: port, headless: headless)
+                    manager.start
+                    manager.session
+                  end
+
+        session.start
+        session.client.on_close { Bidi2pdf.logger.info "WebSocket session closed" }
+
+        browser = session.browser
+        context = browser.create_user_context
+        window = context.create_browser_window
+        tab = window.create_browser_tab
+
+        yield(tab)
+      ensure
+        tab&.close
+        window&.close
+        session&.close
+        manager&.stop
+      end
+    end
+
+    # rubocop: enable  Metrics/AbcSize
+  end
+end

data/lib/bidi2pdf/launcher.rb

@@ -7,9 +7,10 @@ require_relative "bidi/session"
 module Bidi2pdf
   class Launcher
     # rubocop:disable Metrics/ParameterLists
-    def initialize(url:, output:, cookies:, headers:, auth:, headless: true, port: 0, wait_window_loaded: false,
+    def initialize(url:, inputfile:, output:, cookies:, headers:, auth:, headless: true, port: 0, wait_window_loaded: false,
                    wait_network_idle: false, print_options: {}, remote_browser_url: nil)
       @url = url
+      @inputfile = inputfile
       @port = port
       @headless = headless
       @output = output
@@ -21,6 +22,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
@@ -29,6 +31,7 @@ module Bidi2pdf
       runner = SessionRunner.new(
         session: session,
         url: @url,
+        inputfile: @inputfile,
         output: @output,
         cookies: @cookies,
         headers: @headers,
@@ -42,13 +45,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/session_runner.rb

@@ -2,10 +2,11 @@
 
 module Bidi2pdf
   class SessionRunner
-    def initialize(session:, url:, output:, cookies: {}, headers: {}, auth: {}, wait_window_loaded: false,
+    def initialize(session:, url:, inputfile:, output:, cookies: {}, headers: {}, auth: {}, wait_window_loaded: false,
                    wait_network_idle: false, print_options: {})
       @session = session
       @url = url
+      @inputfile = inputfile
       @output = output
       @cookies = cookies || {}
       @headers = headers || {}
@@ -75,7 +76,13 @@ module Bidi2pdf
       @session.status
       @session.user_contexts
 
-      @tab.open_page(@url)
+      if @url
+        @tab.open_page(@url)
+      else
+        Bidi2pdf.logger.info "Loading HTML file #{@inputfile}"
+        data = File.read(@inputfile)
+        @tab.view_html_page(data)
+      end
 
       if @wait_network_idle
         Bidi2pdf.logger.info "Waiting for network idle"

data/lib/bidi2pdf/version.rb

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

data/lib/bidi2pdf.rb

@@ -4,14 +4,29 @@ require_relative "bidi2pdf/utils"
 require_relative "bidi2pdf/process_tree"
 require_relative "bidi2pdf/launcher"
 require_relative "bidi2pdf/bidi/session"
+require_relative "bidi2pdf/dsl"
 
 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
+
+  class PrintError < Error; end
+
   @logger = Logger.new($stdout)
-  @logger.level = Logger::DEBUG
+  @logger.level = Logger::INFO
 
   @default_timeout = 60
 

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