Coverage for adhoc-cicd-odoo-odoo / odoo / service / server.py: 20%

1#----------------------------------------------------------- 

2# Threaded, Gevent and Prefork Servers 

3#----------------------------------------------------------- 

4import contextlib 

5import collections 

6import datetime 

7import errno 

8import logging 

9import os 

10import os.path 

11import platform 

12import random 

13import select 

14import signal 

15import socket 

16import subprocess 

17import sys 

18import threading 

19import time 

20from collections import deque 

21from io import BytesIO 

22 

23import psutil 

24import werkzeug.serving 

25from werkzeug .urls import uri_to_iri 

26 

27if os.name == 'posix': 27 ↛ 40line 27 didn't jump to line 40 because the condition on line 27 was always true

28 # Unix only for workers 

29 import fcntl 

30 import resource 

31 try: 

32 import inotify 

33 from inotify.adapters import InotifyTrees 

34 from inotify.constants import IN_MODIFY, IN_CREATE, IN_MOVED_TO 

35 INOTIFY_LISTEN_EVENTS = IN_MODIFY | IN_CREATE | IN_MOVED_TO 

36 except ImportError: 

37 inotify = None 

38else: 

39 # Windows shim 

40 signal.SIGHUP = -1 

41 inotify = None 

42 

43if not inotify: 43 ↛ 52line 43 didn't jump to line 52 because the condition on line 43 was always true

44 try: 

45 import watchdog 

46 from watchdog.observers import Observer 

47 from watchdog.events import FileCreatedEvent, FileModifiedEvent, FileMovedEvent 

48 except ImportError: 

49 watchdog = None 

50 

51# Optional process names for workers 

52try: 

53 from setproctitle import setproctitle 

54except ImportError: 

55 setproctitle = lambda x: None 

56 

57from odoo import api, sql_db 

58from odoo.modules.registry import Registry 

59from odoo.release import nt_service_name 

60from odoo.tools import config, gc, osutil, OrderedSet, profiler 

61from odoo.tools.cache import log_ormcache_stats 

62from odoo.tools.misc import stripped_sys_argv, dumpstacks 

63from .db import list_dbs 

64 

65_logger = logging.getLogger(__name__) 

66 

67SLEEP_INTERVAL = 60 # 1 min 

68 

69 

70# A global-ish object, each thread/worker uses its own 

71thread_local = threading.local() 

72 

73# the model and method name that was called via rpc, for logging 

74thread_local.rpc_model_method = '' 

75 

76 

77def memory_info(process): 

78 """ 

79 :return: the relevant memory usage according to the OS in bytes. 

80 """ 

81 # psutil < 2.0 does not have memory_info, >= 3.0 does not have get_memory_info 

82 pmem = (getattr(process, 'memory_info', None) or process.get_memory_info)() 

83 # MacOSX allocates very large vms to all processes so we only monitor the rss usage. 

84 if platform.system() == 'Darwin': 

85 return pmem.rss 

86 return pmem.vms 

87 

88 

89def set_limit_memory_hard(): 

90 if platform.system() != 'Linux': 90 ↛ 91line 90 didn't jump to line 91 because the condition on line 90 was never true

91 return 

92 limit_memory_hard = config['limit_memory_hard'] 

93 import odoo # for eventd 

94 if odoo.evented and config['limit_memory_hard_gevent']: 94 ↛ 95line 94 didn't jump to line 95 because the condition on line 94 was never true

95 limit_memory_hard = config['limit_memory_hard_gevent'] 

96 if limit_memory_hard: 96 ↛ exitline 96 didn't return from function 'set_limit_memory_hard' because the condition on line 96 was always true

97 rlimit = resource.RLIMIT_AS 

98 soft, hard = resource.getrlimit(rlimit) 

99 resource.setrlimit(rlimit, (limit_memory_hard, hard)) 

100 

101def empty_pipe(fd): 

102 try: 

103 while os.read(fd, 1): 

104 pass 

105 except OSError as e: 

106 if e.errno not in [errno.EAGAIN]: 

107 raise 

108 

109 

110def cron_database_list(): 

111 return config['db_name'] or list_dbs(True) 

112 

113 

114#---------------------------------------------------------- 

115# Werkzeug WSGI servers patched 

116#---------------------------------------------------------- 

