Make rolling session more resilient in case of long finality stalls (#6106)

* Impl dynamic window size. Keep sessions for unfinalized chain Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * feedback Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * Stretch also in contructor plus tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * review feedback Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix approval-voting tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * grunting: dispute coordinator tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * add session window column Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * integrate approval vote and fix tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix rolling session tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * Small refactor Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * WIP, tests failing Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * Fix approval voting tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix dispute-coordinator tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * remove uneeded param Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fmt Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix loose ends Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * allow failure and tests for it Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix comment Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * comment fix Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * style fix Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * new col doesn't need to be ordered Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fmt and spellcheck Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * db persist tests Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * Add v2 config and cols Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * DB upgrade WIP Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * Fix comments Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * add todo Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * update to parity-db to "0.4.2" Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * migration complete Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * One session window size Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix merge damage Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix build errors Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fmt Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * comment fix Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix build Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * make error more explicit Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * add comment Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * refactor conflict merge Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * rename col_data Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * add doc comment Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * fix build Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> * migration: move all cols to v2 Signed-off-by: Andrei Sandu <andrei-mihail@parity.io> Signed-off-by: Andrei Sandu <andrei-mihail@parity.io>
2026-06-13 19:51:05 +00:00 · 2022-11-08 19:16:31 +02:00
parent be4b5fad47
commit c261353380
15 changed files with 944 additions and 291 deletions
@@ -19,8 +19,13 @@
 //! This is useful for consensus components which need to stay up-to-date about recent sessions but don't
 //! care about the state of particular blocks.

+use super::database::{DBTransaction, Database};
+use kvdb::{DBKey, DBOp};
+
+use parity_scale_codec::{Decode, Encode};
 pub use polkadot_node_primitives::{new_session_window_size, SessionWindowSize};
 use polkadot_primitives::v2::{BlockNumber, Hash, SessionIndex, SessionInfo};
+use std::sync::Arc;

 use futures::channel::oneshot;
 use polkadot_node_subsystem::{
@@ -29,7 +34,11 @@ use polkadot_node_subsystem::{
 	overseer,
 };

+// The window size is equal to the `approval-voting` and `dispute-coordinator` constants that
+// have been obsoleted.
+const SESSION_WINDOW_SIZE: SessionWindowSize = new_session_window_size!(6);
 const LOG_TARGET: &str = "parachain::rolling-session-window";
+const STORED_ROLLING_SESSION_WINDOW: &[u8] = b"Rolling_session_window";

 /// Sessions unavailable in state to cache.
 #[derive(Debug, Clone, thiserror::Error)]
@@ -94,55 +103,176 @@ pub enum SessionWindowUpdate {
 	Unchanged,
 }

+/// A structure to store rolling session database parameters.
+#[derive(Clone)]
+pub struct DatabaseParams {
+	/// Database reference.
+	pub db: Arc<dyn Database>,
+	/// The column which stores the rolling session info.
+	pub db_column: u32,
+}
 /// A rolling window of sessions and cached session info.
 pub struct RollingSessionWindow {
 	earliest_session: SessionIndex,
 	session_info: Vec<SessionInfo>,
 	window_size: SessionWindowSize,
+	// The option is just to enable some approval-voting tests to force feed sessions
+	// in the window without dealing with the DB.
+	db_params: Option<DatabaseParams>,
+}
+
+/// The rolling session data we persist in the database.
+#[derive(Encode, Decode, Default)]
+struct StoredWindow {
+	earliest_session: SessionIndex,
+	session_info: Vec<SessionInfo>,
 }

 impl RollingSessionWindow {
 	/// Initialize a new session info cache with the given window size.
+	/// Invariant: The database always contains the earliest session. Then,
+	/// we can always extend the session info vector using chain state.
 	pub async fn new<Sender>(
 		mut sender: Sender,
-		window_size: SessionWindowSize,
 		block_hash: Hash,
+		db_params: DatabaseParams,
 	) -> Result<Self, SessionsUnavailable>
 	where
 		Sender: overseer::SubsystemSender<RuntimeApiMessage>
 			+ overseer::SubsystemSender<ChainApiMessage>,
 	{
+		// At first, determine session window start using the chain state.
 		let session_index = get_session_index_for_child(&mut sender, block_hash).await?;
 		let earliest_non_finalized_block_session =
 			Self::earliest_non_finalized_block_session(&mut sender).await?;

 		// This will increase the session window to cover the full unfinalized chain.
-		let window_start = std::cmp::min(
-			session_index.saturating_sub(window_size.get() - 1),
+		let on_chain_window_start = std::cmp::min(
+			session_index.saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
 			earliest_non_finalized_block_session,
 		);

-		match load_all_sessions(&mut sender, block_hash, window_start, session_index).await {
-			Err(kind) => Err(SessionsUnavailable {
-				kind,
-				info: Some(SessionsUnavailableInfo {
-					window_start,
-					window_end: session_index,
-					block_hash,
+		// Fetch session information from DB.
+		let maybe_stored_window = Self::db_load(db_params.clone());
+
+		// Get the DB stored sessions and recompute window start based on DB data.
+		let (mut window_start, stored_sessions) =
+			if let Some(mut stored_window) = maybe_stored_window {
+				// Check if DB is ancient.
+				if earliest_non_finalized_block_session >
+					stored_window.earliest_session + stored_window.session_info.len() as u32
+				{
+					// If ancient, we scrap it and fetch from chain state.
+					stored_window.session_info.clear();
+				}
+
+				// The session window might extend beyond the last finalized block, but that's fine as we'll prune it at
+				// next update.
+				let window_start = if stored_window.session_info.len() > 0 {
+					// If there is at least one entry in db, we always take the DB as source of truth.
+					stored_window.earliest_session
+				} else {
+					on_chain_window_start
+				};
+
+				(window_start, stored_window.session_info)
+			} else {
+				(on_chain_window_start, Vec::new())
+			};
+
+		// Compute the amount of sessions missing from the window that will be fetched from chain state.
+		let sessions_missing_count = session_index
+			.saturating_sub(window_start)
+			.saturating_add(1)
+			.saturating_sub(stored_sessions.len() as u32);
+
+		// Extend from chain state.
+		let sessions = if sessions_missing_count > 0 {
+			match extend_sessions_from_chain_state(
+				stored_sessions,
+				&mut sender,
+				block_hash,
+				&mut window_start,
+				session_index,
+			)
+			.await
+			{
+				Err(kind) => Err(SessionsUnavailable {
+					kind,
+					info: Some(SessionsUnavailableInfo {
+						window_start,
+						window_end: session_index,
+						block_hash,
+					}),
 				}),
-			}),
-			Ok(s) => Ok(Self { earliest_session: window_start, session_info: s, window_size }),
+				Ok(sessions) => Ok(sessions),
+			}?
+		} else {
+			// There are no new sessions to be fetched from chain state.
+			Vec::new()
+		};
+
+		Ok(Self {
+			earliest_session: window_start,
+			session_info: sessions,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(db_params),
+		})
+	}
+
+	// Load session information from the parachains db.
+	fn db_load(db_params: DatabaseParams) -> Option<StoredWindow> {
+		match db_params.db.get(db_params.db_column, STORED_ROLLING_SESSION_WINDOW).ok()? {
+			None => None,
+			Some(raw) => {
+				let maybe_decoded = StoredWindow::decode(&mut &raw[..]).map(Some);
+				match maybe_decoded {
+					Ok(decoded) => decoded,
+					Err(err) => {
+						gum::warn!(
+							target: LOG_TARGET,
+							?err,
+							"Failed decoding db entry; will start with onchain session infos and self-heal DB entry on next update."
+						);
+						None
+					},
+				}
+			},
+		}
+	}
+
+	// Saves/Updates all sessions in the database.
+	// TODO: https://github.com/paritytech/polkadot/issues/6144
+	fn db_save(&mut self, stored_window: StoredWindow) {
+		if let Some(db_params) = self.db_params.as_ref() {
+			match db_params.db.write(DBTransaction {
+				ops: vec![DBOp::Insert {
+					col: db_params.db_column,
+					key: DBKey::from_slice(STORED_ROLLING_SESSION_WINDOW),
+					value: stored_window.encode(),
+				}],
+			}) {
+				Ok(_) => {},
+				Err(err) => {
+					gum::warn!(target: LOG_TARGET, ?err, "Failed writing db entry");
+				},
+			}
 		}
 	}

 	/// Initialize a new session info cache with the given window size and
 	/// initial data.
+	/// This is only used in `approval voting` tests.
 	pub fn with_session_info(
-		window_size: SessionWindowSize,
 		earliest_session: SessionIndex,
 		session_info: Vec<SessionInfo>,
 	) -> Self {
-		RollingSessionWindow { earliest_session, session_info, window_size }
+		RollingSessionWindow {
+			earliest_session,
+			session_info,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: None,
+		}
 	}

 	/// Access the session info for the given session index, if stored within the window.
@@ -262,11 +392,6 @@ impl RollingSessionWindow {
 			+ overseer::SubsystemSender<ChainApiMessage>,
 	{
 		let session_index = get_session_index_for_child(sender, block_hash).await?;
-		let earliest_non_finalized_block_session =
-			Self::earliest_non_finalized_block_session(sender).await?;
-
-		let old_window_start = self.earliest_session;
-
 		let latest = self.latest_session();

 		// Either cached or ancient.
@@ -274,6 +399,10 @@ impl RollingSessionWindow {
 			return Ok(SessionWindowUpdate::Unchanged)
 		}

+		let earliest_non_finalized_block_session =
+			Self::earliest_non_finalized_block_session(sender).await?;
+
+		let old_window_start = self.earliest_session;
 		let old_window_end = latest;

 		// Ensure we keep sessions up to last finalized block by adjusting the window start.
@@ -283,16 +412,34 @@ impl RollingSessionWindow {
 			earliest_non_finalized_block_session,
 		);

-		// keep some of the old window, if applicable.
-		let overlap_start = window_start.saturating_sub(old_window_start);
+		// Never look back past earliest session, since if sessions beyond were not needed or available
+		// in the past remains valid for the future (window only advances forward).
+		let mut window_start = std::cmp::max(window_start, self.earliest_session);

-		let fresh_start = if latest < window_start { window_start } else { latest + 1 };
+		let mut sessions = self.session_info.clone();
+		let sessions_out_of_window = window_start.saturating_sub(old_window_start) as usize;

-		match load_all_sessions(sender, block_hash, fresh_start, session_index).await {
+		let sessions = if sessions_out_of_window < sessions.len() {
+			// Drop sessions based on how much the window advanced.
+			sessions.split_off((window_start as usize).saturating_sub(old_window_start as usize))
+		} else {
+			// Window has jumped such that we need to fetch all sessions from on chain.
+			Vec::new()
+		};
+
+		match extend_sessions_from_chain_state(
+			sessions,
+			sender,
+			block_hash,
+			&mut window_start,
+			session_index,
+		)
+		.await
+		{
 			Err(kind) => Err(SessionsUnavailable {
 				kind,
 				info: Some(SessionsUnavailableInfo {
-					window_start: fresh_start,
+					window_start,
 					window_end: session_index,
 					block_hash,
 				}),
@@ -305,15 +452,19 @@ impl RollingSessionWindow {
 					new_window_end: session_index,
 				};

-				let outdated = std::cmp::min(overlap_start as usize, self.session_info.len());
-				self.session_info.drain(..outdated);
-				self.session_info.extend(s);
+				self.session_info = s;
+
 				// we need to account for this case:
 				// window_start ................................... session_index
 				//              old_window_start ........... latest
 				let new_earliest = std::cmp::max(window_start, old_window_start);
 				self.earliest_session = new_earliest;

+				// Update current window in DB.
+				self.db_save(StoredWindow {
+					earliest_session: self.earliest_session,
+					session_info: self.session_info.clone(),
+				});
 				Ok(update)
 			},
 		}
@@ -354,13 +505,23 @@ async fn get_session_index_for_child(
 	}
 }

-async fn load_all_sessions(
+/// Attempts to extend db stored sessions with sessions missing between `start` and up to `end_inclusive`.
+/// Runtime session info fetching errors are ignored if that doesn't create a gap in the window.
+async fn extend_sessions_from_chain_state(
+	stored_sessions: Vec<SessionInfo>,
 	sender: &mut impl overseer::SubsystemSender<RuntimeApiMessage>,
 	block_hash: Hash,
-	start: SessionIndex,
+	window_start: &mut SessionIndex,
 	end_inclusive: SessionIndex,
 ) -> Result<Vec<SessionInfo>, SessionsUnavailableReason> {
-	let mut v = Vec::new();
+	// Start from the db sessions.
+	let mut sessions = stored_sessions;
+	// We allow session fetch failures only if we won't create a gap in the window by doing so.
+	// If `allow_failure` is set to true here, fetching errors are ignored until we get a first session.
+	let mut allow_failure = sessions.is_empty();
+
+	let start = *window_start + sessions.len() as u32;
+
 	for i in start..=end_inclusive {
 		let (tx, rx) = oneshot::channel();
 		sender
@@ -370,22 +531,58 @@ async fn load_all_sessions(
 			))
 			.await;

-		let session_info = match rx.await {
-			Ok(Ok(Some(s))) => s,
-			Ok(Ok(None)) => return Err(SessionsUnavailableReason::Missing(i)),
-			Ok(Err(e)) => return Err(SessionsUnavailableReason::RuntimeApi(e)),
-			Err(canceled) => return Err(SessionsUnavailableReason::RuntimeApiUnavailable(canceled)),
+		match rx.await {
+			Ok(Ok(Some(session_info))) => {
+				// We do not allow failure anymore after having at least 1 session in window.
+				allow_failure = false;
+				sessions.push(session_info);
+			},
+			Ok(Ok(None)) if !allow_failure => return Err(SessionsUnavailableReason::Missing(i)),
+			Ok(Ok(None)) => {
+				// Handle `allow_failure` true.
+				// If we didn't get the session, we advance window start.
+				*window_start += 1;
+				gum::debug!(
+					target: LOG_TARGET,
+					session = ?i,
+					"Session info missing from runtime."
+				);
+			},
+			Ok(Err(e)) if !allow_failure => return Err(SessionsUnavailableReason::RuntimeApi(e)),
+			Err(canceled) if !allow_failure =>
+				return Err(SessionsUnavailableReason::RuntimeApiUnavailable(canceled)),
+			Ok(Err(err)) => {
+				// Handle `allow_failure` true.
+				// If we didn't get the session, we advance window start.
+				*window_start += 1;
+				gum::debug!(
+					target: LOG_TARGET,
+					session = ?i,
+					?err,
+					"Error while fetching session information."
+				);
+			},
+			Err(err) => {
+				// Handle `allow_failure` true.
+				// If we didn't get the session, we advance window start.
+				*window_start += 1;
+				gum::debug!(
+					target: LOG_TARGET,
+					session = ?i,
+					?err,
+					"Channel error while fetching session information."
+				);
+			},
 		};
-
-		v.push(session_info);
 	}

-	Ok(v)
+	Ok(sessions)
 }

 #[cfg(test)]
 mod tests {
 	use super::*;
+	use crate::database::kvdb_impl::DbAdapter;
 	use assert_matches::assert_matches;
 	use polkadot_node_subsystem::{
 		messages::{AllMessages, AvailabilityRecoveryMessage},
@@ -395,7 +592,16 @@ mod tests {
 	use polkadot_primitives::v2::Header;
 	use sp_core::testing::TaskExecutor;

-	pub const TEST_WINDOW_SIZE: SessionWindowSize = new_session_window_size!(6);
+	const SESSION_DATA_COL: u32 = 0;
+
+	const NUM_COLUMNS: u32 = 1;
+
+	fn dummy_db_params() -> DatabaseParams {
+		let db = kvdb_memorydb::create(NUM_COLUMNS);
+		let db = DbAdapter::new(db, &[]);
+		let db: Arc<dyn Database> = Arc::new(db);
+		DatabaseParams { db, db_column: SESSION_DATA_COL }
+	}

 	fn dummy_session_info(index: SessionIndex) -> SessionInfo {
 		SessionInfo {
@@ -420,7 +626,10 @@ mod tests {
 		session: SessionIndex,
 		window: Option<RollingSessionWindow>,
 		expect_requests_from: SessionIndex,
-	) {
+		db_params: Option<DatabaseParams>,
+	) -> RollingSessionWindow {
+		let db_params = db_params.unwrap_or(dummy_db_params());
+
 		let header = Header {
 			digest: Default::default(),
 			extrinsics_root: Default::default(),
@@ -448,9 +657,8 @@ mod tests {
 		let test_fut = {
 			Box::pin(async move {
 				let window = match window {
-					None => RollingSessionWindow::new(sender.clone(), TEST_WINDOW_SIZE, hash)
-						.await
-						.unwrap(),
+					None =>
+						RollingSessionWindow::new(sender.clone(), hash, db_params).await.unwrap(),
 					Some(mut window) => {
 						window.cache_session_info_for_head(sender, hash).await.unwrap();
 						window
@@ -461,6 +669,8 @@ mod tests {
 					window.session_info,
 					(expected_start_session..=session).map(dummy_session_info).collect::<Vec<_>>(),
 				);
+
+				window
 			})
 		};

@@ -522,12 +732,43 @@ mod tests {
 			}
 		});

-		futures::executor::block_on(futures::future::join(test_fut, aux_fut));
+		let (window, _) = futures::executor::block_on(futures::future::join(test_fut, aux_fut));
+		window
+	}
+
+	#[test]
+	fn cache_session_info_start_empty_db() {
+		let db_params = dummy_db_params();
+
+		let window = cache_session_info_test(
+			(10 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			10,
+			None,
+			(10 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			Some(db_params.clone()),
+		);
+
+		let window = cache_session_info_test(
+			(11 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			11,
+			Some(window),
+			11,
+			None,
+		);
+		assert_eq!(window.session_info.len(), SESSION_WINDOW_SIZE.get() as usize);
+
+		cache_session_info_test(
+			(11 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			12,
+			None,
+			12,
+			Some(db_params),
+		);
 	}

 	#[test]
 	fn cache_session_info_first_early() {
-		cache_session_info_test(0, 1, None, 0);
+		cache_session_info_test(0, 1, None, 0, None);
 	}

 	#[test]
@@ -535,19 +776,21 @@ mod tests {
 		let window = RollingSessionWindow {
 			earliest_session: 1,
 			session_info: vec![dummy_session_info(1)],
-			window_size: TEST_WINDOW_SIZE,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(dummy_db_params()),
 		};

-		cache_session_info_test(1, 2, Some(window), 2);
+		cache_session_info_test(1, 2, Some(window), 2, None);
 	}

 	#[test]
 	fn cache_session_info_first_late() {
 		cache_session_info_test(
-			(100 as SessionIndex).saturating_sub(TEST_WINDOW_SIZE.get() - 1),
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
 			100,
 			None,
-			(100 as SessionIndex).saturating_sub(TEST_WINDOW_SIZE.get() - 1),
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			None,
 		);
 	}

@@ -560,48 +803,88 @@ mod tests {
 				dummy_session_info(51),
 				dummy_session_info(52),
 			],
-			window_size: TEST_WINDOW_SIZE,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(dummy_db_params()),
 		};

 		cache_session_info_test(
-			(100 as SessionIndex).saturating_sub(TEST_WINDOW_SIZE.get() - 1),
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
 			100,
 			Some(window),
-			(100 as SessionIndex).saturating_sub(TEST_WINDOW_SIZE.get() - 1),
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			None,
 		);
 	}

 	#[test]
 	fn cache_session_info_roll_full() {
-		let start = 99 - (TEST_WINDOW_SIZE.get() - 1);
+		let start = 99 - (SESSION_WINDOW_SIZE.get() - 1);
 		let window = RollingSessionWindow {
 			earliest_session: start,
 			session_info: (start..=99).map(dummy_session_info).collect(),
-			window_size: TEST_WINDOW_SIZE,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(dummy_db_params()),
 		};

 		cache_session_info_test(
-			(100 as SessionIndex).saturating_sub(TEST_WINDOW_SIZE.get() - 1),
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
 			100,
 			Some(window),
 			100, // should only make one request.
+			None,
 		);
 	}

 	#[test]
-	fn cache_session_info_roll_many_full() {
-		let start = 97 - (TEST_WINDOW_SIZE.get() - 1);
+	fn cache_session_info_roll_many_full_db() {
+		let db_params = dummy_db_params();
+		let start = 97 - (SESSION_WINDOW_SIZE.get() - 1);
 		let window = RollingSessionWindow {
 			earliest_session: start,
 			session_info: (start..=97).map(dummy_session_info).collect(),
-			window_size: TEST_WINDOW_SIZE,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(db_params.clone()),
 		};

 		cache_session_info_test(
-			(100 as SessionIndex).saturating_sub(TEST_WINDOW_SIZE.get() - 1),
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
 			100,
 			Some(window),
 			98,
+			None,
+		);
+
+		// We expect the session to be populated from DB, and only fetch 101 from on chain.
+		cache_session_info_test(
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			101,
+			None,
+			101,
+			Some(db_params.clone()),
+		);
+
+		// Session warps in the future.
+		let window = cache_session_info_test(195, 200, None, 195, Some(db_params));
+
+		assert_eq!(window.session_info.len(), SESSION_WINDOW_SIZE.get() as usize);
+	}
+
+	#[test]
+	fn cache_session_info_roll_many_full() {
+		let start = 97 - (SESSION_WINDOW_SIZE.get() - 1);
+		let window = RollingSessionWindow {
+			earliest_session: start,
+			session_info: (start..=97).map(dummy_session_info).collect(),
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(dummy_db_params()),
+		};
+
+		cache_session_info_test(
+			(100 as SessionIndex).saturating_sub(SESSION_WINDOW_SIZE.get() - 1),
+			100,
+			Some(window),
+			98,
+			None,
 		);
 	}

@@ -611,7 +894,8 @@ mod tests {
 		let window = RollingSessionWindow {
 			earliest_session: start,
 			session_info: (0..=1).map(dummy_session_info).collect(),
-			window_size: TEST_WINDOW_SIZE,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(dummy_db_params()),
 		};

 		cache_session_info_test(
@@ -619,6 +903,7 @@ mod tests {
 			2,
 			Some(window),
 			2, // should only make one request.
+			None,
 		);
 	}

@@ -628,14 +913,17 @@ mod tests {
 		let window = RollingSessionWindow {
 			earliest_session: start,
 			session_info: (0..=1).map(dummy_session_info).collect(),
-			window_size: TEST_WINDOW_SIZE,
+			window_size: SESSION_WINDOW_SIZE,
+			db_params: Some(dummy_db_params()),
 		};

-		cache_session_info_test(0, 3, Some(window), 2);
+		let actual_window_size = window.session_info.len() as u32;
+
+		cache_session_info_test(0, 3, Some(window), actual_window_size, None);
 	}

 	#[test]
-	fn any_session_stretch_for_unfinalized_chain() {
+	fn cache_session_fails_for_gap_in_window() {
 		// Session index of the tip of our fake test chain.
 		let session: SessionIndex = 100;
 		let genesis_session: SessionIndex = 0;
@@ -664,7 +952,8 @@ mod tests {
 		let test_fut = {
 			let sender = ctx.sender().clone();
 			Box::pin(async move {
-				let res = RollingSessionWindow::new(sender, TEST_WINDOW_SIZE, hash).await;
+				let res = RollingSessionWindow::new(sender, hash, dummy_db_params()).await;
+
 				assert!(res.is_err());
 			})
 		};
@@ -713,7 +1002,8 @@ mod tests {
 			);

 			// Unfinalized chain starts at geneisis block, so session 0 is how far we stretch.
-			for i in genesis_session..=session {
+			// First 50 sessions are missing.
+			for i in genesis_session..=50 {
 				assert_matches!(
 					handle.recv().await,
 					AllMessages::RuntimeApi(RuntimeApiMessage::Request(
@@ -722,24 +1012,46 @@ mod tests {
 					)) => {
 						assert_eq!(h, hash);
 						assert_eq!(i, j);
-
-						let _ = s_tx.send(Ok(if i == session {
-							None
-						} else {
-							Some(dummy_session_info(i))
-						}));
+						let _ = s_tx.send(Ok(None));
 					}
 				);
 			}
+			// next 10 sessions are present
+			for i in 51..=60 {
+				assert_matches!(
+					handle.recv().await,
+					AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+						h,
+						RuntimeApiRequest::SessionInfo(j, s_tx),
+					)) => {
+						assert_eq!(h, hash);
+						assert_eq!(i, j);
+						let _ = s_tx.send(Ok(Some(dummy_session_info(i))));
+					}
+				);
+			}
+			// gap of 1 session
+			assert_matches!(
+				handle.recv().await,
+				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+					h,
+					RuntimeApiRequest::SessionInfo(j, s_tx),
+				)) => {
+					assert_eq!(h, hash);
+					assert_eq!(61, j);
+					let _ = s_tx.send(Ok(None));
+				}
+			);
 		});

 		futures::executor::block_on(futures::future::join(test_fut, aux_fut));
 	}

 	#[test]
-	fn any_session_unavailable_for_caching_means_no_change() {
-		let session: SessionIndex = 6;
-		let start_session = session.saturating_sub(TEST_WINDOW_SIZE.get() - 1);
+	fn any_session_stretch_with_failure_allowed_for_unfinalized_chain() {
+		// Session index of the tip of our fake test chain.
+		let session: SessionIndex = 100;
+		let genesis_session: SessionIndex = 0;

 		let header = Header {
 			digest: Default::default(),
@@ -765,7 +1077,113 @@ mod tests {
 		let test_fut = {
 			let sender = ctx.sender().clone();
 			Box::pin(async move {
-				let res = RollingSessionWindow::new(sender, TEST_WINDOW_SIZE, hash).await;
+				let res = RollingSessionWindow::new(sender, hash, dummy_db_params()).await;
+				assert!(res.is_ok());
+				let rsw = res.unwrap();
+				// Since first 50 sessions are missing the earliest should be 50.
+				assert_eq!(rsw.earliest_session, 50);
+				assert_eq!(rsw.session_info.len(), 51);
+			})
+		};
+
+		let aux_fut = Box::pin(async move {
+			assert_matches!(
+				handle.recv().await,
+				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+					h,
+					RuntimeApiRequest::SessionIndexForChild(s_tx),
+				)) => {
+					assert_eq!(h, hash);
+					let _ = s_tx.send(Ok(session));
+				}
+			);
+
+			assert_matches!(
+				handle.recv().await,
+				AllMessages::ChainApi(ChainApiMessage::FinalizedBlockNumber(
+					s_tx,
+				)) => {
+					let _ = s_tx.send(Ok(finalized_header.number));
+				}
+			);
+
+			assert_matches!(
+				handle.recv().await,
+				AllMessages::ChainApi(ChainApiMessage::FinalizedBlockHash(
+					block_number,
+					s_tx,
+				)) => {
+					assert_eq!(block_number, finalized_header.number);
+					let _ = s_tx.send(Ok(Some(finalized_header.hash())));
+				}
+			);
+
+			assert_matches!(
+				handle.recv().await,
+				AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+					h,
+					RuntimeApiRequest::SessionIndexForChild(s_tx),
+				)) => {
+					assert_eq!(h, finalized_header.hash());
+					let _ = s_tx.send(Ok(0));
+				}
+			);
+
+			// Unfinalized chain starts at geneisis block, so session 0 is how far we stretch.
+			// We also test if failure is allowed for 50 first missing sessions.
+			for i in genesis_session..=session {
+				assert_matches!(
+					handle.recv().await,
+					AllMessages::RuntimeApi(RuntimeApiMessage::Request(
+						h,
+						RuntimeApiRequest::SessionInfo(j, s_tx),
+					)) => {
+						assert_eq!(h, hash);
+						assert_eq!(i, j);
+
+						let _ = s_tx.send(Ok(if i < 50 {
+							None
+						} else {
+							Some(dummy_session_info(i))
+						}));
+					}
+				);
+			}
+		});
+
+		futures::executor::block_on(futures::future::join(test_fut, aux_fut));
+	}
+
+	#[test]
+	fn any_session_unavailable_for_caching_means_no_change() {
+		let session: SessionIndex = 6;
+		let start_session = session.saturating_sub(SESSION_WINDOW_SIZE.get() - 1);
+
+		let header = Header {
+			digest: Default::default(),
+			extrinsics_root: Default::default(),
+			number: 5,
+			state_root: Default::default(),
+			parent_hash: Default::default(),
+		};
+
+		let finalized_header = Header {
+			digest: Default::default(),
+			extrinsics_root: Default::default(),
+			number: 0,
+			state_root: Default::default(),
+			parent_hash: Default::default(),
+		};
+
+		let pool = TaskExecutor::new();
+		let (mut ctx, mut handle) = make_subsystem_context::<(), _>(pool.clone());
+
+		let hash = header.hash();
+
+		let test_fut = {
+			let sender = ctx.sender().clone();
+			Box::pin(async move {
+				let res = RollingSessionWindow::new(sender, hash, dummy_db_params()).await;
 				assert!(res.is_err());
 			})
 		};
@@ -857,7 +1275,7 @@ mod tests {
 			Box::pin(async move {
 				let sender = ctx.sender().clone();
 				let window =
-					RollingSessionWindow::new(sender, TEST_WINDOW_SIZE, hash).await.unwrap();
+					RollingSessionWindow::new(sender, hash, dummy_db_params()).await.unwrap();

 				assert_eq!(window.earliest_session, session);
 				assert_eq!(window.session_info, vec![dummy_session_info(session)]);