Class: Puppeteer::CDPSession

Inherits:
Object
  • Object
show all
Includes:
DebugPrint, EventCallbackable
Defined in:
lib/puppeteer/cdp_session.rb

Overview

rbs_inline: enabled

Defined Under Namespace

Classes: Error

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from EventCallbackable

#add_event_listener, #emit_event, #observe_first, #off, #on_event, #remove_event_listener

Methods included from DebugPrint

#debug_print, #debug_puts

Constructor Details

#initialize(connection, target_type, session_id, parent_session: nil) ⇒ CDPSession

Returns a new instance of CDPSession.



15
16
17
18
19
20
21
22
23
24
 
# File 'lib/puppeteer/cdp_session.rb', line 15

def initialize(connection, target_type, session_id, parent_session: nil)
  @callbacks = {}
  @callbacks_mutex = Mutex.new
  @connection = connection
  @target_type = target_type
  @session_id = session_id
  @parent_session = parent_session
  @ready_promise = Async::Promise.new
  @target = nil
end

Instance Attribute Details

#connection ⇒ Object (readonly)

: Puppeteer::Connection?



31
32
33
 
# File 'lib/puppeteer/cdp_session.rb', line 31

def connection
  @connection
end

#parent_session ⇒ Object (readonly)

: Puppeteer::CDPSession?



32
33
34
 
# File 'lib/puppeteer/cdp_session.rb', line 32

def parent_session
  @parent_session
end

#target ⇒ Object

: Puppeteer::Target?



33
34
35
 
# File 'lib/puppeteer/cdp_session.rb', line 33

def target
  @target
end

Instance Method Details

#async_send_message(method, params = {}) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/puppeteer/cdp_session.rb', line 67

def async_send_message(method, params = {})
  if !@connection
    raise Error.new("Protocol error (#{method}): Session closed. Most likely the #{@target_type} has been closed.")
  end

  promise = Async::Promise.new

  @connection.generate_id do |id|
    @callbacks_mutex.synchronize do
      @callbacks[id] = Puppeteer::Connection::MessageCallback.new(method: method, promise: promise)
    end
    @connection.raw_send(id: id, message: { sessionId: @session_id, method: method, params: params })
  end

  promise
end

#detach ⇒ Object 



111
112
113
114
115
116
 
# File 'lib/puppeteer/cdp_session.rb', line 111

def detach
  if !@connection
    raise Error.new("Session already detarched. Most likely the #{@target_type} has been closed.")
  end
  @connection.send_message('Target.detachFromTarget',  sessionId: @session_id)
end

#handle_closed ⇒ Object 



119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/puppeteer/cdp_session.rb', line 119

def handle_closed
  callbacks = @callbacks_mutex.synchronize do
    @callbacks.values.tap { @callbacks.clear }
  end
  callbacks.each do |callback|
    callback.reject(
      Puppeteer::Connection::ProtocolError.new(
        method: callback.method,
        error_message: 'Target Closed.'))
  end
  @ready_promise.reject(Error.new("Session closed")) unless @ready_promise.resolved?
  @connection = nil
  emit_event(CDPSessionEmittedEvents::Disconnected)
end

#handle_message(message) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/puppeteer/cdp_session.rb', line 86

def handle_message(message)
  if message['id']
    if callback = @callbacks_mutex.synchronize { @callbacks.delete(message['id']) }
      callback_with_message(callback, message)
    else
      raise Error.new("unknown id: #{message['id']}")
    end
  else
    emit_event(message['method'], message['params'])
  end
end

#id ⇒ Object 



27
28
29
 
# File 'lib/puppeteer/cdp_session.rb', line 27

def id
  @session_id
end

#mark_ready ⇒ Object 



36
37
38
 
# File 'lib/puppeteer/cdp_session.rb', line 36

def mark_ready
  @ready_promise.resolve(true) unless @ready_promise.resolved?
end

#on(event_name, &block) ⇒ Object 



137
138
139
 
# File 'lib/puppeteer/cdp_session.rb', line 137

def on(event_name, &block)
  add_event_listener(event_name, &block)
end

#once(event_name, &block) ⇒ Object 



144
145
146
 
# File 'lib/puppeteer/cdp_session.rb', line 144

def once(event_name, &block)
  observe_first(event_name, &block)
end

#send_message(method, params = {}) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/puppeteer/cdp_session.rb', line 48

def send_message(method, params = {})
  protocol_timeout = @connection&.protocol_timeout
  if protocol_timeout && protocol_timeout > 0
    begin
      Puppeteer::AsyncUtils.async_timeout(protocol_timeout, async_send_message(method, params)).wait
    rescue Async::TimeoutError
      raise Puppeteer::Connection::ProtocolError.new(
        method: method,
        error_message: "Timeout #{protocol_timeout}ms exceeded",
      )
    end
  else
    async_send_message(method, params).wait
  end
end

#wait_for_ready ⇒ Object 



41
42
43
 
# File 'lib/puppeteer/cdp_session.rb', line 41

def wait_for_ready
  @ready_promise.wait
end