117class LoggingBaseWSGIServerMixIn(object): 

118 def handle_error(self, request, client_address): 

119 t, e, _ = sys.exc_info() 

120 if t == socket.error and e.errno == errno.EPIPE: 

121 # broken pipe, ignore error 

122 return 

123 _logger.exception('Exception happened during processing of request from %s', client_address) 

124 

125class BaseWSGIServerNoBind(LoggingBaseWSGIServerMixIn, werkzeug.serving.BaseWSGIServer): 

126 """ werkzeug Base WSGI Server patched to skip socket binding. PreforkServer 

127 use this class, sets the socket and calls the process_request() manually 

128 """ 

129 def __init__(self, app): 

130 werkzeug.serving.BaseWSGIServer.__init__(self, "127.0.0.1", 0, app, handler=CommonRequestHandler) 

131 # Directly close the socket. It will be replaced by WorkerHTTP when processing requests 

132 if self.socket: 

133 self.socket.close() 

134 

135 def server_activate(self): 

136 # dont listen as we use PreforkServer#socket 

137 pass 

138 

139class CommonRequestHandler(werkzeug.serving.WSGIRequestHandler): 

140 def log_request(self, code = "-", size = "-"): 

141 try: 

142 path = uri_to_iri(self.path) 

143 fragment = thread_local.rpc_model_method 

144 if fragment: 

145 path += '#' + fragment 

146 msg = f"{self.command} {path} {self.request_version}" 

147 except AttributeError: 

148 # path isn't set if the requestline was bad 

149 msg = self.requestline 

150 

151 code = str(code) 

152 

153 if code[0] == "1": # 1xx - Informational 

154 msg = werkzeug.serving._ansi_style(msg, "bold") 

155 elif code == "200": # 2xx - Success 

156 pass 

157 elif code == "304": # 304 - Resource Not Modified 

158 msg = werkzeug.serving._ansi_style(msg, "cyan") 

159 elif code[0] == "3": # 3xx - Redirection 

160 msg = werkzeug.serving._ansi_style(msg, "green") 

161 elif code == "404": # 404 - Resource Not Found 

162 msg = werkzeug.serving._ansi_style(msg, "yellow") 

163 elif code[0] == "4": # 4xx - Client Error 

164 msg = werkzeug.serving._ansi_style(msg, "bold", "red") 

165 else: # 5xx, or any other response 

166 msg = werkzeug.serving._ansi_style(msg, "bold", "magenta") 

167 

168 self.log("info", '"%s" %s %s', msg, code, size) 

169 

170 

171class RequestHandler(CommonRequestHandler): 

172 def setup(self): 

173 # timeout to avoid chrome headless preconnect during tests 

174 if config['test_enable']: 

175 self.timeout = 5 

176 # flag the current thread as handling a http request 

177 super(RequestHandler, self).setup() 

178 me = threading.current_thread() 

179 me.name = 'odoo.service.http.request.%s' % (me.ident,) 

180 

181 def make_environ(self): 

182 environ = super().make_environ() 

183 # Add the TCP socket to environ in order for the websocket 

184 # connections to use it. 

185 environ['socket'] = self.connection 

186 if self.headers.get('Upgrade') == 'websocket': 

187 # Since the upgrade header is introduced in version 1.1, Firefox 

188 # won't accept a websocket connection if the version is set to 

189 # 1.0. 

190 self.protocol_version = "HTTP/1.1" 

191 return environ 

192 

193 def send_header(self, keyword, value): 

194 # Prevent `WSGIRequestHandler` from sending the connection close header (compatibility with werkzeug >= 2.1.1 ) 

195 # since it is incompatible with websocket. 

196 if self.headers.get('Upgrade') == 'websocket' and keyword == 'Connection' and value == 'close': 

197 # Do not keep processing requests. 

198 self.close_connection = True 

199 return 

200 super().send_header(keyword, value) 

201 

202 def end_headers(self, *a, **kw): 

203 super().end_headers(*a, **kw) 

204 # At this point, Werkzeug assumes the connection is closed and will discard any incoming 

205 # data. In the case of WebSocket connections, data should not be discarded. Replace the 

206 # rfile/wfile of this handler to prevent any further action (compatibility with werkzeug >= 2.3.x). 

