f Update SQLite Store

Author: tnull

lightning-persister/src/sqlite_store/mod.rs

@@ -1,4 +1,6 @@
 //! Objects related to [`SqliteStore`] live here.
+use crate::utils::check_namespace_key_validity;
+
 use lightning::util::persist::KVStore;
 use lightning::util::string::PrintableString;
 
@@ -15,7 +17,7 @@ pub const DEFAULT_SQLITE_DB_FILE_NAME: &str = "ldk_data.sqlite";
 pub const DEFAULT_KV_TABLE_NAME: &str = "ldk_data";
 
 // The current SQLite `user_version`, which we can use if we'd ever need to do a schema migration.
-const SCHEMA_USER_VERSION: u16 = 1;
+const SCHEMA_USER_VERSION: u16 = 2;
 
 /// A [`KVStore`] implementation that writes to and reads from an [SQLite] database.
 ///
@@ -56,8 +58,9 @@ impl SqliteStore {
 		let sql = format!(
 			"CREATE TABLE IF NOT EXISTS {} (
 			namespace TEXT NOT NULL,
+			sub_namespace TEXT DEFAULT \"\" NOT NULL,
 			key TEXT NOT NULL CHECK (key <> ''),
-			value BLOB, PRIMARY KEY ( namespace, key )
+			value BLOB, PRIMARY KEY ( namespace, sub_namespace, key )
 		);",
 			kv_table_name
 		);
