referrerpolicy=no-referrer-when-downgrade

polkadot_node_core_backing/
error.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// Copyright (C) Parity Technologies (UK) Ltd.
// This file is part of Polkadot.

// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.

use std::collections::HashMap;

use fatality::Nested;
use futures::channel::{mpsc, oneshot};

use polkadot_node_subsystem::{
	messages::{StoreAvailableDataError, ValidationFailed},
	RuntimeApiError, SubsystemError,
};
use polkadot_node_subsystem_util::{runtime, Error as UtilError};
use polkadot_primitives::{vstaging::BackedCandidate, ValidationCodeHash};

use crate::{ParaId, LOG_TARGET};

pub type Result<T> = std::result::Result<T, Error>;
pub type FatalResult<T> = std::result::Result<T, FatalError>;

/// Errors that can occur in candidate backing.
#[allow(missing_docs)]
#[fatality::fatality(splitable)]
pub enum Error {
	#[fatal]
	#[error("Failed to spawn background task")]
	FailedToSpawnBackgroundTask,

	#[fatal(forward)]
	#[error("Error while accessing runtime information")]
	Runtime(#[from] runtime::Error),

	#[fatal]
	#[error(transparent)]
	BackgroundValidationMpsc(#[from] mpsc::SendError),

	#[error("Candidate is not found")]
	CandidateNotFound,

	#[error("CoreIndex cannot be determined for a candidate")]
	CoreIndexUnavailable,

	#[error("Signature is invalid")]
	InvalidSignature,

	#[error("Failed to send candidates {0:?}")]
	Send(HashMap<ParaId, Vec<BackedCandidate>>),

	#[error("FetchPoV failed")]
	FetchPoV,

	#[error("Fetching validation code by hash failed {0:?}, {1:?}")]
	FetchValidationCode(ValidationCodeHash, RuntimeApiError),

	#[error("Fetching Runtime API version failed {0:?}")]
	FetchRuntimeApiVersion(RuntimeApiError),

	#[error("No validation code {0:?}")]
	NoValidationCode(ValidationCodeHash),

	#[error("Candidate rejected by prospective parachains subsystem")]
	RejectedByProspectiveParachains,

	#[error("ValidateFromExhaustive channel closed before receipt")]
	ValidateFromExhaustive(#[source] oneshot::Canceled),

	#[error("StoreAvailableData channel closed before receipt")]
	StoreAvailableDataChannel(#[source] oneshot::Canceled),

	#[error("RuntimeAPISubsystem channel closed before receipt")]
	RuntimeApiUnavailable(#[source] oneshot::Canceled),

	#[error("a channel was closed before receipt in try_join!")]
	#[fatal]
	JoinMultiple(#[source] oneshot::Canceled),

	#[error("Obtaining erasure chunks failed")]
	ObtainErasureChunks(#[from] polkadot_erasure_coding::Error),

	#[error(transparent)]
	ValidationFailed(#[from] ValidationFailed),

	#[error(transparent)]
	UtilError(#[from] UtilError),

	#[error(transparent)]
	SubsystemError(#[from] SubsystemError),

	#[fatal]
	#[error(transparent)]
	OverseerExited(SubsystemError),

	#[error("Availability store error")]
	StoreAvailableData(#[source] StoreAvailableDataError),

	#[error("Runtime API returned None for executor params")]
	MissingExecutorParams,
}

/// Utility for eating top level errors and log them.
///
/// We basically always want to try and continue on error. This utility function is meant to
/// consume top-level errors by simply logging them
pub fn log_error(result: Result<()>) -> std::result::Result<(), FatalError> {
	match result.into_nested()? {
		Ok(()) => Ok(()),
		Err(jfyi) => {
			jfyi.log();
			Ok(())
		},
	}
}

impl JfyiError {
	/// Log a `JfyiError`.
	pub fn log(self) {
		gum::debug!(target: LOG_TARGET, error = ?self);
	}
}