ci: update Rust to 1.99.0

RPC server subprocess may exit for various reasons,
e.g. because of panic or because of debug_assert! during testing,
or because the process is killed manually or by OOM killer.

We still want to shutdown all threads cleanly in this case
and not fail in Rpc.close(). Otherwise Python process cannot exit
as it waits forever for all threads to terminate.

Without the fix, when added test is run in pytest,
pytest prints "ERROR at teardown of test_shutdown" and gets stuck.
When pytest is manually terminated with ^C, the following error is printed:

```
Exception ignored while joining a thread in _thread._shutdown():
Traceback (most recent call last):
  File "/usr/lib/python3.14/threading.py", line 1583, in _shutdown
    _thread_shutdown()
KeyboardInterrupt:
```

_thread_shutdown() is the function waiting for all non-daemon threads to finish.

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ permissions: {}
 
 env:
   RUSTFLAGS: -Dwarnings
-  RUST_VERSION: 1.98.1
+  RUST_VERSION: 1.99.0
 
   # Minimum Supported Rust Version
   MSRV: 1.89.0

Cargo.lock

@@ -194,9 +194,9 @@ dependencies = [
 
 [[package]]
 name = "astral-tokio-tar"
-version = "0.6.4"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b18457efd137254e016bbde5e1d88df61c4e1a5ae2223746e56123bac6af2463"
+checksum = "6f2e989b33246fe9240d39accf4dd9a01e0b6c1f3ce9dd095e0a47fa02505523"
 dependencies = [
  "futures-core",
  "libc",
@@ -205,6 +205,7 @@ dependencies = [
  "rustix 1.1.4",
  "tokio",
  "tokio-stream",
+ "zerocopy 0.8.59",
 ]
 
 [[package]]
@@ -4595,7 +4596,7 @@ version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
@@ -5812,7 +5813,7 @@ dependencies = [
  "sha3",
  "signature",
  "typenum",
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
@@ -7582,7 +7583,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
  "byteorder",
- "zerocopy-derive",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb"
+dependencies = [
+ "zerocopy-derive 0.8.59",
 ]
 
 [[package]]
@@ -7596,6 +7606,17 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "zerofrom"
 version = "0.1.5"

Cargo.toml

@@ -100,7 +100,7 @@ thiserror = { workspace = true }
 tokio-io-timeout = "1.2.1"
 tokio-rustls = { version = "0.26.2", default-features = false, features = ["tls12", "brotli"] }
 tokio-stream = { version = "0.1.17", features = ["fs"] }
-astral-tokio-tar = { version = "0.6.3", default-features = false }
+astral-tokio-tar = { version = "0.7.0", default-features = false }
 tokio-util = { workspace = true }
 tokio = { workspace = true, features = ["fs", "rt-multi-thread", "macros"] }
 toml = "0.9"

deltachat-rpc-client/src/deltachat_rpc_client/rpc.py

@@ -149,7 +149,10 @@ class Rpc:
     def close(self) -> None:
         """Terminate RPC server process and wait until the reader loop finishes."""
         self.closing = True
-        self.stop_io_for_all_accounts()
+        # JSON-RPC error may happen if RPC server process has crashed already.
+        # We still want to shutdown all threads in this case.
+        with contextlib.suppress(JsonRpcError):
+            self.stop_io_for_all_accounts()
         # Let `events_loop` stop cleanly on `closing` before the pipe goes away,
         # otherwise it might exit through an "RPC server closed" error instead.
         self.events_thread.join()

deltachat-rpc-client/tests/test_something.py

@@ -35,6 +35,19 @@ def test_sleep(rpc) -> None:
         assert sleep_5_future in pending
 
 
+def test_shutdown(rpc) -> None:
+    """Test RPC client shutdown if RPC server process is terminated.
+
+    This is a regression test, at the time of adding it RPC client
+    did not terminate all threads and python process did not exit.
+    Shutting down all threads is tested implicitly by pytest-timeout.
+    """
+    rpc.process.kill()
+    rpc.process.wait()
+    with pytest.raises(JsonRpcError):
+        rpc.get_system_info()
+
+
 def test_email_address_validity(rpc) -> None:
     valid_addresses = [
         "email@example.com",

deny.toml

@@ -113,6 +113,8 @@ skip = [
      { name = "windows_x86_64_gnu" },
      { name = "windows_x86_64_gnullvm" },
      { name = "windows_x86_64_msvc" },
+     { name = "zerocopy-derive", version = "0.7.35" },
+     { name = "zerocopy", version = "0.7.35" },
 ]
 
 

src/blob.rs

@@ -350,24 +350,7 @@ impl<'a> BlobObject<'a> {
                 *vt = Viewtype::Image;
                 return Ok(name);
             }
-
-            let mut img = match fmt {
-                image::ImageFormat::WebP => {
-                    // `with_guessed_format()` restores file position,
-                    // so `buf_reader` is at the beginning of the file.
-                    let buf_reader = imgreader.into_inner();
-                    let webp_decoder = image::codecs::webp::WebPDecoder::new(buf_reader)
-                        .context("Failed to create WebP decoder")?;
-
-                    // If WebP has animation, do not try to recode it.
-                    // Recoding into JPEG will result in losing the animation.
-                    if !is_avatar && webp_decoder.has_animation() {
-                        return Ok(name);
-                    }
-                    DynamicImage::from_decoder(webp_decoder)?
-                }
-                _ => imgreader.decode().context("Failed to decode image")?,
-            };
+            let mut img = imgreader.decode().context("image decode failure")?;
             let orientation = exif
                 .as_ref()
                 .map(|exif| exif_orientation(exif, context))

src/blob/blob_tests.rs

@@ -4,9 +4,7 @@ use super::*;
 use crate::message::{Message, Viewtype};
 use crate::param::Param;
 use crate::sql;
-use crate::test_utils::{
-    self, AVATAR_64x64_BYTES, AVATAR_64x64_DEDUPLICATED, TestContext, TestContextManager,
-};
+use crate::test_utils::{self, AVATAR_64x64_BYTES, AVATAR_64x64_DEDUPLICATED, TestContext};
 use crate::tools::SystemTime;
 
 fn check_image_size(path: impl AsRef<Path>, width: u32, height: u32) -> image::DynamicImage {
@@ -740,66 +738,6 @@ async fn test_send_gif_as_sticker() -> Result<()> {
     Ok(())
 }
 
-/// Tests that animated WebP is sent without reencoding.
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_send_animated_webp_as_image() -> Result<()> {
-    let bytes = include_bytes!("../../test-data/image/animated.webp");
-    let (width, height) = (1280u32, 531u32);
-    let mut tcm = TestContextManager::new();
-    let alice = &tcm.alice().await;
-    let bob = &tcm.bob().await;
-    alice
-        .set_config(
-            Config::MediaQuality,
-            Some(&(MediaQuality::Worse as i32).to_string()),
-        )
-        .await?;
-    let file = alice.get_blobdir().join("file").with_extension("gif");
-    fs::write(&file, &bytes)
-        .await
-        .context("Failed to write file")?;
-    let mut msg = Message::new(Viewtype::Image);
-    msg.set_file_and_deduplicate(alice, &file, Some("file.webp"), None)?;
-
-    let chat = alice.create_chat(bob).await;
-    let sent = alice.send_msg(chat.id, &mut msg).await;
-    let bob_msg = bob.recv_msg(&sent).await;
-    assert_eq!(bob_msg.get_viewtype(), Viewtype::Image);
-    assert_eq!(bob_msg.get_width() as u32, width);
-    assert_eq!(bob_msg.get_height() as u32, height);
-    assert_eq!(
-        bob_msg.get_filebytes(bob).await?.unwrap(),
-        bytes.len() as u64
-    );
-    Ok(())
-}
-
-/// Tests that if user sets animated WebP as an avatar, it may be recoded.
-///
-/// We don't want to recode animated WebPs into JPEG and lose animation,
-/// but for avatars we don't want animation and transparency anyway.
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_recode_animated_webp_avatar() -> Result<()> {
-    let mut tcm = TestContextManager::new();
-    let t = &tcm.alice().await;
-
-    let avatar_src = t.dir.path().join("avatar.webp");
-    let avatar_bytes = include_bytes!("../../test-data/image/animated.webp");
-    fs::write(&avatar_src, avatar_bytes).await.unwrap();
-
-    t.set_config(Config::Selfavatar, Some(avatar_src.to_str().unwrap()))
-        .await?;
-    let avatar_blob = t.get_config(Config::Selfavatar).await?.unwrap();
-    assert!(avatar_blob.ends_with(".jpg"));
-
-    let scaled_avatar_size = fs::metadata(&avatar_blob).await.unwrap().len();
-    assert!(
-        scaled_avatar_size < avatar_bytes.len() as u64,
-        "Animated WebP avatar must be recoded"
-    );
-    Ok(())
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_create_and_deduplicate() -> Result<()> {
     let t = TestContext::new().await;

src/smtp.rs

@@ -68,6 +68,8 @@ impl Smtp {
             // separate task to avoid waiting for reply or timeout.
             task::spawn(async move { transport.quit().await });
         }
+        self.transport_id = None;
+        self.from = None;
         self.last_success = None;
     }