Debian Codegraph @

tests/android/webview/http.py

raw
1 from __future__ import annotations
2
3 import os
4 import sys
5 from typing import TypeVar, cast
6
7 if sys.platform == 'win32' and ('pythonw.exe' in sys.executable or getattr(sys, 'frozen', False)):
8 # bottle.py versions prior to 0.12.23 (the latest on PyPi as of Feb 2023) require stdout and
9 # stderr to exist, which is not the case on Windows with pythonw.exe or PyInstaller >= 5.8.0
10 if sys.stderr is None: # type: ignore
11 sys.stderr = open(os.devnull, 'w')
12 if sys.stdout is None: # type: ignore
13 sys.stdout = open(os.devnull, 'w')
14
15
16 import json
17 import logging
18 import random
19 import socket
20 import ssl
21 import threading
22 import uuid
23 from socketserver import ThreadingMixIn
24 from typing import TYPE_CHECKING
25 from wsgiref.simple_server import WSGIRequestHandler, WSGIServer, make_server
26
27 if TYPE_CHECKING:
28 from wsgiref.types import WSGIApplication
29
30 import bottle
31 from typing_extensions import TypedDict, Unpack
32
33 from .util import abspath, is_app, is_local_url
34
35 WRHT_co = TypeVar('WRHT_co', bound=WSGIRequestHandler, covariant=True)
36 WST_co = TypeVar('WST_co', bound=WSGIServer, covariant=True)
37
38 logger = logging.getLogger('pywebview')
39 global_server = None
40
41
42 def _get_random_port() -> int:
43 while True:
44 port = random.randint(1023, 65535)
45
46 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
47 try:
48 sock.bind(('localhost', port))
49 except OSError:
50 logger.warning(f'Port {port} is in use')
51 continue
52 else:
53 return port
54
55
56 class ThreadedAdapter(bottle.ServerAdapter):
57 def run(self, handler: WSGIApplication) -> None:
58 if self.quiet:
59
60 class QuietHandler(WSGIRequestHandler):
61 def log_request(*args, **_):
62 pass
63
64 self.options['handler_class'] = QuietHandler
65
66 class ThreadAdapter(ThreadingMixIn, WSGIServer):
67 pass
68
69 server = make_server(
70 self.host, self.port, handler, server_class=ThreadAdapter, **self.options
71 )
72 server.serve_forever()
73
74
75 class BottleServer:
76 def __init__(self) -> None:
77 self.root_path = '/'
78 self.running = False
79 self.address = None
80 self.js_callback = {}
81 self.js_api_endpoint = None
82 self.uid = str(uuid.uuid1())
83
84 @classmethod
85 def start_server(
86 cls, urls: list[str], http_port: int | None, keyfile: None = None, certfile: None = None
87 ) -> tuple[str, str | None, BottleServer]:
88 from webview import _state
89
90 apps = [u for u in urls if is_app(u)]
91 server = cls()
92
93 if len(apps) > 0:
94 app = apps[0]
95 common_path = '.'
96 else:
97 local_urls = [u.split('#')[0] for u in urls if is_local_url(u)]
98 common_path = os.path.commonpath(local_urls) if len(local_urls) > 0 else None
99 if common_path is not None and not os.path.isdir(abspath(common_path)):
100 common_path = os.path.dirname(common_path)
101 logger.debug(f'Common path for local URLs: {common_path}')
102 server.root_path = abspath(common_path) if common_path is not None else None
103 logger.debug(f'HTTP server root path: {server.root_path}')
104 app = bottle.Bottle()
105
106 @app.post(f'/js_api/{server.uid}')
107 def js_api():
108 bottle.response.headers['Access-Control-Allow-Origin'] = '*'
109 bottle.response.headers['Access-Control-Allow-Methods'] = (
110 'PUT, GET, POST, DELETE, OPTIONS'
111 )
112 bottle.response.headers['Access-Control-Allow-Headers'] = (
113 'Origin, Accept, Content-Type, X-Requested-With, X-CSRF-Token'
114 )
115
116 body = json.loads(bottle.request.body.read().decode('utf-8'))
117 if body['uid'] in server.js_callback:
118 return json.dumps(server.js_callback[body['uid']](body))
119 else:
120 logger.error(f'JS callback function is not set for window {body["uid"]}')
121
122 @app.route('/')
123 @app.route('/<file:path>')
124 def asset(file):
125 if not server.root_path:
126 return ''
127 bottle.response.set_header('Cache-Control', 'no-cache, no-store, must-revalidate')
128 bottle.response.set_header('Pragma', 'no-cache')
129 bottle.response.set_header('Expires', 0)
130 return bottle.static_file(file, root=server.root_path)
131
132 server.root_path = abspath(common_path) if common_path is not None else None
133 server.port = http_port or _get_random_port()
134 if keyfile and certfile:
135 server_adapter = SSLWSGIRefServer()
136 server_adapter.port = server.port
137 setattr(server_adapter, 'pywebview_keyfile', keyfile)
138 setattr(server_adapter, 'pywebview_certfile', certfile)
139 else:
140 server_adapter = ThreadedAdapter
141 server.thread = threading.Thread(
142 target=lambda: bottle.run(
143 app=app, server=server_adapter, port=server.port, quiet=not _state['debug']
144 ),
145 daemon=True,
146 )
147 server.thread.start()
148
149 server.running = True
150 protocol = 'https' if keyfile and certfile else 'http'
151 server.address = f'{protocol}://127.0.0.1:{server.port}/'
152 cls.common_path = common_path
153 server.js_api_endpoint = f'{server.address}js_api/{server.uid}'
154
155 return server.address, common_path, server
156
157 @property
158 def is_running(self) -> bool:
159 return self.running
160
161
162 ServerType = TypeVar('ServerType', bound=BottleServer, covariant=True)
163
164
165 class SSLWSGIRefServer(bottle.ServerAdapter):
166 def run(self, handler: WSGIApplication) -> None: # pragma: no cover
167 import socket
168 from wsgiref.simple_server import WSGIRequestHandler, WSGIServer, make_server
169
170 class FixedHandler(WSGIRequestHandler):
171 def address_string(self) -> str: # Prevent reverse DNS lookups please.
172 return self.client_address[0]
173
174 def log_request(*args, **kw) -> None:
175 if not self.quiet:
176 return WSGIRequestHandler.log_request(*args, **kw)
177
178 handler_cls = cast(WRHT_co, self.options.get('handler_class', FixedHandler))
179 server_cls = cast(WST_co, self.options.get('server_class', WSGIServer))
180
181 if ':' in self.host: # Fix wsgiref for IPv6 addresses.
182 if server_cls.address_family == socket.AF_INET:
183
184 class server_cls(server_cls):
185 address_family = socket.AF_INET6
186
187 ssl_context = ssl.SSLContext()
188 ssl_context.load_cert_chain(self.pywebview_certfile, self.pywebview_keyfile)
189 self.srv = make_server(self.host, self.port, handler, server_cls, handler_cls)
190 self.srv.socket = ssl_context.wrap_socket(self.srv.socket, server_side=True)
191 self.port = self.srv.server_port # update port actual port (0 means random)
192
193 if os.path.exists(self.pywebview_keyfile):
194 os.unlink(self.pywebview_keyfile)
195 try:
196 self.srv.serve_forever()
197 except KeyboardInterrupt:
198 self.srv.server_close() # Prevent ResourceWarning: unclosed socket
199 raise
200
201
202 class ServerArgs(TypedDict, total=False):
203 keyfile: None
204 certfile: None
205
206
207 def start_server(
208 urls: list[str],
209 http_port: int | None = None,
210 server: type[ServerType] = BottleServer,
211 **server_args: Unpack[ServerArgs],
212 ) -> tuple[str, str | None, BottleServer]:
213 server = server if server is not None else BottleServer
214 return server.start_server(urls, http_port, **server_args)
215
216
217 def start_global_server(
218 http_port: int | None = None,
219 urls: list[str] = ['.'],
220 server: type[ServerType] = BottleServer,
221 **server_args: Unpack[ServerArgs],
222 ) -> tuple[str, str | None, BottleServer]:
223 global global_server
224 address, common_path, global_server = start_server(
225 urls=urls, http_port=http_port, server=server, **server_args
226 )
227 return address, common_path, global_server