2903

Committed 15 Nov 2024 01:59PM UTC coverage: 36.723% (-25.0%) from 61.682%

Build # 2903

Build Type

Pull #16342

buildkite

Committed by

dkijania

Commit Message

Merge branch 'dkijania/remove_publish_job_from_pr_comp' into dkijania/remove_publish_job_from_pr_dev

Pull Request Pull Request #16342: [DEV] Publish debians only on nightly and stable

Run Details

15 of 40 new or added lines in 14 files covered. (37.5%)

15175 existing lines in 340 files now uncovered.

24554 of 66863 relevant lines covered (36.72%)

20704.91 hits per line

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

1.72

/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 =
  match metrics_of_message_type message_type with
  | None ->
      ()
  | Some (module M) -> (
      match result with
      | `Ignore ->
          Mina_metrics.Counter.inc_one M.ignored
      | `Accept ->
          M.Validation_time.update validation_time ;
          M.Processing_time.update processing_time
      | `Reject ->
          Mina_metrics.Counter.inc_one M.rejected ;
          M.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 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 cb.message_type result validation_time
              processing_time ;
            Some result
        | `Timeout ->
            record_timeout_metrics cb ; None )

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

let fire_if_not_already_fired cb result =
  if not (is_expired cb) then
    if Ivar.is_full cb.signal then
      [%log' error (Logger.create ())] "Ivar.fill bug is here!"
    else Ivar.fill cb.signal result

let set_message_type t x = t.message_type <- x

1	open Core	16✔
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 =
UNCOV 15	{ expiration = Some expiration	×
UNCOV 16	; created_at = Time_ns.now ()	×
UNCOV 17	; signal = Ivar.create ()	×
18	; message_type = `Unknown
19	}
20
21	let create_without_expiration () =
UNCOV 22	{ expiration = None	×
UNCOV 23	; created_at = Time_ns.now ()	×
UNCOV 24	; signal = Ivar.create ()	×
25	; message_type = `Unknown
26	}
27
28	let is_expired cb =
UNCOV 29	match cb.expiration with	×
UNCOV 30	\| None ->	×
31	false
UNCOV 32	\| Some expires_at ->	×
UNCOV 33	Time_ns.(now () >= expires_at)	×
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 =
UNCOV 56	match m with	×
UNCOV 57	\| `Unknown ->	×
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 =
UNCOV 76	match metrics_of_message_type message_type with	×
UNCOV 77	\| None ->	×
78	()
79	\| Some (module M) -> (	×
80	match result with
81	\| `Ignore ->	×
82	Mina_metrics.Counter.inc_one M.ignored
83	\| `Accept ->	×
84	M.Validation_time.update validation_time ;
85	M.Processing_time.update processing_time	×
86	\| `Reject ->	×
87	Mina_metrics.Counter.inc_one M.rejected ;
88	M.Rejection_time.update processing_time )	×
89
90	let await_timeout cb =
91	if is_expired cb then Deferred.return ()	×
92	else
93	match cb.expiration with	×
94	\| None ->	×
95	Deferred.never ()
96	\| Some expires_at ->	×
97	after
98	( Time_ns.Span.to_span_float_round_nearest	×
99	@@ Time_ns.diff expires_at (Time_ns.now ()) )	×
100
101	let await cb =
102	if is_expired cb then (record_timeout_metrics cb ; Deferred.return None)	×
103	else
UNCOV 104	match cb.expiration with	×
UNCOV 105	\| None ->	×
UNCOV 106	Ivar.read cb.signal >>\| Option.some	×
UNCOV 107	\| Some expires_at -> (	×
108	match%map
UNCOV 109	Timeout.await ()	×
UNCOV 110	~timeout_duration:(Time_ns.diff expires_at (Time_ns.now ()))	×
UNCOV 111	(Ivar.read cb.signal)	×
112	with
UNCOV 113	\| `Ok result ->	×
114	let validation_time =
UNCOV 115	Time_ns.abs_diff expires_at (Time_ns.now ())	×
UNCOV 116	\|> Time_ns.Span.to_ms \|> Time.Span.of_ms	×
117	in
UNCOV 118	let processing_time =	×
UNCOV 119	Time_ns.abs_diff (Time_ns.now ()) cb.created_at	×
UNCOV 120	\|> Time_ns.Span.to_ms \|> Time.Span.of_ms	×
121	in
UNCOV 122	record_validation_metrics cb.message_type result validation_time	×
123	processing_time ;
UNCOV 124	Some result	×
125	\| `Timeout ->	×
126	record_timeout_metrics cb ; None )	×
127
128	let await_exn cb =
129	match%map await cb with None -> failwith "timeout" \| Some result -> result	×
130
131	let fire_if_not_already_fired cb result =
UNCOV 132	if not (is_expired cb) then	×
UNCOV 133	if Ivar.is_full cb.signal then	×
134	[%log' error (Logger.create ())] "Ivar.fill bug is here!"	×
UNCOV 135	else Ivar.fill cb.signal result	×
136
UNCOV 137	let set_message_type t x = t.message_type <- x	×

MinaProtocol / mina / 2903

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