remove useless patches (#742)

MarinPostma · web-flow · commit af93298cc344 · 2023-10-06T10:27:01.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,5 +1,6 @@
 [workspace]
 
+resolver = "2"
 members = [
     "bottomless",
     "bottomless-cli",
@@ -33,12 +34,8 @@ publish-jobs = ["homebrew"]
 # Whether cargo-dist should create a Github Release or use an existing draft
 create-release = false
 
-# TODO(lucio): Remove this once tonic has released a new version with fixes
 [patch.crates-io]
-tonic = { git = "https://github.com/hyperium/tonic" }
-tonic-build = { git = "https://github.com/hyperium/tonic" }
-console-api = { git = "https://github.com/tokio-rs/console", branch = "lucio/tonic-fix" }
-libsql = { git = "https://github.com/libsql/libsql.git", rev = "61b4f5b" }
+sqlite3-parser = { git = "https://github.com/LucioFranco/lemon-rs" }
 
 # The profile that 'cargo dist' will build with
 [profile.dist]
diff --git a/bottomless/src/lib.rs b/bottomless/src/lib.rs
@@ -583,7 +583,9 @@ pub mod static_init {
         INIT.call_once(|| {
             crate::bottomless_init();
             let orig_methods = unsafe { libsql_wal_methods_find(std::ptr::null()) };
-            if orig_methods.is_null() {}
+            if orig_methods.is_null() {
+                panic!("failed to locate default WAL methods")
+            }
             let methods = crate::bottomless_methods(orig_methods);
             let rc = unsafe { libsql_wal_methods_register(methods) };
             if rc != crate::ffi::SQLITE_OK {
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
 profile = "default"
-channel = "1.70.0"
+channel = "1.73.0"
diff --git a/sqld/Cargo.toml b/sqld/Cargo.toml
@@ -70,7 +70,7 @@ hyper-rustls = { git = "https://github.com/rustls/hyper-rustls.git", rev = "163b
 rustls-pemfile = "1.0.3"
 rustls = "0.21.7"
 async-stream = "0.3.5"
-libsql = { version = "0.1", optional = true }
+libsql = { git = "https://github.com/tursodatabase/libsql.git", rev = "bea8863", optional = true }
 
 [dev-dependencies]
 proptest = "1.0.0"
diff --git a/sqld/src/auth.rs b/sqld/src/auth.rs
@@ -79,13 +79,13 @@ impl Auth {
         }
 
         let Some(auth_header) = auth_header else {
-            return Err(AuthError::HttpAuthHeaderMissing)
+            return Err(AuthError::HttpAuthHeaderMissing);
         };
 
         match parse_http_auth_header(auth_header)? {
             HttpAuthHeader::Basic(actual_value) => {
                 let Some(expected_value) = self.http_basic.as_ref() else {
-                    return Err(AuthError::BasicNotAllowed)
+                    return Err(AuthError::BasicNotAllowed);
                 };
                 // NOTE: this naive comparison may leak information about the `expected_value`
                 // using a timing attack
@@ -133,7 +133,7 @@ impl Auth {
         }
 
         let Some(jwt) = jwt else {
-            return Err(AuthError::JwtMissing)
+            return Err(AuthError::JwtMissing);
         };
 
         self.validate_jwt(jwt, disable_namespaces)
@@ -145,7 +145,7 @@ impl Auth {
         disable_namespaces: bool,
     ) -> Result<Authenticated, AuthError> {
         let Some(jwt_key) = self.jwt_key.as_ref() else {
-            return Err(AuthError::JwtNotAllowed)
+            return Err(AuthError::JwtNotAllowed);
         };
         validate_jwt(jwt_key, jwt, disable_namespaces)
     }
@@ -250,11 +250,11 @@ fn parse_http_auth_header(
     header: &hyper::header::HeaderValue,
 ) -> Result<HttpAuthHeader, AuthError> {
     let Ok(header) = header.to_str() else {
-        return Err(AuthError::HttpAuthHeaderInvalid)
+        return Err(AuthError::HttpAuthHeaderInvalid);
     };
 
     let Some((scheme, param)) = header.split_once(' ') else {
-        return Err(AuthError::HttpAuthHeaderInvalid)
+        return Err(AuthError::HttpAuthHeaderInvalid);
     };
 
     if scheme.eq_ignore_ascii_case("basic") {
diff --git a/sqld/src/connection/dump/exporter.rs b/sqld/src/connection/dump/exporter.rs
@@ -24,9 +24,15 @@ impl<W: Write> DumpState<W> {
         let mut stmt = txn.prepare(stmt)?;
         let mut rows = stmt.query(())?;
         while let Some(row) = rows.next()? {
-            let ValueRef::Text(table) = row.get_ref(0)? else { bail!("invalid schema table") };
-            let ValueRef::Text(ty) = row.get_ref(1)? else { bail!("invalid schema table") };
-            let ValueRef::Text(sql) = row.get_ref(2)? else { bail!("invalid schema table") };
+            let ValueRef::Text(table) = row.get_ref(0)? else {
+                bail!("invalid schema table")
+            };
+            let ValueRef::Text(ty) = row.get_ref(1)? else {
+                bail!("invalid schema table")
+            };
+            let ValueRef::Text(sql) = row.get_ref(2)? else {
+                bail!("invalid schema table")
+            };
 
             if table == b"sqlite_sequence" {
                 writeln!(self.writer, "DELETE FROM sqlite_sequence;")?;
@@ -120,10 +126,14 @@ impl<W: Write> DumpState<W> {
         let col_count = stmt.column_count();
         let mut rows = stmt.query(())?;
         while let Some(row) = rows.next()? {
-            let ValueRef::Text(sql) = row.get_ref(0)? else { bail!("the first row in a table dump query should be of type text") };
+            let ValueRef::Text(sql) = row.get_ref(0)? else {
+                bail!("the first row in a table dump query should be of type text")
+            };
             self.writer.write_all(sql)?;
             for i in 1..col_count {
-                let ValueRef::Text(s) = row.get_ref(i)? else { bail!("row {i} in table dump query should be of type text") };
+                let ValueRef::Text(s) = row.get_ref(i)? else {
+                    bail!("row {i} in table dump query should be of type text")
+                };
                 let s = std::str::from_utf8(s)?;
                 write!(self.writer, ",{s}")?;
             }
@@ -258,7 +268,7 @@ impl Display for Quoted<'_> {
         let s = &self.0;
         let Some(first) = s.chars().next() else {
             write!(f, "{s}")?;
-            return Ok(())
+            return Ok(());
         };
         if !first.is_alphabetic() && first != '_' {
             write!(f, r#""{s}""#)?;
diff --git a/sqld/src/hrana/cursor.rs b/sqld/src/hrana/cursor.rs
@@ -78,9 +78,7 @@ async fn run_cursor<C: Connection>(
     open_rx: oneshot::Receiver<OpenReq<C>>,
     entry_tx: mpsc::Sender<Result<SizedEntry>>,
 ) {
-    let Ok(open_req) = open_rx.await else {
-        return
-    };
+    let Ok(open_req) = open_rx.await else { return };
 
     let result_builder = CursorResultBuilder {
         entry_tx: entry_tx.clone(),
diff --git a/sqld/src/hrana/http/stream.rs b/sqld/src/hrana/http/stream.rs
@@ -142,7 +142,8 @@ pub async fn acquire<'srv, D: Connection>(
                 }
             };
 
-            let Handle::Available(mut stream) = mem::replace(handle.unwrap(), Handle::Acquired) else {
+            let Handle::Available(mut stream) = mem::replace(handle.unwrap(), Handle::Acquired)
+            else {
                 unreachable!()
             };
 
@@ -235,8 +236,10 @@ impl<'srv, D> Drop for Guard<'srv, D> {
 
         let mut state = self.server.stream_state.lock();
         let Some(handle) = state.handles.remove(&stream_id) else {
-            panic!("Dropped a Guard for stream {stream_id}, \
-                but Server does not contain a handle to it");
+            panic!(
+                "Dropped a Guard for stream {stream_id}, \
+                but Server does not contain a handle to it"
+            );
         };
         if !matches!(handle, Handle::Acquired) {
             panic!(
diff --git a/sqld/src/hrana/ws/handshake.rs b/sqld/src/hrana/ws/handshake.rs
@@ -153,7 +153,10 @@ fn negotiate_subproto(
                 .map(|s| s.as_str())
                 .collect::<Vec<_>>()
                 .join(" ");
-            return Err(format!("Only these WebSocket subprotocols are supported: {}", supported))
+            return Err(format!(
+                "Only these WebSocket subprotocols are supported: {}",
+                supported
+            ));
         };
 
         tracing::debug!(
diff --git a/sqld/src/hrana/ws/session.rs b/sqld/src/hrana/ws/session.rs
@@ -379,7 +379,7 @@ pub(super) async fn handle_request<F: MakeNamespace>(
                 while entries.len() < max_count && total_size < max_total_size {
                     let Some(sized_entry) = cursor_hnd.fetch().await? else {
                         done = true;
-                        break
+                        break;
                     };
                     entries.push(sized_entry.entry);
                     total_size += sized_entry.size;
diff --git a/sqld/src/namespace/mod.rs b/sqld/src/namespace/mod.rs
@@ -991,7 +991,9 @@ async fn run_storage_monitor(db_path: PathBuf, stats: Weak<Stats>) -> anyhow::Re
     let db_path: Arc<Path> = db_path.into();
     loop {
         let db_path = db_path.clone();
-        let Some(stats) = stats.upgrade() else { return Ok(()) };
+        let Some(stats) = stats.upgrade() else {
+            return Ok(());
+        };
         let _ = tokio::task::spawn_blocking(move || {
             // because closing the last connection interferes with opening a new one, we lazily
             // initialize a connection here, and keep it alive for the entirety of the program. If we
diff --git a/sqld/src/replication/primary/logger.rs b/sqld/src/replication/primary/logger.rs
@@ -940,7 +940,7 @@ impl ReplicationLogger {
             let mut frames_iter = log_file.rev_frames_iter()?;
             let Some(last_frame_res) = frames_iter.next() else {
                 // the log file is empty, nothing to compact
-                return Ok(false)
+                return Ok(false);
             };
             last_frame_res?
         };
diff --git a/sqld/src/replication/replica/replicator.rs b/sqld/src/replication/replica/replicator.rs
@@ -107,7 +107,6 @@ impl Replicator {
 
         let (snd, rcv) = oneshot::channel();
         let handle = BLOCKING_RT.spawn_blocking({
-            let db_path = db_path;
             move || -> anyhow::Result<()> {
                 let ctx = InjectorHookCtx::new(receiver, pre_commit, post_commit);
                 let mut injector = FrameInjector::new(&db_path, ctx)?;
diff --git a/sqld/src/replication/snapshot.rs b/sqld/src/replication/snapshot.rs
@@ -56,17 +56,19 @@ pub struct SnapshotFile {
 fn parse_snapshot_name(name: &str) -> Option<(Uuid, u64, u64)> {
     static SNAPSHOT_FILE_MATCHER: Lazy<Regex> = Lazy::new(|| {
         Regex::new(
-            r#"(?x)
+            r"(?x)
             # match database id
             (\w{8}-\w{4}-\w{4}-\w{4}-\w{12})-
             # match start frame_no
             (\d*)-
             # match end frame_no
-            (\d*).snap"#,
+            (\d*).snap",
         )
         .unwrap()
     });
-    let Some(captures) = SNAPSHOT_FILE_MATCHER.captures(name) else { return None};
+    let Some(captures) = SNAPSHOT_FILE_MATCHER.captures(name) else {
+        return None;
+    };
     let db_id = captures.get(1).unwrap();
     let start_index: u64 = captures.get(2).unwrap().as_str().parse().unwrap();
     let end_index: u64 = captures.get(3).unwrap().as_str().parse().unwrap();
@@ -82,10 +84,16 @@ fn snapshot_list(db_path: &Path) -> anyhow::Result<impl Iterator<Item = String>>
     let mut entries = std::fs::read_dir(snapshot_dir_path(db_path))?;
     Ok(std::iter::from_fn(move || {
         for entry in entries.by_ref() {
-            let Ok(entry) = entry else { continue; };
+            let Ok(entry) = entry else {
+                continue;
+            };
             let path = entry.path();
-            let Some(name) = path.file_name() else {continue;};
-            let Some(name_str) = name.to_str() else { continue;};
+            let Some(name) = path.file_name() else {
+                continue;
+            };
+            let Some(name_str) = name.to_str() else {
+                continue;
+            };
 
             return Some(name_str.to_string());
         }
@@ -100,7 +108,9 @@ pub fn find_snapshot_file(
 ) -> anyhow::Result<Option<SnapshotFile>> {
     let snapshot_dir_path = snapshot_dir_path(db_path);
     for name in snapshot_list(db_path)? {
-        let Some((_, start_frame_no, end_frame_no)) = parse_snapshot_name(&name) else { continue; };
+        let Some((_, start_frame_no, end_frame_no)) = parse_snapshot_name(&name) else {
+            continue;
+        };
         // we're looking for the frame right after the last applied frame on the replica
         if (start_frame_no..=end_frame_no).contains(&frame_no) {
             let snapshot_path = snapshot_dir_path.join(&name);
diff --git a/sqld/tests/cluster.rs b/sqld/tests/cluster.rs
@@ -6,7 +6,7 @@ mod test {
 
     use super::common;
 
-    use libsql::{hrana::HranaError, Database, Value};
+    use libsql::{Database, Value};
     use serde_json::json;
     use sqld::config::{AdminApiConfig, RpcClientConfig, RpcServerConfig, UserApiConfig};
     use tempfile::tempdir;
@@ -215,9 +215,13 @@ mod test {
             )?;
             let conn = db.connect()?;
 
-            let Err(e) = conn.execute("create table test (x)", ()).await else { panic!() };
-            let libsql::Error::Hrana(HranaError::Api(msg)) = e else { panic!() };
-            assert_eq!(msg, "{\"error\":\"Namespace `foo` doesn't exist\"}");
+            let Err(e) = conn.execute("create table test (x)", ()).await else {
+                panic!()
+            };
+            assert_eq!(
+                e.to_string(),
+                "Hrana: `api error: `{\"error\":\"Namespace `foo` doesn't exist\"}``"
+            );
 
             let client = Client::new();
             let resp = client
