From e45954f4777888f12e1b6c9b6a6b5d92c1af2c50 Mon Sep 17 00:00:00 2001 From: Alain Mebsout Date: Mon, 28 Oct 2024 11:40:43 +0100 Subject: [PATCH 1/2] Rollup node: remove lazy usage in workers This is a bad pattern, especially as the Lazy.force can be triggered from the outside from an RPC (for the batcher). --- src/lib_smart_rollup_node/batcher.ml | 28 +++++++++---------- .../dal_injection_queue.ml | 26 ++++++++--------- src/lib_smart_rollup_node/publisher.ml | 19 ++++++------- .../refutation_coordinator.ml | 19 ++++++------- 4 files changed, 45 insertions(+), 47 deletions(-) diff --git a/src/lib_smart_rollup_node/batcher.ml b/src/lib_smart_rollup_node/batcher.ml index 00c1c99e3cd5..88fa5154cc7e 100644 --- a/src/lib_smart_rollup_node/batcher.ml +++ b/src/lib_smart_rollup_node/batcher.ml @@ -348,12 +348,12 @@ let init plugin (node_ctxt : _ Node_context.t) = else return_unit (* This is a batcher worker for a single scoru *) -let worker = - lazy - (match Lwt.state worker_promise with - | Lwt.Return worker -> Ok worker - | Lwt.Fail exn -> Error (Error_monad.error_of_exn exn) - | Lwt.Sleep -> Error Rollup_node_errors.No_batcher) +let worker () = + let open Result_syntax in + match Lwt.state worker_promise with + | Lwt.Return worker -> return worker + | Lwt.Fail exn -> tzfail (Error_monad.error_of_exn exn) + | Lwt.Sleep -> tzfail Rollup_node_errors.No_batcher let active () = match Lwt.state worker_promise with @@ -362,13 +362,13 @@ let active () = let find_message id = let open Result_syntax in - let+ w = Result.map_error TzTrace.make (Lazy.force worker) in + let+ w = worker () in let state = Worker.state w in Message_queue.find_opt state.messages id let get_queue () = let open Result_syntax in - let+ w = Result.map_error TzTrace.make (Lazy.force worker) in + let+ w = worker () in let state = Worker.state w in Message_queue.bindings state.messages @@ -384,7 +384,7 @@ let handle_request_error rq = let register_messages ~drop_duplicate messages = let open Lwt_result_syntax in - let* w = lwt_map_error TzTrace.make (Lwt.return (Lazy.force worker)) in + let*? w = worker () in Worker.Queue.push_request_and_wait w (Request.Register {messages; drop_duplicate}) @@ -392,17 +392,17 @@ let register_messages ~drop_duplicate messages = let produce_batches () = let open Lwt_result_syntax in - match Lazy.force worker with - | Error Rollup_node_errors.No_batcher -> + match worker () with + | Error (Rollup_node_errors.No_batcher :: _) -> (* There is no batcher, nothing to do *) return_unit - | Error e -> tzfail e + | Error e -> fail e | Ok w -> Worker.Queue.push_request_and_wait w Request.Produce_batches |> handle_request_error let shutdown () = - match Lazy.force worker with + match worker () with | Error _ -> (* There is no batcher, nothing to do *) Lwt.return_unit @@ -418,7 +418,7 @@ let message_status state msg_id = let message_status msg_id = let open Result_syntax in - let+ w = Result.map_error TzTrace.make (Lazy.force worker) in + let+ w = worker () in let state = Worker.state w in message_status state msg_id diff --git a/src/lib_smart_rollup_node/dal_injection_queue.ml b/src/lib_smart_rollup_node/dal_injection_queue.ml index fcaf9df58f13..44640e32c67b 100644 --- a/src/lib_smart_rollup_node/dal_injection_queue.ml +++ b/src/lib_smart_rollup_node/dal_injection_queue.ml @@ -548,12 +548,12 @@ let init (node_ctxt : _ Node_context.t) = else return_unit) (* This is a DAL injection worker for a single scoru *) -let worker = - lazy - (match Lwt.state worker_promise with - | Lwt.Return worker -> Ok worker - | Lwt.Fail exn -> Error (Error_monad.error_of_exn exn) - | Lwt.Sleep -> Error Rollup_node_errors.No_dal_injector) +let worker () = + let open Result_syntax in + match Lwt.state worker_promise with + | Lwt.Return worker -> return worker + | Lwt.Fail exn -> tzfail (Error_monad.error_of_exn exn) + | Lwt.Sleep -> tzfail Rollup_node_errors.No_dal_injector let handle_request_error rq = let open Lwt_syntax in @@ -571,35 +571,35 @@ let register_dal_message w message = let register_dal_messages ~messages = let open Lwt_result_syntax in - let* w = lwt_map_error TzTrace.make (Lwt.return (Lazy.force worker)) in + let*? w = worker () in List.iter_es (register_dal_message w) messages let produce_dal_slots ~level = let open Lwt_result_syntax in - match Lazy.force worker with - | Error Rollup_node_errors.No_dal_injector -> + match worker () with + | Error (Rollup_node_errors.No_dal_injector :: _) -> (* There is no batcher, nothing to do *) return_unit - | Error e -> tzfail e + | Error e -> fail e | Ok w -> Worker.Queue.push_request_and_wait w Request.(Produce_dal_slots level) |> handle_request_error let set_dal_slot_indices idx = let open Lwt_result_syntax in - let* w = lwt_map_error TzTrace.make (Lwt.return (Lazy.force worker)) in + let*? w = worker () in Worker.Queue.push_request_and_wait w Request.(Set_dal_slot_indices idx) |> handle_request_error let get_injection_ids () = let open Result_syntax in - let+ w = Result.map_error TzTrace.make (Lazy.force worker) in + let+ w = worker () in let state = Worker.state w in Recent_dal_injections.keys state.recent_dal_injections let forget_injection_id id = let open Result_syntax in - let+ w = Result.map_error TzTrace.make (Lazy.force worker) in + let+ w = worker () in let state = Worker.state w in let () = Recent_dal_injections.remove state.recent_dal_injections id in Metrics.DAL_batcher.set_dal_injections_queue_length diff --git a/src/lib_smart_rollup_node/publisher.ml b/src/lib_smart_rollup_node/publisher.ml index 37215b791b5c..f25c3a6fbc61 100644 --- a/src/lib_smart_rollup_node/publisher.ml +++ b/src/lib_smart_rollup_node/publisher.ml @@ -564,17 +564,16 @@ let init (node_ctxt : _ Node_context.t) = else return_unit (* This is a publisher worker for a single scoru *) -let worker = +let worker () = let open Result_syntax in - lazy - (match Lwt.state worker_promise with - | Lwt.Return worker -> return worker - | Lwt.Fail exn -> fail (Error_monad.error_of_exn exn) - | Lwt.Sleep -> Error Rollup_node_errors.No_publisher) + match Lwt.state worker_promise with + | Lwt.Return worker -> return worker + | Lwt.Fail exn -> tzfail (Error_monad.error_of_exn exn) + | Lwt.Sleep -> tzfail Rollup_node_errors.No_publisher let worker_add_request condition ~request = let open Lwt_result_syntax in - match Lazy.force worker with + match worker () with | Ok w -> let node_ctxt = Worker.state w in (* Bailout does not publish any commitment it only cement them. *) @@ -584,8 +583,8 @@ let worker_add_request condition ~request = @@ fun () -> let*! (_pushed : bool) = Worker.Queue.push_request w request in return_unit - | Error Rollup_node_errors.No_publisher -> return_unit - | Error e -> tzfail e + | Error (Rollup_node_errors.No_publisher :: _) -> return_unit + | Error e -> fail e let publish_commitments () = worker_add_request ~request:Request.Publish (fun node_ctxt -> @@ -600,7 +599,7 @@ let execute_outbox () = Configuration.can_inject node_ctxt.config.mode Execute_outbox_message) let shutdown () = - match Lazy.force worker with + match worker () with | Error _ -> (* There is no publisher, nothing to do *) Lwt.return_unit diff --git a/src/lib_smart_rollup_node/refutation_coordinator.ml b/src/lib_smart_rollup_node/refutation_coordinator.ml index 19170c91c090..d425162178dd 100644 --- a/src/lib_smart_rollup_node/refutation_coordinator.ml +++ b/src/lib_smart_rollup_node/refutation_coordinator.ml @@ -216,28 +216,27 @@ let init (node_ctxt : _ Node_context.t) = else return_unit (* This is a refutation coordinator for a single scoru *) -let worker = +let worker () = let open Result_syntax in - lazy - (match Lwt.state worker_promise with - | Lwt.Return worker -> return worker - | Lwt.Fail exn -> fail (Error_monad.error_of_exn exn) - | Lwt.Sleep -> Error Rollup_node_errors.No_refutation_coordinator) + match Lwt.state worker_promise with + | Lwt.Return worker -> return worker + | Lwt.Fail exn -> tzfail (Error_monad.error_of_exn exn) + | Lwt.Sleep -> tzfail Rollup_node_errors.No_refutation_coordinator let process b = let open Lwt_result_syntax in - match Lazy.force worker with + match worker () with | Ok w -> let*! (_pushed : bool) = Worker.Queue.push_request w (Request.Process b) in return_unit - | Error Rollup_node_errors.No_refutation_coordinator -> return_unit - | Error e -> tzfail e + | Error (Rollup_node_errors.No_refutation_coordinator :: _) -> return_unit + | Error e -> fail e let shutdown () = let open Lwt_syntax in - match Lazy.force worker with + match worker () with | Error _ -> (* There is no refutation coordinator, nothing to do *) return_unit -- GitLab From 7a2436b92ac9a8dd9dd03ec8aca91914b137a57d Mon Sep 17 00:00:00 2001 From: Alain Mebsout Date: Tue, 29 Oct 2024 16:26:37 +0100 Subject: [PATCH 2/2] Doc: changelog --- CHANGES.rst | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/CHANGES.rst b/CHANGES.rst index 516bb3d31297..67a8388f5b75 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -119,6 +119,17 @@ Smart Rollup node - RPC ``/global/block//outbox//messages`` now fails if ``outbox_level`` is above the level of ``block_id``. (MR :gl:`!14911`) +- Storage now uses SQLite as a backend instead of the custom indexed-file based + store. This change makes the rollup node more robust but entails a migration + of the store data. (MRs :gl:`!15053`, :gl:`!15026`, :gl:`!15059`, + :gl:`!15073`, :gl:`!15218`, :gl:`!15257`) + +- Allow to import snaphosts for older stores by migrating the data on import. + (MR :gl:`!15422`) + +- Fixed a bug which would make injection of messages in the batcher with the RPC + ``/local/batcher/injection`` fail if called too early. (MR :gl:`!15459`) + Smart Rollup WASM Debugger -------------------------- -- GitLab