compression does not need to be async

Cargo.lock

@@ -91,19 +91,6 @@ dependencies = [
  "futures-core",
 ]
 
-[[package]]
-name = "async-compression"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc2d0cfb2a7388d34f590e76686704c494ed7aaceed62ee1ba35cbf363abc2a5"
-dependencies = [
- "flate2",
- "futures-core",
- "memchr",
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "async-executor"
 version = "1.5.4"
@@ -430,7 +417,6 @@ name = "azalea-protocol"
 version = "0.8.0"
 dependencies = [
  "anyhow",
- "async-compression",
  "async-recursion",
  "azalea-auth",
  "azalea-block",

azalea-client/src/disconnect.rs

@@ -65,6 +65,8 @@ fn update_read_packets_task_running_component(
         commands.entity(entity).insert(IsConnectionAlive(running));
     }
 }
+
+#[allow(clippy::type_complexity)]
 fn disconnect_on_connection_dead(
     query: Query<(Entity, &IsConnectionAlive), (Changed<IsConnectionAlive>, With<LocalEntity>)>,
     mut disconnect_events: EventWriter<DisconnectEvent>,

azalea-protocol/Cargo.toml

@@ -9,10 +9,6 @@ version = "0.8.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-compression = { version = "^0.4.5", features = [
-    "tokio",
-    "zlib",
-], optional = true }
 async-recursion = "1.0.5"
 azalea-auth = { path = "../azalea-auth", version = "0.8.0" }
 azalea-block = { path = "../azalea-block", default-features = false, version = "0.8.0" }
@@ -52,7 +48,7 @@ uuid = "1.5.0"
 [features]
 connecting = []
 default = ["packets"]
-packets = ["connecting", "dep:async-compression", "dep:azalea-core"]
+packets = ["connecting", "dep:azalea-core"]
 strict_registry = ["packets"]
 
 [dev-dependencies]

azalea-protocol/src/lib.rs

@@ -180,9 +180,7 @@ mod tests {
         )
         .unwrap();
 
-        let buf = compression_encoder(&buf, compression_threshold)
-            .await
-            .unwrap();
+        let buf = compression_encoder(&buf, compression_threshold).unwrap();
 
         println!("{:?}", buf);
 

azalea-protocol/src/read.rs

@@ -244,6 +244,8 @@ pub async fn read_raw_packet<'a, R>(
     stream: &'a mut R,
     buffer: &mut BytesMut,
     compression_threshold: Option<u32>,
+    // this has to be a &mut Option<T> instead of an Option<&mut T> because
+    // otherwise the borrow checker complains about the cipher being moved
     cipher: &mut Option<Aes128CfbDec>,
 ) -> Result<Vec<u8>, Box<ReadPacketError>>
 where

azalea-protocol/src/write.rs

@@ -1,12 +1,12 @@
 //! Write packets to a stream.
 
 use crate::{packets::ProtocolPacket, read::MAXIMUM_UNCOMPRESSED_LENGTH};
-use async_compression::tokio::bufread::ZlibEncoder;
 use azalea_buf::McBufVarWritable;
 use azalea_crypto::Aes128CfbEnc;
-use std::fmt::Debug;
+use flate2::{bufread::ZlibEncoder, Compression};
+use std::{fmt::Debug, io::Read};
 use thiserror::Error;
-use tokio::io::{AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use tokio::io::{AsyncWrite, AsyncWriteExt};
 use tracing::trace;
 
 /// Prepend the length of the packet to it.
@@ -51,7 +51,7 @@ pub enum PacketCompressError {
     Io(#[from] std::io::Error),
 }
 
-pub async fn compression_encoder(
+pub fn compression_encoder(
     data: &[u8],
     compression_threshold: u32,
 ) -> Result<Vec<u8>, PacketCompressError> {
@@ -64,10 +64,10 @@ pub async fn compression_encoder(
         Ok(buf)
     } else {
         // otherwise, compress
-        let mut deflater = ZlibEncoder::new(data);
+        let mut deflater = ZlibEncoder::new(data, Compression::default());
         // write deflated data to buf
         let mut compressed_data = Vec::new();
-        deflater.read_to_end(&mut compressed_data).await?;
+        deflater.read_to_end(&mut compressed_data)?;
 
         // prepend the length
         let mut len_prepended_compressed_data = Vec::new();
@@ -105,7 +105,7 @@ where
     trace!("Writing raw packet: {raw_packet:?}");
     let mut raw_packet = raw_packet.to_vec();
     if let Some(threshold) = compression_threshold {
-        raw_packet = compression_encoder(&raw_packet, threshold).await.unwrap();
+        raw_packet = compression_encoder(&raw_packet, threshold).unwrap();
     }
     raw_packet = frame_prepender(raw_packet).unwrap();
     // if we were given a cipher, encrypt the packet