Skip to main content

tuwunel_database/engine/
open.rs

1use std::{
2	collections::BTreeSet,
3	fs::read_dir,
4	path::Path,
5	sync::{Arc, OnceLock, atomic::AtomicU32},
6};
7
8use rocksdb::{ColumnFamilyDescriptor, Options, WriteOptions};
9use tuwunel_core::{
10	Result, debug, debug_warn, err, error, implement, info, itertools::Itertools, trace, warn,
11};
12
13use super::{
14	Db, Engine, backup::restore, cf_opts::cf_options, context, db_opts::db_options, descriptor,
15	descriptor::Descriptor, repair::repair,
16};
17use crate::{Context, or_else};
18
19#[implement(Engine)]
20#[tracing::instrument(skip_all)]
21pub(crate) async fn open(ctx: Arc<Context>, desc: &[Descriptor]) -> Result<Arc<Self>> {
22	let server = &ctx.server;
23	let config = &server.config;
24	let path = &config.database_path;
25
26	context::before_open(&ctx, path)?;
27
28	if let Some(backup_id) = config.database_restore_backup {
29		match server.claim_backup_restore() {
30			| true => restore(&ctx, backup_id)?,
31			| false => {
32				info!(%backup_id, "Restore already claimed by this process; not restoring again");
33			},
34		}
35	}
36
37	let db_opts = db_options(
38		config,
39		&ctx.env.lock().expect("environment locked"),
40		&ctx.row_cache.lock().expect("row cache locked"),
41	)?;
42
43	let (cfds, dropped) = Self::configure_cfds(&ctx, &db_opts, desc)?;
44	let num_cfds = cfds.len();
45	debug!("Configured {num_cfds} column descriptors...");
46
47	let load_time = std::time::Instant::now();
48
49	if config.rocksdb.repair {
50		repair(&db_opts, &config.database_path)?;
51	}
52
53	debug!("Opening database...");
54	let db = match () {
55		| () if config.rocksdb.read_only =>
56			Db::open_cf_descriptors_read_only(&db_opts, path, cfds, false),
57		| () if config.rocksdb.secondary =>
58			Db::open_cf_descriptors_as_secondary(&db_opts, path, path, cfds),
59		| () => Db::open_cf_descriptors(&db_opts, path, cfds),
60	}
61	.or_else(or_else)?;
62
63	if !config.rocksdb.read_only && !config.rocksdb.secondary {
64		drop_columns(dropped.iter().map(String::as_str), |name| {
65			db.drop_cf(name).or_else(or_else)
66		})?;
67	}
68
69	info!(
70		columns = num_cfds,
71		sequence = %db.latest_sequence_number(),
72		time = ?load_time.elapsed(),
73		"Opened database."
74	);
75
76	Ok(Arc::new(Self {
77		db,
78		pool: ctx.pool.clone(),
79		ctx: ctx.clone(),
80		read_only: config.rocksdb.read_only,
81		secondary: config.rocksdb.secondary,
82		checksums: config.rocksdb.checksums,
83		write_options: WriteOptions::default(),
84		cf_index: OnceLock::new(),
85		corks: AtomicU32::new(0),
86	}))
87}
88
89pub(super) fn drop_columns<N>(
90	names: impl IntoIterator<Item = N>,
91	mut drop: impl FnMut(&str) -> Result,
92) -> Result
93where
94	N: AsRef<str>,
95{
96	let failed = names
97		.into_iter()
98		.filter(|name| {
99			let name = name.as_ref();
100			debug!(%name, "Deleting dropped database column");
101
102			drop(name)
103				.inspect_err(|error| {
104					error!(%name, ?error, "Failed to delete dropped database column");
105				})
106				.is_err()
107		})
108		.collect::<Vec<_>>();
109
110	failed.is_empty().then_some(()).ok_or_else(|| {
111		err!(Database(
112			"Failed to delete {} dropped database columns: {}",
113			failed.len(),
114			failed
115				.iter()
116				.map(|name: &N| name.as_ref())
117				.format(", ")
118		))
119	})
120}
121
122#[implement(Engine)]
123#[tracing::instrument(name = "configure", skip_all)]
124fn configure_cfds(
125	ctx: &Arc<Context>,
126	db_opts: &Options,
127	desc: &[Descriptor],
128) -> Result<(Vec<ColumnFamilyDescriptor>, Vec<String>)> {
129	let server = &ctx.server;
130	let config = &server.config;
131	let path = &config.database_path;
132	let existing = Self::discover_cfs(path, db_opts)?;
133
134	// Found columns which are not described.
135	let missing = existing
136		.iter()
137		.map(String::as_str)
138		.filter(|&name| name != "default")
139		.filter(|&name| !desc.iter().any(|desc| desc.name == name));
140
141	// Described columns which are not found.
142	let creating = desc
143		.iter()
144		.filter(|desc| !desc.dropped)
145		.filter(|desc| !existing.contains(desc.name));
146
147	// Found columns which are described as dropped.
148	let dropping = desc
149		.iter()
150		.filter(|desc| desc.dropped)
151		.filter(|desc| existing.contains(desc.name))
152		.filter(|_| !config.rocksdb.never_drop_columns);
153
154	// Described dropped columns which are no longer found.
155	let dropped = desc
156		.iter()
157		.filter(|desc| desc.dropped)
158		.filter(|desc| !existing.contains(desc.name));
159
160	debug!(
161		existing = existing.len(),
162		described = desc.len(),
163		missing = missing.clone().count(),
164		dropped = dropped.clone().count(),
165		creating = creating.clone().count(),
166		dropping = dropping.clone().count(),
167		"Discovered database columns"
168	);
169
170	missing.clone().for_each(|name| {
171		debug_warn!("Found undescribed column {name:?} in existing database.");
172	});
173
174	dropped
175		.clone()
176		.map(|desc| desc.name)
177		.for_each(|name| {
178			debug!("Previously dropped column {name:?} no longer found in database.");
179		});
180
181	creating
182		.clone()
183		.map(|desc| desc.name)
184		.for_each(|name| {
185			debug!("Creating new column {name:?} not previously found in existing database.");
186		});
187
188	dropping
189		.clone()
190		.map(|desc| desc.name)
191		.for_each(|name| {
192			warn!(
193				"Column {name:?} has been scheduled for deletion. Storage may not appear \
194				 reclaimed until further restart or compaction."
195			);
196		});
197
198	let not_dropped = |desc: &&Descriptor| {
199		!dropped
200			.clone()
201			.any(|dropped| desc.name == dropped.name)
202	};
203
204	// RocksDB cannot create column families in read-only or secondary mode.
205	let read_only = config.rocksdb.read_only || config.rocksdb.secondary;
206	let openable = |desc: &&Descriptor| !read_only || existing.contains(desc.name);
207
208	let dropping = dropping
209		.map(|desc| desc.name)
210		.map(ToOwned::to_owned)
211		.collect();
212
213	let cfnames = desc
214		.iter()
215		.filter(not_dropped)
216		.filter(openable)
217		.map(|desc| desc.name)
218		.chain(missing.clone());
219
220	let cfds: Vec<_> = desc
221		.iter()
222		.filter(not_dropped)
223		.filter(openable)
224		.copied()
225		.chain(missing.map(|_| descriptor::IGNORED))
226		.zip(cfnames)
227		.inspect(|&(desc, name)| {
228			assert!(
229				desc.ignored || desc.name == name,
230				"{name:?} does not match descriptor {:?}",
231				desc.name
232			);
233		})
234		.inspect(|&(_, name)| debug!(name, "Described column"))
235		.map(|(desc, name)| (desc, name.to_owned()))
236		.map(|(desc, name)| Ok((name, cf_options(ctx, db_opts.clone(), &desc)?)))
237		.map_ok(|(name, opts)| ColumnFamilyDescriptor::new(name, opts))
238		.collect::<Result<_>>()?;
239
240	trace!(?dropping);
241	Ok((cfds, dropping))
242}
243
244#[implement(Engine)]
245#[tracing::instrument(name = "discover", skip_all)]
246fn discover_cfs(path: &Path, opts: &Options) -> Result<BTreeSet<String>> {
247	Db::list_cf(opts, path)
248		.map(|cfs| cfs.into_iter().collect())
249		.or_else(|e| {
250			let remnants = count_remnants(path);
251
252			remnants
253				.eq(&0)
254				.then(BTreeSet::new)
255				.ok_or_else(|| {
256					err!(Database(
257						"Found {remnants} database files in {path:?} but no readable manifest: \
258						 {e}. Refusing to initialize a new database over existing data; restore \
259						 a complete database copy including CURRENT and MANIFEST, or remove the \
260						 remnants to start fresh."
261					))
262				})
263		})
264}
265
266fn count_remnants(path: &Path) -> usize {
267	read_dir(path)
268		.into_iter()
269		.flatten()
270		.filter_map(Result::ok)
271		.filter(|entry| entry.file_name().to_str().is_some_and(is_remnant))
272		.count()
273}
274
275/// Database files a fresh initialization would silently destroy.
276pub(super) fn is_remnant(name: &str) -> bool {
277	let numbered = |suffix| {
278		name.strip_suffix(suffix)
279			.is_some_and(|stem| !stem.is_empty() && stem.bytes().all(|b| b.is_ascii_digit()))
280	};
281
282	name == "CURRENT" || name.starts_with("MANIFEST-") || numbered(".sst") || numbered(".log")
283}