feat: bump version out of beta

Author: jacobtread

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pocket-relay"
-version = "0.7.0-beta"
+version = "0.7.0"
 description = "Pocket Relay Server"
 readme = "README.md"
 keywords = ["EA", "PocketRelay", "MassEffect"]

Cargo.toml

@@ -38,8 +38,8 @@ impl Games {
 
     /// Find a game that matches the provided rule set
     pub fn get_by_rule_set(&self, rule_set: &RuleSet) -> Option<(GameID, GameRef)> {
-        let games = &*self.games.read();
-        games
+        self.games
+            .read()
             .iter()
             .find(|(_game_id, game_ref)| {
                 let join_state = game_ref.read().joinable_state(Some(rule_set));

src/services/game/store.rs

@@ -197,31 +197,33 @@ pub async fn tunnel_keep_alive(service: Arc<TunnelService>) {
                 .remove_dead_tunnels(now, KEEP_ALIVE_TIMEOUT);
         }
 
-        let mappings = service.mappings.read();
-
         // Send out keep-alive messages for any tunnels that aren't expired
-        mappings.tunnel_data().for_each(|(tunnel_id, data)| {
-            match &data.handle {
-                TunnelHandle::Udp(target_address) => {
-                    let buffer = pocket_relay_udp_tunnel::serialize_message(
-                        *tunnel_id,
-                        &pocket_relay_udp_tunnel::TunnelMessage::KeepAlive,
-                    );
-
-                    // Send keep alive message
-                    _ = service.udp_tx.send(UdpTunnelMessage {
-                        buffer,
-                        target_address: *target_address,
-                    });
-                }
-                TunnelHandle::Http(tunnel_handle) => {
-                    // Write a keep alive message
-                    _ = tunnel_handle.tx.send(HttpTunnelMessage {
-                        index: 255,
-                        message: Bytes::new(),
-                    });
+        service
+            .mappings
+            .read()
+            .tunnel_data()
+            .for_each(|(tunnel_id, data)| {
+                match &data.handle {
+                    TunnelHandle::Udp(target_address) => {
+                        let buffer = pocket_relay_udp_tunnel::serialize_message(
+                            *tunnel_id,
+                            &pocket_relay_udp_tunnel::TunnelMessage::KeepAlive,
+                        );
+
+                        // Send keep alive message
+                        _ = service.udp_tx.send(UdpTunnelMessage {
+                            buffer,
+                            target_address: *target_address,
+                        });
+                    }
+                    TunnelHandle::Http(tunnel_handle) => {
+                        // Write a keep alive message
+                        _ = tunnel_handle.tx.send(HttpTunnelMessage {
+                            index: 255,
+                            message: Bytes::new(),
+                        });
+                    }
                 }
-            }
-        });
+            });
     }
 }

src/services/tunnel/mod.rs

@@ -40,10 +40,7 @@ pub async fn handle_join_game(
         .ok_or(GameManagerError::InvalidGameId)?;
 
     // Check the game is joinable
-    let join_state = {
-        let game = &*game_ref.read();
-        game.joinable_state(None)
-    };
+    let join_state = { game_ref.read().joinable_state(None) };
 
     if !matches!(join_state, GameJoinableState::Joinable) {
         return Err(GameManagerError::GameFull.into());
@@ -77,8 +74,7 @@ pub async fn handle_get_game_data(
         .get_by_id(game_id)
         .ok_or(GameManagerError::InvalidGameId)?;
 
-    let game = &*game.read();
-    let body = game.game_data();
+    let body = game.read().game_data();
 
     Ok(body)
 }