2863

Committed 05 Nov 2024 06:20PM UTC coverage: 30.754% (-16.6%) from 47.311%

Build # 2863

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge pull request #16296 from MinaProtocol/dkijania/more_multi_jobs

more multi jobs in CI

Run Details

20276 of 65930 relevant lines covered (30.75%)

8631.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

43.86

/src/lib/mina_net2/validation_callback.ml

open Core
open Async
module Timeout = Timeout_lib.Core_time_ns

type validation_result = [ `Accept | `Reject | `Ignore ] [@@deriving equal]

type t =
  { expiration : Time_ns.t option
  ; created_at : Time_ns.t
  ; signal : validation_result Ivar.t
  ; mutable message_type : [ `Unknown | `Block | `Snark_work | `Transaction ]
  }

let create expiration =
  { expiration = Some expiration
  ; created_at = Time_ns.now ()
  ; signal = Ivar.create ()
  ; message_type = `Unknown
  }

let create_without_expiration () =
  { expiration = None
  ; created_at = Time_ns.now ()
  ; signal = Ivar.create ()
  ; message_type = `Unknown
  }

let is_expired cb =
  match cb.expiration with
  | None ->
      false
  | Some expires_at ->
      Time_ns.(now () >= expires_at)

module type Metric_intf = sig
  val validations_timed_out : Mina_metrics.Counter.t

  val rejected : Mina_metrics.Counter.t

  val ignored : Mina_metrics.Counter.t

  module Validation_time : sig
    val update : Time.Span.t -> unit
  end

  module Processing_time : sig
    val update : Time.Span.t -> unit
  end

  module Rejection_time : sig
    val update : Time.Span.t -> unit
  end
end

let metrics_of_message_type m : (module Metric_intf) option =
  match m with
  | `Unknown ->
      None
  | `Block ->
      Some (module Mina_metrics.Network.Block)
  | `Snark_work ->
      Some (module Mina_metrics.Network.Snark_work)
  | `Transaction ->
      Some (module Mina_metrics.Network.Transaction)

let record_timeout_metrics cb =
  Mina_metrics.(Counter.inc_one Network.validations_timed_out) ;
  match metrics_of_message_type cb.message_type with
  | None ->
      ()
  | Some (module M) ->
      Mina_metrics.Counter.inc_one M.validations_timed_out

let record_validation_metrics message_type (result : validation_result)
    validation_time processing_time ~block_window_duration:_ (*TODO remove*) =
  match metrics_of_message_type message_type with
  | None ->
      ()
  | Some (module M) -> (
      match result with
      | `Ignore ->
          Mina_metrics.Counter.inc_one M.ignored
      | `Accept ->
          let module Validation_time = M.Validation_time in
          Validation_time.update validation_time ;
          let module Processing_time = M.Processing_time in
          Processing_time.update processing_time
      | `Reject ->
          Mina_metrics.Counter.inc_one M.rejected ;
          let module Rejection_time = M.Rejection_time in
          Rejection_time.update processing_time )

let await_timeout cb =
  if is_expired cb then Deferred.return ()
  else
    match cb.expiration with
    | None ->
        Deferred.never ()
    | Some expires_at ->
        after
          ( Time_ns.Span.to_span_float_round_nearest
          @@ Time_ns.diff expires_at (Time_ns.now ()) )

let await ~block_window_duration cb =
  if is_expired cb then (record_timeout_metrics cb ; Deferred.return None)
  else
    match cb.expiration with
    | None ->
        Ivar.read cb.signal >>| Option.some
    | Some expires_at -> (
        match%map
          Timeout.await ()
            ~timeout_duration:(Time_ns.diff expires_at (Time_ns.now ()))
            (Ivar.read cb.signal)
        with
        | `Ok result ->
            let validation_time =
              Time_ns.abs_diff expires_at (Time_ns.now ())
              |> Time_ns.Span.to_ms |> Time.Span.of_ms
            in
            let processing_time =
              Time_ns.abs_diff (Time_ns.now ()) cb.created_at
              |> Time_ns.Span.to_ms |> Time.Span.of_ms
            in
            record_validation_metrics ~block_window_duration cb.message_type
              result validation_time processing_time ;
            Some result
        | `Timeout ->
            record_timeout_metrics cb ; None )

let await_exn ~block_window_duration cb =
  match%map await ~block_window_duration cb with
  | None ->
      failwith "timeout"
  | Some result ->
      result

let fire_if_not_already_fired cb result =
  if not (is_expired cb) then Ivar.fill_if_empty cb.signal result

let set_message_type t x = t.message_type <- x

