From 57c9f41fdfb6862882fea159b04e99408ea60815 Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Wed, 28 Dec 2022 21:07:48 -0800 Subject: [PATCH 1/8] add copy to shellchat pddb subcommand --- services/shellchat/src/cmds/pddb_cmd.rs | 63 ++++++++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index 714e4a0c6..9ce6cd875 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -157,6 +157,67 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { write!(ret, "Missing query of form 'dict:key'").unwrap(); } } + "copy" => { + if let Some(descriptor) = tokens.next() { + if let Some((dict, keyname)) = descriptor.split_once(':') { + match self.pddb.get(dict, keyname, None, + false, false, None, None::) { + Ok(mut key) => { + let mut readbuf = [0u8; 512]; // up to the first 512 chars of the key + match key.read(&mut readbuf) { + Ok(len) => { + match std::string::String::from_utf8(readbuf[..len].to_vec()) { + Ok(val) => { + if let Some(descriptor) = tokens.next() { + if let Some((dict, keyname)) = descriptor.split_once(':') { + match self.pddb.get(dict, keyname, None, + true, true, Some(256), None::) { + Ok(mut key) => { + if val.len() > 0 { + match key.write(&val.as_bytes()[..val.len()]) { + Ok(len) => { + self.pddb.sync().ok(); + write!(ret, "Copied {} bytes to {}:{}", len, dict, keyname).ok(); + } + Err(e) => { + write!(ret, "Error writing {}:{}: {:?}", dict, keyname, e).ok(); + } + } + } else { + write!(ret, "Created an empty key {}:{}", dict, keyname).ok(); + } + } + _ => write!(ret, "{}:{} not found or other error", dict, keyname).unwrap() + } + } else { + write!(ret, "Query is of form 'dict:key'").unwrap(); + } + } else { + write!(ret, "Missing query of form 'dict:key'").unwrap(); + } + } + _ => { + for &b in readbuf[..len].iter() { + match write!(ret, "{:02x} ", b) { + Ok(_) => (), + Err(_) => break, // we can overflow our return buffer returning hex chars + } + } + } + } + } + _ => write!(ret, "Error encountered reading {}:{}", dict, keyname).unwrap() + } + } + _ => write!(ret, "{}:{} not found or other error", dict, keyname).unwrap() + } + } else { + write!(ret, "Query is of form 'dict:key'").unwrap(); + } + } else { + write!(ret, "Missing query of form 'dict:key'").unwrap(); + } + } "write" => { if let Some(descriptor) = tokens.next() { if let Some((dict, keyname)) = descriptor.split_once(':') { @@ -1178,4 +1239,4 @@ fn hex(data: Vec) -> std::string::String { } s -} \ No newline at end of file +} From 6a014018e787e18e22f2ddb5df4265bf7f059ae6 Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Wed, 28 Dec 2022 21:09:21 -0800 Subject: [PATCH 2/8] add copy (and write) to the help --- services/shellchat/src/cmds/pddb_cmd.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index 9ce6cd875..064e43230 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -54,9 +54,9 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { fn process(&mut self, args: String::<1024>, _env: &mut CommonEnv) -> Result>, xous::Error> { let mut ret = String::<1024>::new(); #[cfg(not(feature="pddbtest"))] - let helpstring = "pddb [basislist] [basiscreate] [basisunlock] [basislock] [basisdelete] [default]\n[dictlist] [keylist] [query] [dictdelete] [keydelete] [churn] [flush] [sync]"; + let helpstring = "pddb [basislist] [basiscreate] [basisunlock] [basislock] [basisdelete] [default]\n[dictlist] [keylist] [write] [query] [copy] [dictdelete] [keydelete] [churn] [flush] [sync]"; #[cfg(feature="pddbtest")] - let helpstring = "pddb [basislist] [basiscreate] [basisunlock] [basislock] [basisdelete] [default]\n[dictlist] [keylist] [query] [dictdelete] [keydelete] [churn] [flush] [sync]\n[test]"; + let helpstring = "pddb [basislist] [basiscreate] [basisunlock] [basislock] [basisdelete] [default]\n[dictlist] [keylist] [write] [query] [copy] [dictdelete] [keydelete] [churn] [flush] [sync]\n[test]"; let mut tokens = args.as_str().unwrap().split(' '); if let Some(sub_cmd) = tokens.next() { From 839cf747a848d3be71d0b89331db376975426eed Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Sun, 1 Jan 2023 20:18:53 -0800 Subject: [PATCH 3/8] add "copy" that uses copy() --- services/shellchat/src/cmds/pddb_cmd.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index 064e43230..392860d12 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -158,6 +158,21 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { } } "copy" => { + if let Some(srcdescriptor) = tokens.next() { + if let Some(dstdescriptor) = tokens.next() { + write!(ret, "Will copy from {} to {}", srcdescriptor, dstdescriptor).ok(); + match std::fs::copy(srcdescriptor, dstdescriptor) { + Ok(result) => { + write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); + } + Err(e) => { + write!(ret, "Error copying from {} to {}: {:?}", srcdescriptor, dstdescriptor, e).ok(); + } + } + } + } + } + "copy2" => { if let Some(descriptor) = tokens.next() { if let Some((dict, keyname)) = descriptor.split_once(':') { match self.pddb.get(dict, keyname, None, From 38296a95103c0f7b639f3d3955878bca5114df3b Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Sun, 1 Jan 2023 21:03:39 -0800 Subject: [PATCH 4/8] remove old implementation (copy2) --- services/shellchat/src/cmds/pddb_cmd.rs | 62 ------------------------- 1 file changed, 62 deletions(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index 392860d12..b9121b5dc 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -160,7 +160,6 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { "copy" => { if let Some(srcdescriptor) = tokens.next() { if let Some(dstdescriptor) = tokens.next() { - write!(ret, "Will copy from {} to {}", srcdescriptor, dstdescriptor).ok(); match std::fs::copy(srcdescriptor, dstdescriptor) { Ok(result) => { write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); @@ -172,67 +171,6 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { } } } - "copy2" => { - if let Some(descriptor) = tokens.next() { - if let Some((dict, keyname)) = descriptor.split_once(':') { - match self.pddb.get(dict, keyname, None, - false, false, None, None::) { - Ok(mut key) => { - let mut readbuf = [0u8; 512]; // up to the first 512 chars of the key - match key.read(&mut readbuf) { - Ok(len) => { - match std::string::String::from_utf8(readbuf[..len].to_vec()) { - Ok(val) => { - if let Some(descriptor) = tokens.next() { - if let Some((dict, keyname)) = descriptor.split_once(':') { - match self.pddb.get(dict, keyname, None, - true, true, Some(256), None::) { - Ok(mut key) => { - if val.len() > 0 { - match key.write(&val.as_bytes()[..val.len()]) { - Ok(len) => { - self.pddb.sync().ok(); - write!(ret, "Copied {} bytes to {}:{}", len, dict, keyname).ok(); - } - Err(e) => { - write!(ret, "Error writing {}:{}: {:?}", dict, keyname, e).ok(); - } - } - } else { - write!(ret, "Created an empty key {}:{}", dict, keyname).ok(); - } - } - _ => write!(ret, "{}:{} not found or other error", dict, keyname).unwrap() - } - } else { - write!(ret, "Query is of form 'dict:key'").unwrap(); - } - } else { - write!(ret, "Missing query of form 'dict:key'").unwrap(); - } - } - _ => { - for &b in readbuf[..len].iter() { - match write!(ret, "{:02x} ", b) { - Ok(_) => (), - Err(_) => break, // we can overflow our return buffer returning hex chars - } - } - } - } - } - _ => write!(ret, "Error encountered reading {}:{}", dict, keyname).unwrap() - } - } - _ => write!(ret, "{}:{} not found or other error", dict, keyname).unwrap() - } - } else { - write!(ret, "Query is of form 'dict:key'").unwrap(); - } - } else { - write!(ret, "Missing query of form 'dict:key'").unwrap(); - } - } "write" => { if let Some(descriptor) = tokens.next() { if let Some((dict, keyname)) = descriptor.split_once(':') { From d8a8046521dc55d55ce498336f593bea9b6fe360 Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Sun, 1 Jan 2023 21:11:09 -0800 Subject: [PATCH 5/8] address warning (result not used in "copy") --- services/shellchat/src/cmds/pddb_cmd.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index b9121b5dc..e4832e695 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -161,7 +161,7 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { if let Some(srcdescriptor) = tokens.next() { if let Some(dstdescriptor) = tokens.next() { match std::fs::copy(srcdescriptor, dstdescriptor) { - Ok(result) => { + Ok(_result) => { write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); } Err(e) => { From 8804f7ef1747143bd00cefb51bfd1aa2fda60d59 Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Mon, 2 Jan 2023 07:15:05 -0800 Subject: [PATCH 6/8] add helpful error messages in keeping with style --- services/shellchat/src/cmds/pddb_cmd.rs | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index e4832e695..69459dcd7 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -160,15 +160,27 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { "copy" => { if let Some(srcdescriptor) = tokens.next() { if let Some(dstdescriptor) = tokens.next() { - match std::fs::copy(srcdescriptor, dstdescriptor) { - Ok(_result) => { - write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); - } - Err(e) => { - write!(ret, "Error copying from {} to {}: {:?}", srcdescriptor, dstdescriptor, e).ok(); + if let Some((_srcdict, _srckeyname)) = srcdescriptor.split_once(':') { + if let Some((_dstdict, _dstkeyname)) = dstdescriptor.split_once(':') { + match std::fs::copy(srcdescriptor, dstdescriptor) { + Ok(_result) => { + write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); + } + Err(e) => { + write!(ret, "Error copying from {} to {}: {:?}", srcdescriptor, dstdescriptor, e).ok(); + } + } + } else { + write!(ret, "Destination {} is not of required form 'dict:key'", dstdescriptor).unwrap(); } + } else { + write!(ret, "Source {} is not of required form 'dict:key'", srcdescriptor).unwrap(); } + } else { + write!(ret, "Usage is copy 'dict:key' 'dict:key' (missing destination)").unwrap(); } + } else { + write!(ret, "Usage is copy 'dict:key' 'dict:key' (missing source)").unwrap(); } } "write" => { From fb5811ddc876f35aa750e346ac956cfb0f72b67a Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Thu, 12 Jan 2023 07:20:43 -0800 Subject: [PATCH 7/8] use MAIN_SEPARATOR instead of hardcoded ':' --- services/shellchat/src/cmds/pddb_cmd.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index 69459dcd7..63319f5e2 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -160,8 +160,8 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { "copy" => { if let Some(srcdescriptor) = tokens.next() { if let Some(dstdescriptor) = tokens.next() { - if let Some((_srcdict, _srckeyname)) = srcdescriptor.split_once(':') { - if let Some((_dstdict, _dstkeyname)) = dstdescriptor.split_once(':') { + if let Some((_srcdict, _srckeyname)) = srcdescriptor.split_once(std::path::MAIN_SEPARATOR) { + if let Some((_dstdict, _dstkeyname)) = dstdescriptor.split_once(std::path::MAIN_SEPARATOR) { match std::fs::copy(srcdescriptor, dstdescriptor) { Ok(_result) => { write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); @@ -171,10 +171,10 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { } } } else { - write!(ret, "Destination {} is not of required form 'dict:key'", dstdescriptor).unwrap(); + write!(ret, "Destination {} is not of required form 'dict{}key'", dstdescriptor, std::path::MAIN_SEPARATOR).unwrap(); } } else { - write!(ret, "Source {} is not of required form 'dict:key'", srcdescriptor).unwrap(); + write!(ret, "Source {} is not of required form 'dict{}key'", srcdescriptor, std::path::MAIN_SEPARATOR).unwrap(); } } else { write!(ret, "Usage is copy 'dict:key' 'dict:key' (missing destination)").unwrap(); From 0cd20107808e37175b07dd1f673fb4ea09b9cb7a Mon Sep 17 00:00:00 2001 From: Patryk Laurent Date: Thu, 12 Jan 2023 21:12:56 -0800 Subject: [PATCH 8/8] use closure/return to avoid deep indents --- services/shellchat/src/cmds/pddb_cmd.rs | 44 ++++++++++++------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/services/shellchat/src/cmds/pddb_cmd.rs b/services/shellchat/src/cmds/pddb_cmd.rs index 63319f5e2..c1f3ee401 100644 --- a/services/shellchat/src/cmds/pddb_cmd.rs +++ b/services/shellchat/src/cmds/pddb_cmd.rs @@ -158,30 +158,30 @@ impl<'a> ShellCmdApi<'a> for PddbCmd { } } "copy" => { - if let Some(srcdescriptor) = tokens.next() { - if let Some(dstdescriptor) = tokens.next() { - if let Some((_srcdict, _srckeyname)) = srcdescriptor.split_once(std::path::MAIN_SEPARATOR) { - if let Some((_dstdict, _dstkeyname)) = dstdescriptor.split_once(std::path::MAIN_SEPARATOR) { - match std::fs::copy(srcdescriptor, dstdescriptor) { - Ok(_result) => { - write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).ok(); - } - Err(e) => { - write!(ret, "Error copying from {} to {}: {:?}", srcdescriptor, dstdescriptor, e).ok(); - } - } - } else { - write!(ret, "Destination {} is not of required form 'dict{}key'", dstdescriptor, std::path::MAIN_SEPARATOR).unwrap(); - } - } else { - write!(ret, "Source {} is not of required form 'dict{}key'", srcdescriptor, std::path::MAIN_SEPARATOR).unwrap(); - } - } else { + (|| { + let Some(srcdescriptor) = tokens.next() else { write!(ret, "Usage is copy 'dict:key' 'dict:key' (missing destination)").unwrap(); + return; + }; + let Some(dstdescriptor) = tokens.next() else { + write!(ret, "Usage is copy 'dict:key' 'dict:key' (missing source)").unwrap(); + return; + }; + if srcdescriptor.split_once(':').is_none() { + write!(ret, "Source {} is not of required form 'dict:key'", srcdescriptor).unwrap(); + return; } - } else { - write!(ret, "Usage is copy 'dict:key' 'dict:key' (missing source)").unwrap(); - } + if dstdescriptor.split_once(':').is_none() { + write!(ret, "Destination {} is not of required form 'dict:key'", dstdescriptor).unwrap(); + return; + } + if let Err(e) = std::fs::copy(srcdescriptor, dstdescriptor) { + write!(ret, "Error copying from {} to {}: {:?}", srcdescriptor, dstdescriptor, e).unwrap(); + return; + } + + write!(ret, "Copy from {} to {} succeeded", srcdescriptor, dstdescriptor).unwrap(); + })() } "write" => { if let Some(descriptor) = tokens.next() {