@@ -76,27 +79,13 @@ impl SqliteStore {
 }
 
 impl KVStore for SqliteStore {
-	fn read(&self, namespace: &str, key: &str) -> std::io::Result<Vec<u8>> {
-		if key.is_empty() {
-			debug_assert!(false, "Failed to read {}/{}: key may not be empty.",
-				PrintableString(namespace), PrintableString(key));
-			let msg = format!("Failed to read {}/{}: key may not be empty.",
-				PrintableString(namespace), PrintableString(key));
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
-		}
-
-		if namespace.chars().any(|c| !c.is_ascii() || c.is_control()) ||
-			key.chars().any(|c| !c.is_ascii() || c.is_control()) {
-			debug_assert!(false, "Failed to read {}/{}: namespace and key must be valid ASCII
-				strings.", PrintableString(namespace), PrintableString(key));
-			let msg = format!("Failed to read {}/{}: namespace and key must be valid ASCII strings.",
-				PrintableString(namespace), PrintableString(key));
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
-		}
+	fn read(&self, namespace: &str, sub_namespace: &str, key: &str) -> std::io::Result<Vec<u8>> {
+		check_namespace_key_validity(namespace, sub_namespace, Some(key), "read")?;
 
 		let locked_conn = self.connection.lock().unwrap();
 		let sql =
-			format!("SELECT value FROM {} WHERE namespace=:namespace AND key=:key;", self.kv_table_name);
+			format!("SELECT value FROM {} WHERE namespace=:namespace AND sub_namespace=:sub_namespace AND key=:key;",
+			self.kv_table_name);
 
 		let mut stmt = locked_conn.prepare_cached(&sql).map_err(|e| {
 			let msg = format!("Failed to prepare statement: {}", e);
@@ -107,46 +96,35 @@ impl KVStore for SqliteStore {
 			.query_row(
 				named_params! {
 					":namespace": namespace,
+					":sub_namespace": sub_namespace,
 					":key": key,
 				},
 				|row| row.get(0),
 			)
 			.map_err(|e| match e {
 				rusqlite::Error::QueryReturnedNoRows => {
 					let msg =
-						format!("Failed to read as key could not be found: {}/{}", namespace, key);
+						format!("Failed to read as key could not be found: {}/{}/{}",
+						PrintableString(namespace), PrintableString(sub_namespace), PrintableString(key));
 					std::io::Error::new(std::io::ErrorKind::NotFound, msg)
 				}
 				e => {
-					let msg = format!("Failed to read from key {}/{}: {}", namespace, key, e);
+					let msg = format!("Failed to read from key {}/{}/{}: {}",
+						PrintableString(namespace), PrintableString(sub_namespace),
+						PrintableString(key), e);
 					std::io::Error::new(std::io::ErrorKind::Other, msg)
 				}
 			})?;
 		Ok(res)
 	}
 
-	fn write(&self, namespace: &str, key: &str, buf: &[u8]) -> std::io::Result<()> {
-		if key.is_empty() {
-			debug_assert!(false, "Failed to write {}/{}: key may not be empty.",
-				PrintableString(namespace), PrintableString(key));
-			let msg = format!("Failed to write {}/{}: key may not be empty.",
-				PrintableString(namespace), PrintableString(key));
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
-		}
-
-		if namespace.chars().any(|c| !c.is_ascii() || c.is_control()) ||
-			key.chars().any(|c| !c.is_ascii() || c.is_control()) {
-			debug_assert!(false, "Failed to write {}/{}: namespace and key must be valid ASCII
-				strings.", PrintableString(namespace), PrintableString(key));
-			let msg = format!("Failed to write {}/{}: namespace and key must be valid ASCII strings.",
-				PrintableString(namespace), PrintableString(key));
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
-		}
+	fn write(&self, namespace: &str, sub_namespace: &str, key: &str, buf: &[u8]) -> std::io::Result<()> {
+		check_namespace_key_validity(namespace, sub_namespace, Some(key), "write")?;
 
 		let locked_conn = self.connection.lock().unwrap();
 
 		let sql = format!(
-			"INSERT OR REPLACE INTO {} (namespace, key, value) VALUES (:namespace, :key, :value);",
+			"INSERT OR REPLACE INTO {} (namespace, sub_namespace, key, value) VALUES (:namespace, :sub_namespace, :key, :value);",
 			self.kv_table_name
 		);
 
@@ -158,38 +136,26 @@ impl KVStore for SqliteStore {
 		stmt.execute(
 			named_params! {
 				":namespace": namespace,
+				":sub_namespace": sub_namespace,
 				":key": key,
 				":value": buf,
 			},
 			)
 			.map(|_| ())
 			.map_err(|e| {
-				let msg = format!("Failed to write to key {}/{}: {}", namespace, key, e);
+				let msg = format!("Failed to write to key {}/{}/{}: {}",
+					PrintableString(namespace), PrintableString(sub_namespace),
+					PrintableString(key), e);
 				std::io::Error::new(std::io::ErrorKind::Other, msg)
 			})
 	}
 
-	fn remove(&self, namespace: &str, key: &str) -> lightning::io::Result<()> {
-		if key.is_empty() {
-			debug_assert!(false, "Failed to remove {}/{}: key may not be empty.",
-				PrintableString(namespace), PrintableString(key));
-			let msg = format!("Failed to remove {}/{}: key may not be empty.",
-				PrintableString(namespace), PrintableString(key));
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
-		}
-
-		if namespace.chars().any(|c| !c.is_ascii() || c.is_control()) ||
-			key.chars().any(|c| !c.is_ascii() || c.is_control()) {
-			debug_assert!(false, "Failed to remove {}/{}: namespace and key must be valid ASCII
-				strings.", PrintableString(namespace), PrintableString(key));
-			let msg = format!("Failed to remove {}/{}: namespace and key must be valid ASCII strings.",
-				PrintableString(namespace), PrintableString(key));
-			return Err(std::io::Error::new(std::io::ErrorKind::Other, msg));
-		}
+	fn remove(&self, namespace: &str, sub_namespace: &str, key: &str, lazy: bool) -> std::io::Result<()> {
+		check_namespace_key_validity(namespace, sub_namespace, Some(key), "remove")?;
 
 		let locked_conn = self.connection.lock().unwrap();
 
-		let sql = format!("DELETE FROM {} WHERE namespace=:namespace AND key=:key;", self.kv_table_name);
+		let sql = format!("DELETE FROM {} WHERE namespace=:namespace AND sub_namespace=:sub_namespace AND key=:key;", self.kv_table_name);
 
 		let mut stmt = locked_conn.prepare_cached(&sql).map_err(|e| {
 			let msg = format!("Failed to prepare statement: {}", e);
@@ -199,20 +165,25 @@ impl KVStore for SqliteStore {
 		stmt.execute(
 			named_params! {
 				":namespace": namespace,
+				":sub_namespace": sub_namespace,
 				":key": key,
 			},
 			)
 			.map_err(|e| {
-				let msg = format!("Failed to delete key {}/{}: {}", namespace, key, e);
+				let msg = format!("Failed to delete key {}/{}/{}: {}",
+					PrintableString(namespace), PrintableString(sub_namespace),
+					PrintableString(key), e);
 				std::io::Error::new(std::io::ErrorKind::Other, msg)
 			})?;
 		Ok(())
 	}
 
-	fn list(&self, namespace: &str) -> std::io::Result<Vec<String>> {
+	fn list(&self, namespace: &str, sub_namespace: &str) -> std::io::Result<Vec<String>> {
+		check_namespace_key_validity(namespace, sub_namespace, None, "list")?;
+
 		let locked_conn = self.connection.lock().unwrap();
 
-		let sql = format!("SELECT key FROM {} WHERE namespace=:namespace", self.kv_table_name);
+		let sql = format!("SELECT key FROM {} WHERE namespace=:namespace AND sub_namespace=:sub_namespace", self.kv_table_name);
 		let mut stmt = locked_conn.prepare_cached(&sql).map_err(|e| {
 			let msg = format!("Failed to prepare statement: {}", e);
 			std::io::Error::new(std::io::ErrorKind::Other, msg)
@@ -221,7 +192,11 @@ impl KVStore for SqliteStore {
 		let mut keys = Vec::new();
 
 		let rows_iter = stmt
-			.query_map(named_params! {":namespace": namespace, }, |row| row.get(0))
+			.query_map(
+				named_params! {
+					":namespace": namespace,
+					":sub_namespace": sub_namespace,
+			}, |row| row.get(0))
 			.map_err(|e| {
 				let msg = format!("Failed to retrieve queried rows: {}", e);
 				std::io::Error::new(std::io::ErrorKind::Other, msg)