1	open Core	4✔
2	open Async
3	module Timeout = Timeout_lib.Core_time_ns
4
5	type validation_result = [ `Accept \| `Reject \| `Ignore ] [@@deriving equal]	×
6
7	type t =
8	{ expiration : Time_ns.t option
9	; created_at : Time_ns.t
10	; signal : validation_result Ivar.t
11	; mutable message_type : [ `Unknown \| `Block \| `Snark_work \| `Transaction ]
12	}
13
14	let create expiration =
15	{ expiration = Some expiration	6✔
16	; created_at = Time_ns.now ()	6✔
17	; signal = Ivar.create ()	6✔
18	; message_type = `Unknown
19	}
20
21	let create_without_expiration () =
22	{ expiration = None	×
23	; created_at = Time_ns.now ()	×
24	; signal = Ivar.create ()	×
25	; message_type = `Unknown
26	}
27
28	let is_expired cb =
29	match cb.expiration with	12✔
30	\| None ->	×
31	false
32	\| Some expires_at ->	12✔
33	Time_ns.(now () >= expires_at)	12✔
34
35	module type Metric_intf = sig
36	val validations_timed_out : Mina_metrics.Counter.t
37
38	val rejected : Mina_metrics.Counter.t
39
40	val ignored : Mina_metrics.Counter.t
41
42	module Validation_time : sig
43	val update : Time.Span.t -> unit
44	end
45
46	module Processing_time : sig
47	val update : Time.Span.t -> unit
48	end
49
50	module Rejection_time : sig
51	val update : Time.Span.t -> unit
52	end
53	end
54
55	let metrics_of_message_type m : (module Metric_intf) option =
56	match m with	6✔
57	\| `Unknown ->	6✔
58	None
59	\| `Block ->	×
60	Some (module Mina_metrics.Network.Block)
61	\| `Snark_work ->	×
62	Some (module Mina_metrics.Network.Snark_work)
63	\| `Transaction ->	×
64	Some (module Mina_metrics.Network.Transaction)
65
66	let record_timeout_metrics cb =
67	Mina_metrics.(Counter.inc_one Network.validations_timed_out) ;	×
68	match metrics_of_message_type cb.message_type with
69	\| None ->	×
70	()
71	\| Some (module M) ->	×
72	Mina_metrics.Counter.inc_one M.validations_timed_out
73
74	let record_validation_metrics message_type (result : validation_result)
75	validation_time processing_time ~block_window_duration:_ (TODO remove) =
76	match metrics_of_message_type message_type with	6✔
77	\| None ->	6✔
78	()
79	\| Some (module M) -> (	×
80	match result with
81	\| `Ignore ->	×
82	Mina_metrics.Counter.inc_one M.ignored
83	\| `Accept ->	×
84	let module Validation_time = M.Validation_time in
85	Validation_time.update validation_time ;
86	let module Processing_time = M.Processing_time in	×
87	Processing_time.update processing_time
88	\| `Reject ->	×
89	Mina_metrics.Counter.inc_one M.rejected ;
90	let module Rejection_time = M.Rejection_time in	×
91	Rejection_time.update processing_time )
92
93	let await_timeout cb =
94	if is_expired cb then Deferred.return ()	×
95	else
96	match cb.expiration with	×
97	\| None ->	×
98	Deferred.never ()
99	\| Some expires_at ->	×
100	after
101	( Time_ns.Span.to_span_float_round_nearest	×
102	@@ Time_ns.diff expires_at (Time_ns.now ()) )	×
103
104	let await ~block_window_duration cb =
105	if is_expired cb then (record_timeout_metrics cb ; Deferred.return None)	×
106	else
107	match cb.expiration with	6✔
108	\| None ->	×
109	Ivar.read cb.signal >>\| Option.some	×
110	\| Some expires_at -> (	6✔
111	match%map
112	Timeout.await ()	6✔
113	~timeout_duration:(Time_ns.diff expires_at (Time_ns.now ()))	6✔
114	(Ivar.read cb.signal)	6✔
115	with
116	\| `Ok result ->	6✔
117	let validation_time =
118	Time_ns.abs_diff expires_at (Time_ns.now ())	6✔
119	\|> Time_ns.Span.to_ms \|> Time.Span.of_ms	6✔
120	in
121	let processing_time =	6✔
122	Time_ns.abs_diff (Time_ns.now ()) cb.created_at	6✔
123	\|> Time_ns.Span.to_ms \|> Time.Span.of_ms	6✔
124	in
125	record_validation_metrics ~block_window_duration cb.message_type	6✔
126	result validation_time processing_time ;
127	Some result	6✔
128	\| `Timeout ->	×
129	record_timeout_metrics cb ; None )	×
130
131	let await_exn ~block_window_duration cb =
132	match%map await ~block_window_duration cb with	×
133	\| None ->	×
134	failwith "timeout"
135	\| Some result ->	×
136	result
137
138	let fire_if_not_already_fired cb result =
139	if not (is_expired cb) then Ivar.fill_if_empty cb.signal result	6✔
140
141	let set_message_type t x = t.message_type <- x	×

MinaProtocol / mina / 2863

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous