chromiumoxide/handler/
target.rs

1use std::collections::VecDeque;
2use std::pin::Pin;
3use std::sync::Arc;
4use std::time::Instant;
5
6use futures::channel::oneshot::Sender;
7use futures::stream::Stream;
8use futures::task::{Context, Poll};
9
10use crate::auth::Credentials;
11use crate::cdp::browser_protocol::target::CloseTargetParams;
12use crate::cmd::CommandChain;
13use crate::cmd::CommandMessage;
14use crate::error::{CdpError, Result};
15use crate::handler::browser::BrowserContext;
16use crate::handler::domworld::DOMWorldKind;
17use crate::handler::emulation::EmulationManager;
18use crate::handler::frame::FrameRequestedNavigation;
19use crate::handler::frame::{
20    FrameEvent, FrameManager, NavigationError, NavigationId, NavigationOk,
21};
22use crate::handler::network::{NetworkEvent, NetworkManager};
23use crate::handler::page::PageHandle;
24use crate::handler::viewport::Viewport;
25use crate::handler::{PageInner, REQUEST_TIMEOUT};
26use crate::listeners::{EventListenerRequest, EventListeners};
27use crate::{page::Page, ArcHttpRequest};
28use chromiumoxide_cdp::cdp::browser_protocol::{
29    browser::BrowserContextId,
30    log as cdplog,
31    page::{FrameId, GetFrameTreeParams},
32    target::{AttachToTargetParams, SessionId, SetAutoAttachParams, TargetId, TargetInfo},
33};
34use chromiumoxide_cdp::cdp::events::CdpEvent;
35use chromiumoxide_cdp::cdp::js_protocol::runtime::{
36    ExecutionContextId, RunIfWaitingForDebuggerParams,
37};
38use chromiumoxide_cdp::cdp::CdpEventMessage;
39use chromiumoxide_types::{Command, Method, MethodId, Request, Response};
40use spider_network_blocker::intercept_manager::NetworkInterceptManager;
41use std::time::Duration;
42
43macro_rules! advance_state {
44    ($s:ident, $cx:ident, $now:ident, $cmds: ident, $next_state:expr ) => {{
45        if let Poll::Ready(poll) = $cmds.poll($now) {
46            return match poll {
47                None => {
48                    $s.init_state = $next_state;
49                    $s.poll($cx, $now)
50                }
51                Some(Ok((method, params))) => Some(TargetEvent::Request(Request {
52                    method,
53                    session_id: $s.session_id.clone().map(Into::into),
54                    params,
55                })),
56                Some(Err(_)) => Some($s.on_initialization_failed()),
57            };
58        } else {
59            return None;
60        }
61    }};
62}
63
64lazy_static::lazy_static! {
65    /// Initial start command params (global SetAutoAttach + disable logging + optional performance).
66    static ref INIT_COMMANDS_PARAMS: Vec<(MethodId, serde_json::Value)> = {
67        if let Ok(attach) = SetAutoAttachParams::builder()
68            .flatten(true)
69            .auto_attach(true)
70            .wait_for_debugger_on_start(true)
71            .build() {
72                let disable_log = cdplog::DisableParams::default();
73
74                let mut cmds =  vec![
75                    (
76                        attach.identifier(),
77                        serde_json::to_value(attach).unwrap_or_default(),
78                    ),
79                    (
80                        disable_log.identifier(),
81                        serde_json::to_value(disable_log).unwrap_or_default(),
82                    )
83                ];
84
85                // enable performance on pages.
86                if cfg!(feature = "collect_metrics") {
87                    let enable_performance = chromiumoxide_cdp::cdp::browser_protocol::performance::EnableParams::default();
88                    cmds.push((
89                        enable_performance.identifier(),
90                        serde_json::to_value(enable_performance).unwrap_or_default(),
91                    ));
92                }
93
94                cmds
95            } else {
96                vec![]
97            }
98    };
99
100    /// Attach to target commands (RunIfWaitingForDebugger).
101    static ref ATTACH_TARGET: (MethodId, serde_json::Value) = {
102        let runtime_cmd = RunIfWaitingForDebuggerParams::default();
103        (
104            runtime_cmd.identifier(),
105            serde_json::to_value(runtime_cmd).unwrap_or_default()
106        )
107    };
108}
109
110#[derive(Debug)]
111pub struct Target {
112    /// Info about this target as returned from the chromium instance
113    info: TargetInfo,
114    /// The type of this target
115    r#type: TargetType,
116    /// Configs for this target
117    config: TargetConfig,
118    /// The context this target is running in
119    browser_context: BrowserContext,
120    /// The frame manager that maintains the state of all frames and handles
121    /// navigations of frames
122    frame_manager: FrameManager,
123    /// Handles all the https
124    pub(crate) network_manager: NetworkManager,
125    emulation_manager: EmulationManager,
126    /// The identifier of the session this target is attached to
127    session_id: Option<SessionId>,
128    /// The handle of the browser page of this target
129    page: Option<PageHandle>,
130    /// Drives this target towards initialization
131    pub(crate) init_state: TargetInit,
132    /// Currently queued events to report to the `Handler`
133    queued_events: VecDeque<TargetEvent>,
134    /// All registered event subscriptions
135    event_listeners: EventListeners,
136    /// Senders that need to be notified once the main frame has loaded
137    wait_for_frame_navigation: Vec<Sender<ArcHttpRequest>>,
138    /// Senders that need to be notified once the main frame reaches `networkIdle`.
139    wait_for_network_idle: Vec<Sender<ArcHttpRequest>>,
140    /// (Optional) for `networkAlmostIdle` if you want it as well.
141    wait_for_network_almost_idle: Vec<Sender<ArcHttpRequest>>,
142    /// The sender who requested the page.
143    initiator: Option<Sender<Result<Page>>>,
144    /// Emulation init commands we want to forward to worker / service_worker / shared_worker targets.
145    attached_emulation_init_cmds: Vec<(MethodId, serde_json::Value)>,
146    /// Set attached agents.
147    attached_user_agent_override: Option<(MethodId, serde_json::Value)>,
148}
149
150impl Target {
151    /// Create a new target instance with `TargetInfo` after a
152    /// `CreateTargetParams` request.
153    pub fn new(info: TargetInfo, config: TargetConfig, browser_context: BrowserContext) -> Self {
154        let ty = TargetType::new(&info.r#type);
155        let request_timeout: Duration = config.request_timeout;
156        let mut network_manager = NetworkManager::new(config.ignore_https_errors, request_timeout);
157
158        if !config.cache_enabled {
159            network_manager.set_cache_enabled(false);
160        }
161
162        if !config.service_worker_enabled {
163            network_manager.set_service_worker_enabled(true);
164        }
165
166        network_manager.set_request_interception(config.request_intercept);
167        network_manager.max_bytes_allowed = config.max_bytes_allowed;
168
169        if let Some(headers) = &config.extra_headers {
170            network_manager.set_extra_headers(headers.clone());
171        }
172
173        if let Some(white_list) = &config.whitelist_patterns {
174            network_manager.set_whitelist_patterns(white_list.clone());
175        }
176
177        network_manager.ignore_visuals = config.ignore_visuals;
178        network_manager.block_javascript = config.ignore_javascript;
179        network_manager.block_analytics = config.ignore_analytics;
180        network_manager.block_stylesheets = config.ignore_stylesheets;
181        network_manager.only_html = config.only_html;
182        network_manager.intercept_manager = config.intercept_manager;
183
184        Self {
185            info,
186            r#type: ty,
187            config,
188            frame_manager: FrameManager::new(request_timeout),
189            network_manager,
190            emulation_manager: EmulationManager::new(request_timeout),
191            session_id: None,
192            page: None,
193            init_state: TargetInit::AttachToTarget,
194            wait_for_frame_navigation: Default::default(),
195            wait_for_network_idle: Default::default(),
196            wait_for_network_almost_idle: Default::default(),
197            queued_events: Default::default(),
198            event_listeners: Default::default(),
199            initiator: None,
200            browser_context,
201            attached_emulation_init_cmds: Vec::new(),
202            attached_user_agent_override: None,
203        }
204    }
205
206    /// Set the session id.
207    pub fn set_session_id(&mut self, id: SessionId) {
208        self.session_id = Some(id)
209    }
210
211    /// Get the session id.
212    pub fn session_id(&self) -> Option<&SessionId> {
213        self.session_id.as_ref()
214    }
215
216    /// Get the session id mut.
217    pub fn session_id_mut(&mut self) -> &mut Option<SessionId> {
218        &mut self.session_id
219    }
220
221    /// Get the browser context.
222    pub fn browser_context(&self) -> &BrowserContext {
223        &self.browser_context
224    }
225
226    /// The identifier for this target
227    pub fn target_id(&self) -> &TargetId {
228        &self.info.target_id
229    }
230
231    /// The type of this target
232    pub fn r#type(&self) -> &TargetType {
233        &self.r#type
234    }
235
236    /// Whether this target is already initialized
237    pub fn is_initialized(&self) -> bool {
238        matches!(self.init_state, TargetInit::Initialized)
239    }
240
241    /// Navigate a frame
242    pub fn goto(&mut self, req: FrameRequestedNavigation) {
243        if self.network_manager.has_target_domain() {
244            self.network_manager.clear_target_domain();
245            let goto_url = req
246                .req
247                .params
248                .as_object()
249                .and_then(|o| o.get("url"))
250                .and_then(|v| v.as_str());
251
252            if let Some(url) = goto_url {
253                self.network_manager.set_page_url(url.into());
254            }
255        }
256        self.frame_manager.goto(req);
257    }
258
259    /// Create a new page from the session.
260    fn create_page(&mut self) {
261        if self.page.is_none() {
262            if let Some(session) = self.session_id.clone() {
263                let handle =
264                    PageHandle::new(self.target_id().clone(), session, self.opener_id().cloned());
265                self.page = Some(handle);
266            }
267        }
268    }
269
270    /// Tries to create the `PageInner` if this target is already initialized
271    pub(crate) fn get_or_create_page(&mut self) -> Option<&Arc<PageInner>> {
272        self.create_page();
273        self.page.as_ref().map(|p| p.inner())
274    }
275
276    /// Is the target a page?
277    pub fn is_page(&self) -> bool {
278        self.r#type().is_page()
279    }
280
281    /// The browser context ID.
282    pub fn browser_context_id(&self) -> Option<&BrowserContextId> {
283        self.info.browser_context_id.as_ref()
284    }
285
286    /// The target connection info.
287    pub fn info(&self) -> &TargetInfo {
288        &self.info
289    }
290
291    /// Get the target that opened this target. Top-level targets return `None`.
292    pub fn opener_id(&self) -> Option<&TargetId> {
293        self.info.opener_id.as_ref()
294    }
295
296    pub fn frame_manager(&self) -> &FrameManager {
297        &self.frame_manager
298    }
299
300    /// The frame manager.
301    pub fn frame_manager_mut(&mut self) -> &mut FrameManager {
302        &mut self.frame_manager
303    }
304
305    /// Get event listeners mutably.
306    pub fn event_listeners_mut(&mut self) -> &mut EventListeners {
307        &mut self.event_listeners
308    }
309
310    /// Received a response to a command issued by this target
311    pub fn on_response(&mut self, resp: Response, method: &str) {
312        if let Some(cmds) = self.init_state.commands_mut() {
313            cmds.received_response(method);
314        }
315
316        if let GetFrameTreeParams::IDENTIFIER = method {
317            if let Some(resp) = resp
318                .result
319                .and_then(|val| GetFrameTreeParams::response_from_value(val).ok())
320            {
321                self.frame_manager.on_frame_tree(resp.frame_tree);
322            }
323        }
324        // requests originated from the network manager all return an empty response, hence they
325        // can be ignored here
326    }
327
328    /// On CDP Event message.
329    pub fn on_event(&mut self, event: CdpEventMessage) {
330        let CdpEventMessage {
331            params,
332            method,
333            session_id,
334            ..
335        } = event;
336
337        let is_session_scoped = matches!(
338            params,
339            CdpEvent::FetchRequestPaused(_)
340                | CdpEvent::FetchAuthRequired(_)
341                | CdpEvent::NetworkRequestWillBeSent(_)
342                | CdpEvent::NetworkResponseReceived(_)
343                | CdpEvent::NetworkLoadingFinished(_)
344                | CdpEvent::NetworkLoadingFailed(_)
345                | CdpEvent::PageFrameAttached(_)
346                | CdpEvent::PageFrameDetached(_)
347                | CdpEvent::PageFrameNavigated(_)
348                | CdpEvent::PageNavigatedWithinDocument(_)
349                | CdpEvent::PageLifecycleEvent(_)
350                | CdpEvent::PageFrameStartedLoading(_)
351                | CdpEvent::PageFrameStoppedLoading(_)
352                | CdpEvent::RuntimeExecutionContextCreated(_)
353                | CdpEvent::RuntimeExecutionContextDestroyed(_)
354                | CdpEvent::RuntimeExecutionContextsCleared(_)
355                | CdpEvent::RuntimeBindingCalled(_)
356        );
357
358        if is_session_scoped {
359            let ev_sid: &str = match session_id.as_deref() {
360                Some(s) => s,
361                None => return,
362            };
363
364            let self_sid: &str = match self.session_id.as_ref() {
365                Some(sid) => sid.as_ref(),
366                None => return,
367            };
368
369            if self_sid != ev_sid {
370                return;
371            }
372        }
373
374        match &params {
375            // `FrameManager` events
376            CdpEvent::PageFrameAttached(ev) => self
377                .frame_manager
378                .on_frame_attached(ev.frame_id.clone(), Some(ev.parent_frame_id.clone())),
379            CdpEvent::PageFrameDetached(ev) => self.frame_manager.on_frame_detached(ev),
380            CdpEvent::PageFrameNavigated(ev) => {
381                self.frame_manager.on_frame_navigated(&ev.frame);
382            }
383            CdpEvent::PageNavigatedWithinDocument(ev) => {
384                self.frame_manager.on_frame_navigated_within_document(ev)
385            }
386            CdpEvent::RuntimeExecutionContextCreated(ev) => {
387                self.frame_manager.on_frame_execution_context_created(ev)
388            }
389            CdpEvent::RuntimeExecutionContextDestroyed(ev) => {
390                self.frame_manager.on_frame_execution_context_destroyed(ev)
391            }
392            CdpEvent::RuntimeExecutionContextsCleared(_) => {
393                self.frame_manager.on_execution_contexts_cleared()
394            }
395            CdpEvent::RuntimeBindingCalled(ev) => {
396                // TODO check if binding registered and payload is json
397                self.frame_manager.on_runtime_binding_called(ev)
398            }
399            CdpEvent::PageLifecycleEvent(ev) => self.frame_manager.on_page_lifecycle_event(ev),
400            CdpEvent::PageFrameStartedLoading(ev) => {
401                self.frame_manager.on_frame_started_loading(ev);
402            }
403            CdpEvent::PageFrameStoppedLoading(ev) => {
404                self.frame_manager.on_frame_stopped_loading(ev);
405            }
406            // `Target` events
407            CdpEvent::TargetAttachedToTarget(ev) => {
408                if ev.waiting_for_debugger {
409                    let runtime_cmd = ATTACH_TARGET.clone();
410
411                    self.queued_events.push_back(TargetEvent::Request(Request {
412                        method: runtime_cmd.0,
413                        session_id: Some(ev.session_id.clone().into()),
414                        params: runtime_cmd.1,
415                    }));
416                }
417
418                // Forward emulation init commands (device metrics, touch) to worker-like targets.
419                let target_type = ev.target_info.r#type.as_str();
420                let is_worker_like =
421                    matches!(target_type, "worker" | "shared_worker" | "service_worker");
422
423                if is_worker_like {
424                    for (method, params) in &self.attached_emulation_init_cmds {
425                        self.queued_events.push_back(TargetEvent::Request(Request {
426                            method: method.clone(),
427                            session_id: Some(ev.session_id.clone().into()),
428                            params: params.clone(),
429                        }));
430                    }
431
432                    if let Some((method, params)) = &self.attached_user_agent_override {
433                        self.queued_events.push_back(TargetEvent::Request(Request {
434                            method: method.clone(),
435                            session_id: Some(ev.session_id.clone().into()),
436                            params: params.clone(),
437                        }));
438                    }
439                }
440            }
441            // `NetworkManager` events
442            CdpEvent::FetchRequestPaused(ev) => self.network_manager.on_fetch_request_paused(ev),
443            CdpEvent::FetchAuthRequired(ev) => self.network_manager.on_fetch_auth_required(ev),
444            CdpEvent::NetworkRequestWillBeSent(ev) => {
445                self.network_manager.on_request_will_be_sent(ev)
446            }
447            CdpEvent::NetworkRequestServedFromCache(ev) => {
448                self.network_manager.on_request_served_from_cache(ev)
449            }
450            CdpEvent::NetworkResponseReceived(ev) => self.network_manager.on_response_received(ev),
451            CdpEvent::NetworkLoadingFinished(ev) => {
452                self.network_manager.on_network_loading_finished(ev)
453            }
454            CdpEvent::NetworkLoadingFailed(ev) => {
455                self.network_manager.on_network_loading_failed(ev)
456            }
457            _ => (),
458        }
459        chromiumoxide_cdp::consume_event!(match params {
460           |ev| self.event_listeners.start_send(ev),
461           |json| { let _ = self.event_listeners.try_send_custom(&method, json);}
462        });
463    }
464
465    /// Called when a init command timed out
466    fn on_initialization_failed(&mut self) -> TargetEvent {
467        if let Some(initiator) = self.initiator.take() {
468            let _ = initiator.send(Err(CdpError::Timeout));
469        }
470        self.init_state = TargetInit::Closing;
471        let close_target = CloseTargetParams::new(self.info.target_id.clone());
472
473        TargetEvent::Request(Request {
474            method: close_target.identifier(),
475            session_id: self.session_id.clone().map(Into::into),
476            params: serde_json::to_value(close_target).unwrap_or_default(),
477        })
478    }
479
480    /// Advance that target's state
481    pub(crate) fn poll(&mut self, cx: &mut Context<'_>, now: Instant) -> Option<TargetEvent> {
482        if !self.is_page() {
483            // can only poll pages
484            return None;
485        }
486
487        match &mut self.init_state {
488            TargetInit::AttachToTarget => {
489                self.init_state = TargetInit::InitializingFrame(FrameManager::init_commands(
490                    self.config.request_timeout,
491                ));
492
493                if let Ok(params) = AttachToTargetParams::builder()
494                    .target_id(self.target_id().clone())
495                    .flatten(true)
496                    .build()
497                {
498                    return Some(TargetEvent::Request(Request::new(
499                        params.identifier(),
500                        serde_json::to_value(params).unwrap_or_default(),
501                    )));
502                } else {
503                    return None;
504                }
505            }
506            TargetInit::InitializingFrame(cmds) => {
507                self.session_id.as_ref()?;
508                if let Poll::Ready(poll) = cmds.poll(now) {
509                    return match poll {
510                        None => {
511                            if let Some(world_name) = self.frame_manager.get_isolated_world_name() {
512                                let world_name = world_name.clone();
513
514                                if let Some(isolated_world_cmds) =
515                                    self.frame_manager.ensure_isolated_world(&world_name)
516                                {
517                                    *cmds = isolated_world_cmds;
518                                } else {
519                                    self.init_state = TargetInit::InitializingNetwork(
520                                        self.network_manager.init_commands(),
521                                    );
522                                }
523                            } else {
524                                self.init_state = TargetInit::InitializingNetwork(
525                                    self.network_manager.init_commands(),
526                                );
527                            }
528                            self.poll(cx, now)
529                        }
530                        Some(Ok((method, params))) => Some(TargetEvent::Request(Request {
531                            method,
532                            session_id: self.session_id.clone().map(Into::into),
533                            params,
534                        })),
535                        Some(Err(_)) => Some(self.on_initialization_failed()),
536                    };
537                } else {
538                    return None;
539                }
540            }
541            TargetInit::InitializingNetwork(cmds) => {
542                advance_state!(
543                    self,
544                    cx,
545                    now,
546                    cmds,
547                    TargetInit::InitializingPage(Self::page_init_commands(
548                        self.config.request_timeout
549                    ))
550                );
551            }
552            TargetInit::InitializingPage(cmds) => {
553                advance_state!(
554                    self,
555                    cx,
556                    now,
557                    cmds,
558                    match self.config.viewport.as_ref() {
559                        Some(viewport) => TargetInit::InitializingEmulation(
560                            self.emulation_manager.init_commands(viewport)
561                        ),
562                        None => TargetInit::Initialized,
563                    }
564                );
565            }
566            TargetInit::InitializingEmulation(cmds) => {
567                if let Poll::Ready(poll) = cmds.poll(now) {
568                    return match poll {
569                        None => {
570                            self.init_state = TargetInit::Initialized;
571                            self.poll(cx, now)
572                        }
573                        Some(Ok((method, params))) => {
574                            if method.as_ref().starts_with("Emulation.") {
575                                self.attached_emulation_init_cmds
576                                    .push((method.clone(), params.clone()));
577                            }
578
579                            Some(TargetEvent::Request(Request {
580                                method,
581                                session_id: self.session_id.clone().map(Into::into),
582                                params,
583                            }))
584                        }
585                        Some(Err(_)) => Some(self.on_initialization_failed()),
586                    };
587                } else {
588                    return None;
589                }
590            }
591            TargetInit::Initialized => {
592                if let Some(initiator) = self.initiator.take() {
593                    // make sure that the main frame of the page has finished loading
594                    if self
595                        .frame_manager
596                        .main_frame()
597                        .map(|frame| frame.is_loaded())
598                        .unwrap_or_default()
599                    {
600                        if let Some(page) = self.get_or_create_page() {
601                            let _ = initiator.send(Ok(page.clone().into()));
602                        } else {
603                            self.initiator = Some(initiator);
604                        }
605                    } else {
606                        self.initiator = Some(initiator);
607                    }
608                }
609            }
610            TargetInit::Closing => return None,
611        };
612
613        loop {
614            if self.init_state == TargetInit::Closing {
615                break None;
616            }
617
618            if let Some(frame) = self.frame_manager.main_frame() {
619                if frame.is_loaded() {
620                    while let Some(tx) = self.wait_for_frame_navigation.pop() {
621                        let _ = tx.send(frame.http_request().cloned());
622                    }
623                }
624
625                if frame.is_network_idle() {
626                    while let Some(tx) = self.wait_for_network_idle.pop() {
627                        let _ = tx.send(frame.http_request().cloned());
628                    }
629                }
630
631                if frame.is_network_almost_idle() {
632                    while let Some(tx) = self.wait_for_network_almost_idle.pop() {
633                        let _ = tx.send(frame.http_request().cloned());
634                    }
635                }
636            }
637
638            // Drain queued messages first.
639            if let Some(ev) = self.queued_events.pop_front() {
640                return Some(ev);
641            }
642
643            if let Some(handle) = self.page.as_mut() {
644                while let Poll::Ready(Some(msg)) = Pin::new(&mut handle.rx).poll_next(cx) {
645                    if self.init_state == TargetInit::Closing {
646                        break;
647                    }
648
649                    match msg {
650                        TargetMessage::Command(cmd) => {
651                            if cmd.method == "Network.setBlockedURLs" {
652                                if let Some(arr) = cmd.params.get("urls").and_then(|v| v.as_array())
653                                {
654                                    let mut unblock_all = false;
655                                    let mut block_all = false;
656
657                                    for s in arr.iter().filter_map(|v| v.as_str()) {
658                                        if s == "!*" {
659                                            unblock_all = true;
660                                            break; // "!*" overrides any block rules
661                                        }
662                                        if s.contains('*') {
663                                            block_all = true;
664                                        }
665                                    }
666
667                                    if unblock_all {
668                                        self.network_manager.set_block_all(false);
669                                    } else if block_all {
670                                        self.network_manager.set_block_all(true);
671                                    }
672                                }
673                            }
674
675                            let method_str = cmd.method.as_ref();
676                            if method_str == "Network.setUserAgentOverride"
677                                || method_str == "Emulation.setUserAgentOverride"
678                            {
679                                self.attached_user_agent_override =
680                                    Some((cmd.method.clone(), cmd.params.clone()));
681                            }
682
683                            self.queued_events.push_back(TargetEvent::Command(cmd));
684                        }
685                        TargetMessage::MainFrame(tx) => {
686                            let _ =
687                                tx.send(self.frame_manager.main_frame().map(|f| f.id().clone()));
688                        }
689                        TargetMessage::AllFrames(tx) => {
690                            let _ = tx.send(
691                                self.frame_manager
692                                    .frames()
693                                    .map(|f| f.id().clone())
694                                    .collect(),
695                            );
696                        }
697                        #[cfg(feature = "_cache")]
698                        TargetMessage::CacheKey((cache_key, cache_policy)) => {
699                            self.network_manager.set_cache_site_key(cache_key);
700                            self.network_manager.set_cache_policy(cache_policy);
701                        }
702                        TargetMessage::Url(req) => {
703                            let GetUrl { frame_id, tx } = req;
704                            let frame = if let Some(frame_id) = frame_id {
705                                self.frame_manager.frame(&frame_id)
706                            } else {
707                                self.frame_manager.main_frame()
708                            };
709                            let _ = tx.send(frame.and_then(|f| f.url().map(str::to_string)));
710                        }
711                        TargetMessage::Name(req) => {
712                            let GetName { frame_id, tx } = req;
713                            let frame = if let Some(frame_id) = frame_id {
714                                self.frame_manager.frame(&frame_id)
715                            } else {
716                                self.frame_manager.main_frame()
717                            };
718                            let _ = tx.send(frame.and_then(|f| f.name().map(str::to_string)));
719                        }
720                        TargetMessage::Parent(req) => {
721                            let GetParent { frame_id, tx } = req;
722                            let frame = self.frame_manager.frame(&frame_id);
723                            let _ = tx.send(frame.and_then(|f| f.parent_id().cloned()));
724                        }
725                        TargetMessage::WaitForNavigation(tx) => {
726                            if let Some(frame) = self.frame_manager.main_frame() {
727                                // TODO submit a navigation watcher: waitForFrameNavigation
728
729                                // TODO return the watchers navigationResponse
730                                if frame.is_loaded() {
731                                    let _ = tx.send(frame.http_request().cloned());
732                                } else {
733                                    self.wait_for_frame_navigation.push(tx);
734                                }
735                            } else {
736                                self.wait_for_frame_navigation.push(tx);
737                            }
738                        }
739                        TargetMessage::WaitForNetworkIdle(tx) => {
740                            if let Some(frame) = self.frame_manager.main_frame() {
741                                if frame.is_network_idle() {
742                                    let _ = tx.send(frame.http_request().cloned());
743                                } else {
744                                    self.wait_for_network_idle.push(tx);
745                                }
746                            } else {
747                                self.wait_for_network_idle.push(tx);
748                            }
749                        }
750                        TargetMessage::WaitForNetworkAlmostIdle(tx) => {
751                            if let Some(frame) = self.frame_manager.main_frame() {
752                                if frame.is_network_almost_idle() {
753                                    let _ = tx.send(frame.http_request().cloned());
754                                } else {
755                                    self.wait_for_network_almost_idle.push(tx);
756                                }
757                            } else {
758                                self.wait_for_network_almost_idle.push(tx);
759                            }
760                        }
761                        TargetMessage::AddEventListener(req) => {
762                            if req.method == "Fetch.requestPaused" {
763                                self.network_manager.enable_request_intercept();
764                            }
765                            // register a new listener
766                            self.event_listeners.add_listener(req);
767                        }
768                        TargetMessage::GetExecutionContext(ctx) => {
769                            let GetExecutionContext {
770                                dom_world,
771                                frame_id,
772                                tx,
773                            } = ctx;
774                            let frame = if let Some(frame_id) = frame_id {
775                                self.frame_manager.frame(&frame_id)
776                            } else {
777                                self.frame_manager.main_frame()
778                            };
779
780                            if let Some(frame) = frame {
781                                match dom_world {
782                                    DOMWorldKind::Main => {
783                                        let _ = tx.send(frame.main_world().execution_context());
784                                    }
785                                    DOMWorldKind::Secondary => {
786                                        let _ =
787                                            tx.send(frame.secondary_world().execution_context());
788                                    }
789                                }
790                            } else {
791                                let _ = tx.send(None);
792                            }
793                        }
794                        TargetMessage::Authenticate(credentials) => {
795                            self.network_manager.authenticate(credentials);
796                        }
797                    }
798                }
799            }
800
801            while let Some(event) = self.network_manager.poll() {
802                if self.init_state == TargetInit::Closing {
803                    break;
804                }
805                match event {
806                    NetworkEvent::SendCdpRequest((method, params)) => {
807                        // send a message to the browser
808                        self.queued_events.push_back(TargetEvent::Request(Request {
809                            method,
810                            session_id: self.session_id.clone().map(Into::into),
811                            params,
812                        }))
813                    }
814                    NetworkEvent::Request(_) => {}
815                    NetworkEvent::Response(_) => {}
816                    NetworkEvent::RequestFailed(request) => {
817                        self.frame_manager.on_http_request_finished(request);
818                    }
819                    NetworkEvent::RequestFinished(request) => {
820                        self.frame_manager.on_http_request_finished(request);
821                    }
822                    NetworkEvent::BytesConsumed(n) => {
823                        self.queued_events.push_back(TargetEvent::BytesConsumed(n));
824                    }
825                }
826            }
827
828            while let Some(event) = self.frame_manager.poll(now) {
829                if self.init_state == TargetInit::Closing {
830                    break;
831                }
832                match event {
833                    FrameEvent::NavigationResult(res) => {
834                        self.queued_events
835                            .push_back(TargetEvent::NavigationResult(res));
836                    }
837                    FrameEvent::NavigationRequest(id, req) => {
838                        self.queued_events
839                            .push_back(TargetEvent::NavigationRequest(id, req));
840                    }
841                }
842            }
843
844            if self.queued_events.is_empty() {
845                return None;
846            }
847        }
848    }
849
850    /// Set the sender half of the channel who requested the creation of this
851    /// target
852    pub fn set_initiator(&mut self, tx: Sender<Result<Page>>) {
853        self.initiator = Some(tx);
854    }
855
856    pub(crate) fn page_init_commands(timeout: Duration) -> CommandChain {
857        CommandChain::new(INIT_COMMANDS_PARAMS.clone(), timeout)
858    }
859}
860
861/// Configuration for how a single target/page should be fetched and processed.
862#[derive(Debug, Clone)]
863pub struct TargetConfig {
864    pub ignore_https_errors: bool,
865    pub request_timeout: Duration,
866    pub viewport: Option<Viewport>,
867    pub request_intercept: bool,
868    pub cache_enabled: bool,
869    pub ignore_visuals: bool,
870    pub ignore_javascript: bool,
871    pub ignore_analytics: bool,
872    pub ignore_stylesheets: bool,
873    pub only_html: bool,
874    pub service_worker_enabled: bool,
875    pub extra_headers: Option<std::collections::HashMap<String, String>>,
876    pub intercept_manager: NetworkInterceptManager,
877    pub max_bytes_allowed: Option<u64>,
878    pub whitelist_patterns: Option<Vec<String>>,
879}
880
881impl Default for TargetConfig {
882    fn default() -> Self {
883        Self {
884            ignore_https_errors: true,
885            request_timeout: Duration::from_secs(REQUEST_TIMEOUT),
886            viewport: Default::default(),
887            request_intercept: false,
888            cache_enabled: true,
889            service_worker_enabled: true,
890            ignore_javascript: false,
891            ignore_visuals: false,
892            ignore_stylesheets: false,
893            ignore_analytics: true,
894            only_html: false,
895            extra_headers: Default::default(),
896            intercept_manager: NetworkInterceptManager::Unknown,
897            max_bytes_allowed: None,
898            whitelist_patterns: None,
899        }
900    }
901}
902
903#[derive(Debug, Clone, Eq, PartialEq)]
904pub enum TargetType {
905    Page,
906    BackgroundPage,
907    ServiceWorker,
908    SharedWorker,
909    Other,
910    Browser,
911    Webview,
912    Unknown(String),
913}
914
915impl TargetType {
916    pub fn new(ty: &str) -> Self {
917        match ty {
918            "page" => TargetType::Page,
919            "background_page" => TargetType::BackgroundPage,
920            "service_worker" => TargetType::ServiceWorker,
921            "shared_worker" => TargetType::SharedWorker,
922            "other" => TargetType::Other,
923            "browser" => TargetType::Browser,
924            "webview" => TargetType::Webview,
925            s => TargetType::Unknown(s.to_string()),
926        }
927    }
928
929    pub fn is_page(&self) -> bool {
930        matches!(self, TargetType::Page)
931    }
932
933    pub fn is_background_page(&self) -> bool {
934        matches!(self, TargetType::BackgroundPage)
935    }
936
937    pub fn is_service_worker(&self) -> bool {
938        matches!(self, TargetType::ServiceWorker)
939    }
940
941    pub fn is_shared_worker(&self) -> bool {
942        matches!(self, TargetType::SharedWorker)
943    }
944
945    pub fn is_other(&self) -> bool {
946        matches!(self, TargetType::Other)
947    }
948
949    pub fn is_browser(&self) -> bool {
950        matches!(self, TargetType::Browser)
951    }
952
953    pub fn is_webview(&self) -> bool {
954        matches!(self, TargetType::Webview)
955    }
956}
957
958#[derive(Debug)]
959pub(crate) enum TargetEvent {
960    /// An internal request
961    Request(Request),
962    /// An internal navigation request
963    NavigationRequest(NavigationId, Request),
964    /// Indicates that a previous requested navigation has finished
965    NavigationResult(Result<NavigationOk, NavigationError>),
966    /// A new command arrived via a channel
967    Command(CommandMessage),
968    /// The bytes consumed by the network.
969    BytesConsumed(u64),
970}
971
972// TODO this can be moved into the classes?
973#[derive(Debug, PartialEq)]
974pub enum TargetInit {
975    InitializingFrame(CommandChain),
976    InitializingNetwork(CommandChain),
977    InitializingPage(CommandChain),
978    InitializingEmulation(CommandChain),
979    AttachToTarget,
980    Initialized,
981    Closing,
982}
983
984impl TargetInit {
985    fn commands_mut(&mut self) -> Option<&mut CommandChain> {
986        match self {
987            TargetInit::InitializingFrame(cmd) => Some(cmd),
988            TargetInit::InitializingNetwork(cmd) => Some(cmd),
989            TargetInit::InitializingPage(cmd) => Some(cmd),
990            TargetInit::InitializingEmulation(cmd) => Some(cmd),
991            TargetInit::AttachToTarget => None,
992            TargetInit::Initialized => None,
993            TargetInit::Closing => None,
994        }
995    }
996}
997
998#[derive(Debug)]
999pub struct GetExecutionContext {
1000    /// For which world the execution context was requested
1001    pub dom_world: DOMWorldKind,
1002    /// The id of the frame to get the `ExecutionContext` for
1003    pub frame_id: Option<FrameId>,
1004    /// Sender half of the channel to send the response back
1005    pub tx: Sender<Option<ExecutionContextId>>,
1006}
1007
1008impl GetExecutionContext {
1009    pub fn new(tx: Sender<Option<ExecutionContextId>>) -> Self {
1010        Self {
1011            dom_world: DOMWorldKind::Main,
1012            frame_id: None,
1013            tx,
1014        }
1015    }
1016}
1017
1018#[derive(Debug)]
1019pub struct GetUrl {
1020    /// The id of the frame to get the url for (None = main frame)
1021    pub frame_id: Option<FrameId>,
1022    /// Sender half of the channel to send the response back
1023    pub tx: Sender<Option<String>>,
1024}
1025
1026impl GetUrl {
1027    pub fn new(tx: Sender<Option<String>>) -> Self {
1028        Self { frame_id: None, tx }
1029    }
1030}
1031
1032#[derive(Debug)]
1033pub struct GetName {
1034    /// The id of the frame to get the name for (None = main frame)
1035    pub frame_id: Option<FrameId>,
1036    /// Sender half of the channel to send the response back
1037    pub tx: Sender<Option<String>>,
1038}
1039
1040#[derive(Debug)]
1041pub struct GetParent {
1042    /// The id of the frame to get the parent for (None = main frame)
1043    pub frame_id: FrameId,
1044    /// Sender half of the channel to send the response back
1045    pub tx: Sender<Option<FrameId>>,
1046}
1047
1048#[derive(Debug)]
1049pub enum TargetMessage {
1050    /// Execute a command within the session of this target
1051    Command(CommandMessage),
1052    /// Return the main frame of this target's page
1053    MainFrame(Sender<Option<FrameId>>),
1054    /// Return all the frames of this target's page
1055    AllFrames(Sender<Vec<FrameId>>),
1056    #[cfg(feature = "_cache")]
1057    /// Set the cache key and policy for the target page.
1058    CacheKey((Option<String>, Option<crate::cache::BasicCachePolicy>)),
1059    /// Return the url if available
1060    Url(GetUrl),
1061    /// Return the name if available
1062    Name(GetName),
1063    /// Return the parent id of a frame
1064    Parent(GetParent),
1065    /// A Message that resolves when the frame finished loading a new url
1066    WaitForNavigation(Sender<ArcHttpRequest>),
1067    /// A Message that resolves when the frame network is idle
1068    WaitForNetworkIdle(Sender<ArcHttpRequest>),
1069    /// A Message that resolves when the frame network is almost idle
1070    WaitForNetworkAlmostIdle(Sender<ArcHttpRequest>),
1071    /// A request to submit a new listener that gets notified with every
1072    /// received event
1073    AddEventListener(EventListenerRequest),
1074    /// Get the `ExecutionContext` if available
1075    GetExecutionContext(GetExecutionContext),
1076    Authenticate(Credentials),
1077}
chromiumoxide/handler/target.rs

chromiumoxide/handler/
target.rs
