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 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 let creating = desc
143 .iter()
144 .filter(|desc| !desc.dropped)
145 .filter(|desc| !existing.contains(desc.name));
146
147 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 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 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
275pub(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}