Client and server talking to each other with godot-rust

client.rs

use gdnative::prelude::*;
use gdnative::api::NetworkedMultiplayerENet;

#[derive(NativeClass)]
#[inherit(Node)]
pub struct ServerPuppet {
    address: String,
    port: i64,
    in_bandwidth: i64,
    out_bandwidth: i64,
    client_port: i64,
}

#[methods]
impl ServerPuppet {
    fn new(_owner: &Node) -> Self {
        Self {
            address: String::from("128.0.0.1"),
            port: 9876,
            in_bandwidth: 1000,
            out_bandwidth: 1000,
            client_port: 9877,
        }
    }

    #[export]
    fn _ready(&mut self, owner: TRef<Node>) {
        let peer = NetworkedMultiplayerENet::new();
        peer.create_client(
            GodotString::from(&self.address),
            self.port,
            self.in_bandwidth,
            self.out_bandwidth,
            self.client_port,
        ).unwrap();

        if let Some(tree) = owner.get_tree() {
            let tree = unsafe { tree.assume_safe() };
            tree.set_network_peer(peer);
            tree.connect(
                "connected_to_server",
                owner,
                "on_connected_to_server",
                VariantArray::new_shared(),
                0
            ).unwrap();
        };
    }

    #[export]
    fn on_connected_to_server(&mut self, owner: &Node) {
        owner.rpc(GodotString::from_str("greet_server"), &[]);
    }

    #[export(rpc = "remote")]
    fn return_greeting(&mut self, _owner: &Node) {
        godot_print!("Hello from server");
    }
}

lib.rs

use gdnative::prelude::*;

mod client;
mod server;

fn init(handle: InitHandle) {
    handle.add_class::<client::ServerPuppet>();
    handle.add_class::<server::Server>();
}

godot_init!(init)

server.rs

use gdnative::prelude::*;
use gdnative::api::NetworkedMultiplayerENet;

#[derive(NativeClass)]
#[inherit(Node)]
pub struct Server {
    port: i64,
    max_clients: i64,
    in_bandwidth: i64,
    out_bandwidth: i64,
}

#[methods]
impl Server {
    fn new(_owner: &Node) -> Self {
        Self {
            port: 9876,
            max_clients: 1,
            in_bandwidth: 1000,
            out_bandwidth: 1000,
        }
    }

    #[export]
    fn _ready(&mut self, owner: &Node) {
        let peer = NetworkedMultiplayerENet::new();
        peer.create_server(
            self.port,
            self.max_clients,
            self.in_bandwidth,
            self.out_bandwidth,
        ).unwrap();

        if let Some(tree) = owner.get_tree() {
            let tree = unsafe { tree.assume_safe() };
            tree.set_network_peer(peer);
        };
    }

    #[export(rpc = "remote")]
    fn greet_server(&mut self, owner: &Node) {
        godot_print!("Hello from client");
        owner.rpc(GodotString::from_str("return_greeting"), &[]);
    }
}