Address PR feedback

Author: G8XSU

src/io/vss_store.rs

@@ -28,46 +28,42 @@ impl VssStore {
 		Self { client, store_id, runtime }
 	}
 
-	fn build_key(&self, namespace: &str, sub_namespace: &str, key: &str) -> io::Result<String> {
-		if key.is_empty() {
-			return Err(Error::new(ErrorKind::Other, "Empty key is not allowed"));
-		}
-		if namespace.is_empty() {
+	fn build_key(&self, primary_namespace: &str, secondary_namespace: &str, key: &str) -> io::Result<String> {
+		if primary_namespace.is_empty() {
 			Ok(key.to_string())
 		} else {
-			Ok(format!("{}#{}#{}", namespace, sub_namespace, key))
+			Ok(format!("{}#{}#{}", primary_namespace, secondary_namespace, key))
 		}
 	}
 
-	fn split_key(&self, key: &str) -> io::Result<(String, String, String)> {
-		let parts: Vec<&str> = key.split('#').collect();
-		match parts.as_slice() {
-			[namespace, sub_namespace, actual_key] => {
-				Ok((namespace.to_string(), sub_namespace.to_string(), actual_key.to_string()))
-			}
-			_ => Err(Error::new(ErrorKind::InvalidData, "Invalid key format")),
+	fn extract_key(&self, unified_key: &str) -> io::Result<String> {
+		let mut parts = unified_key.splitn(3, '#');
+		let (_, _) = (parts.next(), parts.next()); // Discard primary_namespace & secondary_namespace
+		match parts.next() {
+			Some(actual_key) => Ok(actual_key.to_string()),
+			None => Err(Error::new(ErrorKind::InvalidData, "Invalid key format")),
 		}
 	}
 
-	async fn list_all_keys(&self, namespace: &str, sub_namespace: &str) -> io::Result<Vec<String>> {
+	async fn list_all_keys(&self, primary_namespace: &str, secondary_namespace: &str) -> io::Result<Vec<String>> {
 		let mut page_token = None;
 		let mut keys = vec![];
-		let key_prefix = format!("{}#{}", namespace, sub_namespace);
+		let key_prefix = format!("{}#{}", primary_namespace, secondary_namespace);
 		while page_token != Some("".to_string()) {
 			let request = ListKeyVersionsRequest {
-				store_id: self.store_id.to_string(),
-				key_prefix: Some(key_prefix.to_string()),
+				store_id: self.store_id.clone(),
+				key_prefix: Some(key_prefix.clone()),
 				page_token,
 				page_size: None,
 			};
 
 			let response = self.client.list_key_versions(&request).await.map_err(|e| {
-				let msg = format!("Failed to list keys in {}/{}: {}", namespace, sub_namespace, e);
+				let msg = format!("Failed to list keys in {}/{}: {}", primary_namespace, secondary_namespace, e);
 				Error::new(ErrorKind::Other, msg)
 			})?;
 
 			for kv in response.key_versions {
-				keys.push(self.split_key(&kv.key)?.2);
+				keys.push(self.extract_key(&kv.key)?);
 			}
 			page_token = response.next_page_token;
 		}
@@ -76,11 +72,11 @@ impl VssStore {
 }
 
 impl KVStore for VssStore {
-	fn read(&self, namespace: &str, sub_namespace: &str, key: &str) -> io::Result<Vec<u8>> {
-		check_namespace_key_validity(namespace, sub_namespace, Some(key), "read")?;
+	fn read(&self, primary_namespace: &str, secondary_namespace: &str, key: &str) -> io::Result<Vec<u8>> {
+		check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "read")?;
 		let request = GetObjectRequest {
 			store_id: self.store_id.to_string(),
-			key: self.build_key(namespace, sub_namespace, key)?,
+			key: self.build_key(primary_namespace, secondary_namespace, key)?,
 		};
 
 		let resp =
@@ -89,28 +85,28 @@ impl KVStore for VssStore {
 					VssError::NoSuchKeyError(..) => {
 						let msg = format!(
 							"Failed to read as key could not be found: {}/{}/{}. Details: {}",
-							namespace, sub_namespace, key, e
+							primary_namespace, secondary_namespace, key, e
 						);
 						Error::new(ErrorKind::NotFound, msg)
 					}
 					_ => {
 						let msg = format!(
 							"Failed to read from key {}/{}/{}: {}",
-							namespace, sub_namespace, key, e
+							primary_namespace, secondary_namespace, key, e
 						);
 						Error::new(ErrorKind::Other, msg)
 					}
 				})?;
 		Ok(resp.value.unwrap().value)
 	}
 
-	fn write(&self, namespace: &str, sub_namespace: &str, key: &str, buf: &[u8]) -> io::Result<()> {
-		check_namespace_key_validity(namespace, sub_namespace, Some(key), "write")?;
+	fn write(&self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8]) -> io::Result<()> {
+		check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "write")?;
 		let request = PutObjectRequest {
 			store_id: self.store_id.to_string(),
 			global_version: None,
 			transaction_items: vec![KeyValue {
-				key: self.build_key(namespace, sub_namespace, key)?,
+				key: self.build_key(primary_namespace, secondary_namespace, key)?,
 				version: -1,
 				value: buf.to_vec(),
 			}],
@@ -121,7 +117,7 @@ impl KVStore for VssStore {
 			.map_err(|e| {
 				let msg = format!(
 					"Failed to write to key {}/{}/{}: {}",
-					namespace, sub_namespace, key, e
+					primary_namespace, secondary_namespace, key, e
 				);
 				Error::new(ErrorKind::Other, msg)
 			})?;
@@ -130,13 +126,13 @@ impl KVStore for VssStore {
 	}
 
 	fn remove(
-		&self, namespace: &str, sub_namespace: &str, key: &str, _lazy: bool,
+		&self, primary_namespace: &str, secondary_namespace: &str, key: &str, _lazy: bool,
 	) -> io::Result<()> {
-		check_namespace_key_validity(namespace, sub_namespace, Some(key), "remove")?;
+		check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "remove")?;
 		let request = DeleteObjectRequest {
 			store_id: self.store_id.to_string(),
 			key_value: Some(KeyValue {
-				key: self.build_key(namespace, sub_namespace, key)?,
+				key: self.build_key(primary_namespace, secondary_namespace, key)?,
 				version: -1,
 				value: vec![],
 			}),
@@ -145,22 +141,22 @@ impl KVStore for VssStore {
 		tokio::task::block_in_place(|| self.runtime.block_on(self.client.delete_object(&request)))
 			.map_err(|e| {
 				let msg =
-					format!("Failed to delete key {}/{}/{}: {}", namespace, sub_namespace, key, e);
+					format!("Failed to delete key {}/{}/{}: {}", primary_namespace, secondary_namespace, key, e);
 				Error::new(ErrorKind::Other, msg)
 			})?;
 		Ok(())
 	}
 
-	fn list(&self, namespace: &str, sub_namespace: &str) -> io::Result<Vec<String>> {
-		check_namespace_key_validity(namespace, sub_namespace, None, "list")?;
+	fn list(&self, primary_namespace: &str, secondary_namespace: &str) -> io::Result<Vec<String>> {
+		check_namespace_key_validity(primary_namespace, secondary_namespace, None, "list")?;
 
 		let keys = tokio::task::block_in_place(|| {
-			self.runtime.block_on(self.list_all_keys(namespace, sub_namespace))
+			self.runtime.block_on(self.list_all_keys(primary_namespace, secondary_namespace))
 		})
 		.map_err(|e| {
 			let msg = format!(
 				"Failed to retrieve keys in namespace: {}/{} : {}",
-				namespace, sub_namespace, e
+				primary_namespace, secondary_namespace, e
 			);
 			Error::new(ErrorKind::Other, msg)
 		})?;