207 # See: https://github.com/pallets/werkzeug/blob/2.3.x/src/werkzeug/serving.py#L334 

208 if self.headers.get('Upgrade') == 'websocket': 

209 self.rfile = BytesIO() 

210 self.wfile = BytesIO() 

211 

212 def log_error(self, format, *args): 

213 if format == "Request timed out: %r" and config['test_enable']: 

214 _logger.info(format, *args) 

215 else: 

216 super().log_error(format, *args) 

217 

218class ThreadedWSGIServerReloadable(LoggingBaseWSGIServerMixIn, werkzeug.serving.ThreadedWSGIServer): 

219 """ werkzeug Threaded WSGI Server patched to allow reusing a listen socket 

220 given by the environment, this is used by autoreload to keep the listen 

221 socket open when a reload happens. 

222 """ 

223 def __init__(self, host, port, app): 

224 # The ODOO_MAX_HTTP_THREADS environment variable allows to limit the amount of concurrent 

225 # socket connections accepted by a threaded server, implicitly limiting the amount of 

226 # concurrent threads running for http requests handling. 

227 self.max_http_threads = os.environ.get("ODOO_MAX_HTTP_THREADS") 

228 if self.max_http_threads: 

229 try: 

230 self.max_http_threads = int(self.max_http_threads) 

231 except ValueError: 

232 # If the value can't be parsed to an integer then it's computed in an automated way to 

233 # half the size of db_maxconn because while most requests won't borrow cursors concurrently 

234 # there are some exceptions where some controllers might allocate two or more cursors. 

