fix deadlock

Author: kralverde

pumpkin-world/src/level.rs

@@ -139,7 +139,11 @@ impl Level {
     ///
     /// Note: The order of the output chunks will almost never be in the same order as the order of input chunks
 
-    pub fn fetch_chunks(&self, chunks: &[Vector2<i32>], channel: mpsc::Sender<Arc<ChunkData>>) {
+    pub fn fetch_chunks(
+        &self,
+        chunks: &[Vector2<i32>],
+        channel: mpsc::UnboundedSender<Arc<ChunkData>>,
+    ) {
         chunks.into_par_iter().for_each(|at| {
             let channel = channel.clone();
 
@@ -160,6 +164,8 @@ impl Level {
                             ) => {
                                 // This chunk was not generated yet.
                                 let chunk = Arc::new(self.world_gen.generate_chunk(*at));
+                                let mut loaded_chunks = self.loaded_chunks.write();
+                                loaded_chunks.insert(*at, chunk.clone());
                                 Ok(chunk)
                             }
                             Err(err) => Err(err),
@@ -168,6 +174,8 @@ impl Level {
                     None => {
                         // There is no savefile yet -> generate the chunks
                         let chunk = Arc::new(self.world_gen.generate_chunk(*at));
+                        let mut loaded_chunks = self.loaded_chunks.write();
+                        loaded_chunks.insert(*at, chunk.clone());
                         Ok(chunk)
                     }
                 };
@@ -182,9 +190,9 @@ impl Level {
             });
             match maybe_chunk {
                 Some(chunk) => {
-                    channel
-                        .blocking_send(chunk.clone())
-                        .expect("Failed sending ChunkData.");
+                    let _ = channel
+                        .send(chunk)
+                        .inspect_err(|err| log::error!("unable to send chunk to channel: {}", err));
                 }
                 None => {
                     log::error!("Unable to send chunk {:?}!", at);

pumpkin/src/world/mod.rs

@@ -255,12 +255,7 @@ impl World {
         level.mark_chunk_as_newly_watched(chunks);
     }
 
-    async fn spawn_world_chunks(
-        &self,
-        client: Arc<Client>,
-        chunks: Vec<Vector2<i32>>,
-        distance: i32,
-    ) {
+    async fn spawn_world_chunks(&self, client: Arc<Client>, chunks: Vec<Vector2<i32>>) {
         if client.closed.load(std::sync::atomic::Ordering::Relaxed) {
             log::info!(
                 "The connection with {} has closed before world chunks were spawned",
@@ -269,7 +264,11 @@ impl World {
             return;
         }
         let inst = std::time::Instant::now();
-        let (sender, mut chunk_receiver) = mpsc::channel(distance as usize);
+
+        // level.fetch_chunks is synchronous
+        // if level.fetch_chunks is spawned before the chunk sender is spawned,
+        // can block as the channel capacity is reached
+        let (sender, mut chunk_receiver) = mpsc::unbounded_channel();
 
         let level = self.level.clone();
         let chunks = Arc::new(chunks);

pumpkin/src/world/player_chunker.rs

@@ -58,7 +58,7 @@ pub async fn player_join(world: &World, player: Arc<Player>) {
     if !loading_chunks.is_empty() {
         world.mark_chunks_as_watched(&loading_chunks).await;
         world
-            .spawn_world_chunks(player.client.clone(), loading_chunks, view_distance)
+            .spawn_world_chunks(player.client.clone(), loading_chunks)
             .await;
     }
 
@@ -122,7 +122,7 @@ pub async fn update_position(player: &Player) {
             entity.world.mark_chunks_as_watched(&loading_chunks).await;
             entity
                 .world
-                .spawn_world_chunks(player.client.clone(), loading_chunks, view_distance)
+                .spawn_world_chunks(player.client.clone(), loading_chunks)
                 .await;
         }