230 lines
8.0 KiB
Python
230 lines
8.0 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
@Author : g1879
|
|
@Contact : g1879@qq.com
|
|
@Website : https://DrissionPage.cn
|
|
@Copyright: (c) 2020 by g1879, Inc. All Rights Reserved.
|
|
"""
|
|
from json import dumps, loads, JSONDecodeError
|
|
from queue import Queue, Empty
|
|
from threading import Thread
|
|
from time import perf_counter, sleep
|
|
|
|
from requests import Session
|
|
from requests import adapters
|
|
from websocket import (WebSocketTimeoutException, WebSocketConnectionClosedException, create_connection,
|
|
WebSocketException, WebSocketBadStatusException)
|
|
|
|
from .._functions.settings import Settings as _S
|
|
from ..errors import PageDisconnectedError, BrowserConnectError
|
|
|
|
adapters.DEFAULT_RETRIES = 5
|
|
|
|
|
|
class Driver(object):
|
|
def __init__(self, _id, address, owner=None):
|
|
self.id = _id
|
|
self.address = address
|
|
self.owner = owner
|
|
self.alert_flag = False # 标记alert出现,跳过一条请求后复原
|
|
|
|
self._cur_id = 0
|
|
self._ws = None
|
|
|
|
self._recv_th = Thread(target=self._recv_loop)
|
|
self._handle_event_th = Thread(target=self._handle_event_loop)
|
|
self._recv_th.daemon = True
|
|
self._handle_event_th.daemon = True
|
|
self._handle_immediate_event_th = None
|
|
|
|
self.is_running = False
|
|
self.session_id = None
|
|
|
|
self.event_handlers = {}
|
|
self.immediate_event_handlers = {}
|
|
self.method_results = {}
|
|
self.event_queue = Queue()
|
|
self.immediate_event_queue = Queue()
|
|
|
|
self.start()
|
|
|
|
def _send(self, message, timeout=None):
|
|
self._cur_id += 1
|
|
ws_id = self._cur_id
|
|
message['id'] = ws_id
|
|
message_json = dumps(message)
|
|
|
|
end_time = perf_counter() + timeout if timeout is not None else None
|
|
self.method_results[ws_id] = Queue()
|
|
try:
|
|
self._ws.send(message_json)
|
|
if timeout == 0:
|
|
self.method_results.pop(ws_id, None)
|
|
return {'id': ws_id, 'result': {}}
|
|
|
|
except (OSError, WebSocketConnectionClosedException):
|
|
self.method_results.pop(ws_id, None)
|
|
return {'error': {'message': 'connection disconnected'}, 'type': 'connection_error'}
|
|
|
|
while self.is_running:
|
|
try:
|
|
result = self.method_results[ws_id].get(timeout=.2)
|
|
self.method_results.pop(ws_id, None)
|
|
return result
|
|
|
|
except Empty:
|
|
if self.alert_flag and message['method'].startswith(('Input.', 'Runtime.')):
|
|
return {'error': {'message': 'alert exists.'}, 'type': 'alert_exists'}
|
|
|
|
if timeout is not None and perf_counter() > end_time:
|
|
self.method_results.pop(ws_id, None)
|
|
return {'error': {'message': 'alert exists.'}, 'type': 'alert_exists'} \
|
|
if self.alert_flag else {'error': {'message': 'timeout'}, 'type': 'timeout'}
|
|
|
|
continue
|
|
|
|
return {'error': {'message': 'connection disconnected'}, 'type': 'connection_error'}
|
|
|
|
def _recv_loop(self):
|
|
while self.is_running:
|
|
try:
|
|
# self._ws.settimeout(1)
|
|
msg_json = self._ws.recv()
|
|
msg = loads(msg_json)
|
|
except WebSocketTimeoutException:
|
|
continue
|
|
except (WebSocketException, OSError, WebSocketConnectionClosedException, JSONDecodeError):
|
|
self._stop()
|
|
return
|
|
|
|
if 'method' in msg:
|
|
if msg['method'].startswith('Page.javascriptDialog'):
|
|
self.alert_flag = msg['method'].endswith('Opening')
|
|
function = self.immediate_event_handlers.get(msg['method'])
|
|
if function:
|
|
self._handle_immediate_event(function, msg['params'])
|
|
else:
|
|
self.event_queue.put(msg)
|
|
|
|
elif msg.get('id') in self.method_results:
|
|
self.method_results[msg['id']].put(msg)
|
|
|
|
def _handle_event_loop(self):
|
|
while self.is_running:
|
|
try:
|
|
event = self.event_queue.get(timeout=1)
|
|
except Empty:
|
|
continue
|
|
|
|
function = self.event_handlers.get(event['method'])
|
|
if function:
|
|
function(**event['params'])
|
|
|
|
self.event_queue.task_done()
|
|
|
|
def _handle_immediate_event_loop(self):
|
|
while not self.immediate_event_queue.empty():
|
|
function, kwargs = self.immediate_event_queue.get(timeout=1)
|
|
try:
|
|
function(**kwargs)
|
|
except PageDisconnectedError:
|
|
pass
|
|
|
|
def _handle_immediate_event(self, function, kwargs):
|
|
self.immediate_event_queue.put((function, kwargs))
|
|
if self._handle_immediate_event_th is None or not self._handle_immediate_event_th.is_alive():
|
|
self._handle_immediate_event_th = Thread(target=self._handle_immediate_event_loop)
|
|
self._handle_immediate_event_th.daemon = True
|
|
self._handle_immediate_event_th.start()
|
|
|
|
def run(self, _method, sessionId=None, **kwargs):
|
|
if not self.is_running:
|
|
return {'error': 'connection disconnected', 'type': 'connection_error'}
|
|
|
|
timeout = kwargs.pop('_timeout', _S.cdp_timeout)
|
|
if self.session_id:
|
|
result = self._send({'method': _method, 'params': kwargs, 'sessionId': self.session_id}, timeout=timeout)
|
|
elif sessionId:
|
|
result = self._send({'method': _method, 'params': kwargs, 'sessionId': sessionId}, timeout=timeout)
|
|
else:
|
|
result = self._send({'method': _method, 'params': kwargs}, timeout=timeout)
|
|
if 'result' not in result and 'error' in result:
|
|
kwargs['_timeout'] = timeout
|
|
return {'error': result['error']['message'], 'type': result.get('type', 'call_method_error'),
|
|
'method': _method, 'args': kwargs, 'data': result['error'].get('data')}
|
|
else:
|
|
return result['result']
|
|
|
|
def start(self):
|
|
self.is_running = True
|
|
try:
|
|
self._ws = create_connection(self.address, enable_multithread=True, suppress_origin=True)
|
|
except WebSocketBadStatusException as e:
|
|
if 'Handshake status 403 Forbidden' in str(e):
|
|
raise EnvironmentError(_S._lang.join(_S._lang.UPGRADE_WS))
|
|
else:
|
|
raise
|
|
except ConnectionRefusedError:
|
|
raise BrowserConnectError(_S._lang.BROWSER_NOT_EXIST)
|
|
self._recv_th.start()
|
|
self._handle_event_th.start()
|
|
return True
|
|
|
|
def stop(self):
|
|
self._stop()
|
|
while self._handle_event_th.is_alive() or self._recv_th.is_alive():
|
|
sleep(.01)
|
|
return True
|
|
|
|
def _stop(self):
|
|
if not self.is_running:
|
|
return False
|
|
|
|
self.is_running = False
|
|
if self._ws:
|
|
self._ws.close()
|
|
self._ws = None
|
|
|
|
self.event_handlers.clear()
|
|
self.method_results.clear()
|
|
self.event_queue.queue.clear()
|
|
|
|
if hasattr(self.owner, '_on_disconnect'):
|
|
self.owner._on_disconnect()
|
|
|
|
def set_callback(self, event, callback, immediate=False):
|
|
handler = self.immediate_event_handlers if immediate else self.event_handlers
|
|
if callback:
|
|
handler[event] = callback
|
|
else:
|
|
handler.pop(event, None)
|
|
|
|
|
|
class BrowserDriver(Driver):
|
|
BROWSERS = {}
|
|
|
|
def __new__(cls, _id, address, owner):
|
|
if _id in cls.BROWSERS:
|
|
return cls.BROWSERS[_id]
|
|
return object.__new__(cls)
|
|
|
|
def __init__(self, _id, address, owner):
|
|
if hasattr(self, '_created'):
|
|
return
|
|
self._created = True
|
|
BrowserDriver.BROWSERS[_id] = self
|
|
super().__init__(_id, address, owner)
|
|
|
|
def __repr__(self):
|
|
return f'<BrowserDriver {self.id}>'
|
|
|
|
@staticmethod
|
|
def get(url):
|
|
s = Session()
|
|
s.trust_env = False
|
|
s.keep_alive = False
|
|
r = s.get(url, headers={'Connection': 'close'})
|
|
r.close()
|
|
s.close()
|
|
return r
|