235 self.max_http_threads = max((config['db_maxconn'] - config['max_cron_threads']) // 2, 1) 

236 self.http_threads_sem = threading.Semaphore(self.max_http_threads) 

237 super(ThreadedWSGIServerReloadable, self).__init__(host, port, app, 

238 handler=RequestHandler) 

239 

240 # See https://github.com/pallets/werkzeug/pull/770 

241 # This allow the request threads to not be set as daemon 

242 # so the server waits for them when shutting down gracefully. 

243 self.daemon_threads = False 

244 

245 def server_bind(self): 

246 SD_LISTEN_FDS_START = 3 

247 if os.environ.get('LISTEN_FDS') == '1' and os.environ.get('LISTEN_PID') == str(os.getpid()): 

248 self.reload_socket = True 

249 self.socket = socket.fromfd(SD_LISTEN_FDS_START, socket.AF_INET, socket.SOCK_STREAM) 

250 _logger.info('HTTP service (werkzeug) running through socket activation') 

251 else: 

252 self.reload_socket = False 

253 super(ThreadedWSGIServerReloadable, self).server_bind() 

254 _logger.info('HTTP service (werkzeug) running on %s:%s', self.server_name, self.server_port) 

255 

256 def server_activate(self): 

257 if not self.reload_socket: 

258 super(ThreadedWSGIServerReloadable, self).server_activate() 

259 

260 def process_request(self, request, client_address): 

261 """ 

262 Start a new thread to process the request. 

263 Override the default method of class socketserver.ThreadingMixIn 

264 to be able to get the thread object which is instantiated 

265 and set its start time as an attribute 

266 """ 

267 t = threading.Thread(target = self.process_request_thread, 

268 args = (request, client_address)) 

269 t.daemon = self.daemon_threads 

270 t.type = 'http' 

271 t.start_time = time.time() 

272 t.start() 

273 

274 def _handle_request_noblock(self): 

275 if self.max_http_threads and not self.http_threads_sem.acquire(timeout=0.1): 

276 # If the semaphore is full we will return immediately to the upstream (most probably 

277 # socketserver.BaseServer's serve_forever loop which will retry immediately as the 

278 # selector will find a pending connection to accept on the socket. There is a 100 ms 

279 # penalty in such case in order to avoid cpu bound loop while waiting for the semaphore. 

280 return 

281 # upstream _handle_request_noblock will handle errors and call shutdown_request in any cases 

282 super(ThreadedWSGIServerReloadable, self)._handle_request_noblock() 

283 

284 def shutdown_request(self, request): 

285 if self.max_http_threads: 

286 # upstream is supposed to call this function no matter what happens during processing 

287 self.http_threads_sem.release() 

288 super().shutdown_request(request) 

289 

290#---------------------------------------------------------- 

291# FileSystem Watcher for autoreload and cache invalidation 

292#---------------------------------------------------------- 

293class FSWatcherBase(object): 

294 def handle_file(self, path): 

295 if path.endswith('.py') and not os.path.basename(path).startswith('.~'): 

296 try: 

297 source = open(path, 'rb').read() + b'\n' 

298 compile(source, path, 'exec') 

299 except IOError: 

300 _logger.error('autoreload: python code change detected, IOError for %s', path) 

301 except SyntaxError: 

302 _logger.error('autoreload: python code change detected, SyntaxError in %s', path) 

303 else: 

304 if not server_phoenix: 

305 _logger.info('autoreload: python code updated, autoreload activated') 

306 restart() 

307 return True 

308 

309 

310class FSWatcherWatchdog(FSWatcherBase): 

311 def __init__(self): 

312 self.observer = Observer() 

313 import odoo.addons # noqa: PLC0415 

314 for path in odoo.addons.__path__: 

315 _logger.info('Watching addons folder %s', path) 

316 self.observer.schedule(self, path, recursive=True) 

317 

318 def dispatch(self, event): 

319 if isinstance(event, (FileCreatedEvent, FileModifiedEvent, FileMovedEvent)): 

320 if not event.is_directory: 

321 path = getattr(event, 'dest_path', '') or event.src_path 

322 self.handle_file(path) 

323 

324 def start(self): 

325 self.observer.start() 

326 _logger.info('AutoReload watcher running with watchdog') 

327 

328 def stop(self): 

329 self.observer.stop() 

330 self.observer.join() 

331 

332 

333class FSWatcherInotify(FSWatcherBase): 

334 def __init__(self): 

335 self.started = False 

336 # ignore warnings from inotify in case we have duplicate addons paths. 

337 inotify.adapters._LOGGER.setLevel(logging.ERROR) 

338 # recreate a list as InotifyTrees' __init__ deletes the list's items 

339 paths_to_watch = [] 

340 import odoo.addons # noqa: PLC0415 

341 for path in odoo.addons.__path__: 

342 paths_to_watch.append(path) 

343 _logger.info('Watching addons folder %s', path) 

344 self.watcher = InotifyTrees(paths_to_watch, mask=INOTIFY_LISTEN_EVENTS, block_duration_s=.5) 

345 

346 def run(self): 

347 _logger.info('AutoReload watcher running with inotify') 

348 dir_creation_events = set(('IN_MOVED_TO', 'IN_CREATE')) 

349 while self.started: 

350 for event in self.watcher.event_gen(timeout_s=0, yield_nones=False): 

351 (_, type_names, path, filename) = event 

352 if 'IN_ISDIR' not in type_names: 

353 # despite not having IN_DELETE in the watcher's mask, the 

354 # watcher sends these events when a directory is deleted. 

355 if 'IN_DELETE' not in type_names: 

356 full_path = os.path.join(path, filename) 

357 if self.handle_file(full_path): 

358 return 

359 elif dir_creation_events.intersection(type_names): 

360 full_path = os.path.join(path, filename) 

361 for root, _, files in os.walk(full_path): 

362 for file in files: 

363 if self.handle_file(os.path.join(root, file)): 

364 return 

365 

366 def start(self): 

367 self.started = True 

368 self.thread = threading.Thread(target=self.run, name="odoo.service.autoreload.watcher") 

369 self.thread.daemon = True 

370 self.thread.start() 

371 

372 def stop(self): 

373 self.started = False 

374 self.thread.join() 

375 del self.watcher # ensures inotify watches are freed up before reexec 

376 

377 

378#---------------------------------------------------------- 

379# Servers: Threaded, Gevented and Prefork 

380#---------------------------------------------------------- 

381 

382class CommonServer(object): 

383 _on_stop_funcs = [] 

384 

385 def __init__(self, app): 

386 self.app = app 

387 # config 

388 self.interface = config['http_interface'] or '0.0.0.0' 

389 self.port = config['http_port'] 

390 # runtime 

391 self.pid = os.getpid() 

392 

393 def close_socket(self, sock): 

394 """ Closes a socket instance cleanly 

395 :param sock: the network socket to close 

396 :type sock: socket.socket 

397 """ 

398 try: 

399 sock.shutdown(socket.SHUT_RDWR) 

400 except socket.error as e: 

401 if e.errno == errno.EBADF: 

402 # Werkzeug > 0.9.6 closes the socket itself (see commit 

403 # https://github.com/mitsuhiko/werkzeug/commit/4d8ca089) 

404 return 

405 # On OSX, socket shutdowns both sides if any side closes it 

406 # causing an error 57 'Socket is not connected' on shutdown 

407 # of the other side (or something), see 

408 # http://bugs.python.org/issue4397 

409 # note: stdlib fixed test, not behavior 

410 if e.errno != errno.ENOTCONN or platform.system() not in ['Darwin', 'Windows']: 

411 raise 

412 sock.close() 

413 

414 @classmethod 

415 def on_stop(cls, func): 

416 """ Register a cleanup function to be executed when the server stops """ 

417 cls._on_stop_funcs.append(func) 

418 

419 def stop(self): 

420 for func in self._on_stop_funcs: 

421 try: 

422 _logger.debug("on_close call %s", func) 

423 func() 

424 except Exception: 

425 _logger.warning("Exception in %s", func.__name__, exc_info=True) 

426 

427 

428class ThreadedServer(CommonServer): 

429 def __init__(self, app): 

430 super(ThreadedServer, self).__init__(app) 

431 self.main_thread_id = threading.current_thread().ident 

432 # Variable keeping track of the number of calls to the signal handler defined 

433 # below. This variable is monitored by ``quit_on_signals()``. 

434 self.quit_signals_received = 0 

435 

436 #self.socket = None 

437 self.httpd = None 

438 self.limits_reached_threads = set() 

439 self.limit_reached_time = None 

440 

441 def signal_handler(self, sig, frame): 

442 if sig in [signal.SIGINT, signal.SIGTERM]: 

443 # shutdown on kill -INT or -TERM 

444 self.quit_signals_received += 1 

445 if self.quit_signals_received > 1: 

446 # logging.shutdown was already called at this point. 

447 sys.stderr.write("Forced shutdown.\n") 

448 os._exit(0) 

449 # interrupt run() to start shutdown 

450 raise KeyboardInterrupt() 

451 elif hasattr(signal, 'SIGXCPU') and sig == signal.SIGXCPU: 

452 sys.stderr.write("CPU time limit exceeded! Shutting down immediately\n") 

453 sys.stderr.flush() 

454 os._exit(0) 

455 elif sig == signal.SIGHUP: 

456 # restart on kill -HUP 

457 global server_phoenix # noqa: PLW0603 

458 server_phoenix = True 

459 self.quit_signals_received += 1 

460 # interrupt run() to start shutdown 

461 raise KeyboardInterrupt() 

462 

463 def process_limit(self): 

464 memory = memory_info(psutil.Process(os.getpid())) 

465 if config['limit_memory_soft'] and memory > config['limit_memory_soft']: 

466 _logger.warning('Server memory limit (%s) reached.', memory) 

467 self.limits_reached_threads.add(threading.current_thread()) 

468 

469 for thread in threading.enumerate(): 

470 thread_type = getattr(thread, 'type', None) 

471 if not thread.daemon and thread_type != 'websocket' or thread_type == 'cron': 

472 # We apply the limits on cron threads and HTTP requests, 

473 # websocket requests excluded. 

474 if getattr(thread, 'start_time', None): 

475 thread_execution_time = time.time() - thread.start_time 

476 thread_limit_time_real = config['limit_time_real'] 

477 if (getattr(thread, 'type', None) == 'cron' and 

478 config['limit_time_real_cron'] and config['limit_time_real_cron'] > 0): 

479 thread_limit_time_real = config['limit_time_real_cron'] 

480 if thread_limit_time_real and thread_execution_time > thread_limit_time_real: 

481 _logger.warning( 

482 'Thread %s virtual real time limit (%d/%ds) reached.', 

483 thread, thread_execution_time, thread_limit_time_real) 

484 self.limits_reached_threads.add(thread) 

485 # Clean-up threads that are no longer alive 

486 # e.g. threads that exceeded their real time, 

487 # but which finished before the server could restart. 

488 for thread in list(self.limits_reached_threads): 

489 if not thread.is_alive(): 

490 self.limits_reached_threads.remove(thread) 

491 if self.limits_reached_threads: 

492 self.limit_reached_time = self.limit_reached_time or time.time() 

493 else: 

494 self.limit_reached_time = None 

495 

496 def cron_thread(self, number): 

497 # Steve Reich timing style with thundering herd mitigation. 

498 # 

499 # On startup, all workers bind on a notification channel in 

500 # postgres so they can be woken up at will. At worst they wake 

501 # up every SLEEP_INTERVAL with a jitter. The jitter creates a 

502 # chorus effect that helps distribute on the timeline the moment 

503 # when individual worker wake up. 

504 # 

505 # On NOTIFY, all workers are awaken at the same time, sleeping 

506 # just a bit prevents they all poll the database at the exact 

507 # same time. This is known as the thundering herd effect. 

508 

509 from odoo.addons.base.models.ir_cron import IrCron # noqa: PLC0415 

510 

511 def _run_cron(cr): 

512 pg_conn = cr._cnx 

513 # LISTEN / NOTIFY doesn't work in recovery mode 

514 cr.execute("SELECT pg_is_in_recovery()") 

515 in_recovery = cr.fetchone()[0] 

516 if not in_recovery: 

517 cr.execute("LISTEN cron_trigger") 

518 else: 

519 _logger.warning("PG cluster in recovery mode, cron trigger not activated") 

520 cr.commit() 

521 check_all_time = 0.0 # last time that we listed databases, initialized far in the past 

522 all_db_names = [] 

523 alive_time = time.monotonic() 

524 while config['limit_time_worker_cron'] <= 0 or (time.monotonic() - alive_time) <= config['limit_time_worker_cron']: 

525 select.select([pg_conn], [], [], SLEEP_INTERVAL + number) 

526 time.sleep(number / 100) 

527 try: 

528 pg_conn.poll() 

529 except Exception: 

530 if pg_conn.closed: 

531 # connection closed, just exit the loop 

532 return 

533 raise 

534 notified = OrderedSet( 

535 notif.payload 

536 for notif in pg_conn.notifies 

537 if notif.channel == 'cron_trigger' 

538 ) 

539 pg_conn.notifies.clear() # free resources 

540 

541 if time.time() - SLEEP_INTERVAL > check_all_time: 

542 # check all databases 

543 # last time we checked them was `now - SLEEP_INTERVAL` 

544 check_all_time = time.time() 

545 # process notified databases first, then the other ones 

546 all_db_names = OrderedSet(cron_database_list()) 

547 db_names = [ 

548 *(db for db in notified if db in all_db_names), 

549 *(db for db in all_db_names if db not in notified), 

550 ] 

551 else: 

552 # restrict to notified databases only 

553 db_names = notified.intersection(all_db_names) 

554 if not db_names: 

555 continue 

556 

557 _logger.debug('cron%d polling for jobs (notified: %s)', number, notified) 

558 for db_name in db_names: 

559 thread = threading.current_thread() 

560 thread.start_time = time.time() 

561 try: 

562 IrCron._process_jobs(db_name) 

563 except Exception: 

564 _logger.warning('cron%d encountered an Exception:', number, exc_info=True) 

565 thread.start_time = None 

566 

567 while True: 

568 conn = sql_db.db_connect('postgres') 

569 with contextlib.closing(conn.cursor()) as cr: 

570 _run_cron(cr) 

571 cr._cnx.close() 

572 _logger.info('cron%d max age (%ss) reached, releasing connection.', number, config['limit_time_worker_cron']) 

573 

574 def cron_spawn(self): 

575 """ Start the above runner function in a daemon thread. 

576 

577 The thread is a typical daemon thread: it will never quit and must be 

578 terminated when the main process exits - with no consequence (the processing 

579 threads it spawns are not marked daemon). 

580 

581 """ 

582 for i in range(config['max_cron_threads']): 

583 t = threading.Thread(target=self.cron_thread, args=(i,), name=f"odoo.service.cron.cron{i}") 

584 t.daemon = True 

585 t.type = 'cron' 

586 t.start() 

587 _logger.debug("cron%d started!", i) 

588 

589 def http_spawn(self): 

590 self.httpd = ThreadedWSGIServerReloadable(self.interface, self.port, self.app) 

591 threading.Thread( 

592 target=self.httpd.serve_forever, 

593 name="odoo.service.httpd", 

594 daemon=True, 

595 ).start() 

596 

597 def start(self, stop=False): 

598 _logger.debug("Setting signal handlers") 

599 set_limit_memory_hard() 

600 if os.name == 'posix': 600 ↛ 609line 600 didn't jump to line 609 because the condition on line 600 was always true

601 signal.signal(signal.SIGINT, self.signal_handler) 

602 signal.signal(signal.SIGTERM, self.signal_handler) 

603 signal.signal(signal.SIGCHLD, self.signal_handler) 

604 signal.signal(signal.SIGHUP, self.signal_handler) 

605 signal.signal(signal.SIGXCPU, self.signal_handler) 

606 signal.signal(signal.SIGQUIT, dumpstacks) 

607 signal.signal(signal.SIGUSR1, log_ormcache_stats) 

608 signal.signal(signal.SIGUSR2, log_ormcache_stats) 

609 elif os.name == 'nt': 

610 import win32api 

611 win32api.SetConsoleCtrlHandler(lambda sig: self.signal_handler(sig, None), 1) 

612 

613 if config['test_enable'] or (config['http_enable'] and not stop): 613 ↛ 615line 613 didn't jump to line 615 because the condition on line 613 was never true

614 # some tests need the http daemon to be available... 

615 self.http_spawn() 

616 

617 def stop(self): 

618 """ Shutdown the WSGI server. Wait for non daemon threads. 

619 """ 

620 if server_phoenix: 620 ↛ 621line 620 didn't jump to line 621 because the condition on line 620 was never true

621 _logger.info("Initiating server reload") 

622 else: 

623 _logger.info("Initiating shutdown") 

624 _logger.info("Hit CTRL-C again or send a second signal to force the shutdown.") 

625 

626 stop_time = time.time() 

627 

628 if self.httpd: 628 ↛ 629line 628 didn't jump to line 629 because the condition on line 628 was never true

629 self.httpd.shutdown() 

630 

631 super().stop() 

632 

633 # Manually join() all threads before calling sys.exit() to allow a second signal 

634 # to trigger _force_quit() in case some non-daemon threads won't exit cleanly. 

635 # threading.Thread.join() should not mask signals (at least in python 2.5). 

636 me = threading.current_thread() 

637 _logger.debug('current thread: %r', me) 

638 for thread in threading.enumerate(): 

639 _logger.debug('process %r (%r)', thread, thread.daemon) 

640 if (thread != me and not thread.daemon and thread.ident != self.main_thread_id and 640 ↛ 642line 640 didn't jump to line 642 because the condition on line 640 was never true

641 thread not in self.limits_reached_threads): 

642 while thread.is_alive() and (time.time() - stop_time) < 1: 

643 # We wait for requests to finish, up to 1 second. 

644 _logger.debug('join and sleep') 

645 # Need a busyloop here as thread.join() masks signals 

646 # and would prevent the forced shutdown. 

647 thread.join(0.05) 

648 time.sleep(0.05) 

649 

650 sql_db.close_all() 

651 

652 current_process = psutil.Process() 

653 children = current_process.children(recursive=False) 

654 for child in children: 654 ↛ 655line 654 didn't jump to line 655 because the loop on line 654 never started

655 _logger.info('A child process was found, pid is %s, process may hang', child) 

656 

657 _logger.debug('--') 

658 logging.shutdown() 

659 

660 def run(self, preload=None, stop=False): 

661 """ Start the http server and the cron thread then wait for a signal. 

662 

663 The first SIGINT or SIGTERM signal will initiate a graceful shutdown while 

664 a second one if any will force an immediate exit. 

665 """ 

666 with Registry._lock: 

667 self.start(stop=stop) 

668 rc = preload_registries(preload) 

669 

670 if stop: 670 ↛ 683line 670 didn't jump to line 683 because the condition on line 670 was always true

671 if config['test_enable']: 671 ↛ 672line 671 didn't jump to line 672 because the condition on line 671 was never true

672 from odoo.tests.result import _logger as logger # noqa: PLC0415 

673 with Registry.registries._lock: 

674 for db, registry in Registry.registries.items(): 

675 report = registry._assertion_report 

676 log = logger.error if not report.wasSuccessful() \ 

677 else logger.warning if not report.testsRun \ 

678 else logger.info 

679 log("%s when loading database %r", report, db) 

680 self.stop() 

681 return rc 

682 

683 self.cron_spawn() 

684 

685 # Wait for a first signal to be handled. (time.sleep will be interrupted 

686 # by the signal handler) 

687 try: 

688 while self.quit_signals_received == 0: 

689 self.process_limit() 

690 if self.limit_reached_time: 

691 has_other_valid_requests = any( 

692 not t.daemon and 

693 t not in self.limits_reached_threads 

694 for t in threading.enumerate() 

695 if getattr(t, 'type', None) == 'http') 

696 if (not has_other_valid_requests or 

697 (time.time() - self.limit_reached_time) > SLEEP_INTERVAL): 

698 # We wait there is no processing requests 

699 # other than the ones exceeding the limits, up to 1 min, 

700 # before asking for a reload. 

701 _logger.info('Dumping stacktrace of limit exceeding threads before reloading') 

702 dumpstacks(thread_idents=[thread.ident for thread in self.limits_reached_threads]) 

703 self.reload() 

704 # `reload` increments `self.quit_signals_received` 

705 # and the loop will end after this iteration, 

706 # therefore leading to the server stop. 

707 # `reload` also sets the `server_phoenix` flag 

708 # to tell the server to restart the server after shutting down. 

709 else: 

710 time.sleep(1) 

711 else: 

712 time.sleep(SLEEP_INTERVAL) 

713 except KeyboardInterrupt: 

714 pass 

715 

716 self.stop() 

717 

718 def reload(self): 

719 os.kill(self.pid, signal.SIGHUP) 

720 

721class GeventServer(CommonServer): 

722 def __init__(self, app): 

723 super(GeventServer, self).__init__(app) 

724 self.port = config['gevent_port'] 

725 self.httpd = None 

726 

727 def process_limits(self): 

728 restart = False 

729 if self.ppid != os.getppid(): 

730 _logger.warning("Gevent Parent changed: %s", self.pid) 

731 restart = True 

732 memory = memory_info(psutil.Process(self.pid)) 

733 limit_memory_soft = config['limit_memory_soft_gevent'] or config['limit_memory_soft'] 

734 if limit_memory_soft and memory > limit_memory_soft: 

735 _logger.warning('Gevent virtual memory limit reached: %s', memory) 

736 restart = True 

737 if restart: 

738 # suicide !! 

739 os.kill(self.pid, signal.SIGTERM) 

740 

741 def watchdog(self, beat=4): 

742 import gevent 

743 self.ppid = os.getppid() 

744 while True: 

745 self.process_limits() 

746 gevent.sleep(beat) 

747 

748 def start(self): 

749 import gevent 

750 try: 

751 from gevent.pywsgi import WSGIServer, WSGIHandler 

752 except ImportError: 

753 from gevent.wsgi import WSGIServer, WSGIHandler 

754 

755 class ProxyHandler(WSGIHandler): 

756 """ When logging requests, try to get the client address from 

757 the environment so we get proxyfix's modifications (if any). 

758 

759 Derived from werzeug.serving.WSGIRequestHandler.log 

760 / werzeug.serving.WSGIRequestHandler.address_string 

761 """ 

762 def _connection_upgrade_requested(self): 

763 if self.headers.get('Connection', '').lower() == 'upgrade': 

764 return True 

765 if self.headers.get('Upgrade', '').lower() == 'websocket': 

766 return True 

767 return False 

768 

769 def format_request(self): 

770 old_address = self.client_address 

771 if getattr(self, 'environ', None): 

772 self.client_address = self.environ['REMOTE_ADDR'] 

773 elif not self.client_address: 

774 self.client_address = '<local>' 

775 # other cases are handled inside WSGIHandler 

776 try: 

777 return super().format_request() 

778 finally: 

779 self.client_address = old_address 

780 

781 def finalize_headers(self): 

782 # We need to make gevent.pywsgi stop dealing with chunks when the connection 

783 # Is being upgraded. see https://github.com/gevent/gevent/issues/1712 

784 super().finalize_headers() 

785 if self.code == 101: 

786 # Switching Protocols. Disable chunked writes. 

787 self.response_use_chunked = False 

788 

789 def get_environ(self): 

790 # Add the TCP socket to environ in order for the websocket 

791 # connections to use it. 

792 environ = super().get_environ()