Doubt about rust logic

[hareendranmg]

Hi team,

In one of the ealier commit, there is a point about restarting Rust logic on Dart's hot restart. Is that possible? As of now i can't restart the Rust logic from Dart's hot restart.
Please find the commit details here

[temeddix]

Hi @hareendranmg, that's a really good question.

Rust's restart on Dart's hot restart was temporarily gone on 2.1 and 2.2. It was restored in 2.3. If you install version 2.3 and do dart run rust_in_flutter:apply_template again, Rust logic will be restarted properly.

However, there is a caveat that Rust logic does not get restarted yet on the web. We're trying to solve this problem, which will probably be shipped with 2.4 or beyond.

If you have any other problems, please let us know!

[hareendranmg]

Hi @temeddix , thanks for the quick response. I installed version 2.3.0 and recreated the native folder. But i can't restart the logic from a hot restart.
I tested with the calculate_something() function.

[temeddix]

Hi @temeddix , thanks for the quick response. I installed version 2.3.0 and recreated the native folder. But i can't restart the logic from a hot restart. I tested with the calculate_something() function.

Hmm, that sounds strange. When Dart performs hot restart, the whole async tokio runtime in Rust should stop immediately.

May I ask you if it was surely hot restart was what you did, not hot reload? Because those two are similar but different:


In the terminal, the shortcut for hot restart is R(capital). in vscode debugger, it's refresh button, not the thunder button.

If you've correctly done Dart's hot restart, can you check that no attribute is above async fn main()? There should not be tokio::main attribute on the top of that main function. Also, are you spawning async tasks with crate::spawn(), not tokio::spawn()?

Also, to make things sure, could you copy and paste the content of ./native/hub/src/bridge/api.rs and ./native/hub/src/lib.rs here?

[hareendranmg]

Hi @temeddix,

Yes. I'm doing the hot restart, not the hot reload.
And here is the files ypu asked.

native\hub\src\bridge\api.rs

#![allow(dead_code)]

use crate::bridge::bridge_engine::StreamSink;
use lazy_static::lazy_static;
use std::cell::RefCell;
use std::sync::Arc;
use std::sync::Mutex;
use tokio::sync::mpsc::channel;
use tokio::sync::mpsc::Receiver;
use tokio::sync::mpsc::Sender;

/// Available operations that a RustRequest object can hold.
/// There are 4 options, Create,Read,Update, and Delete.
pub enum RustOperation {
Create,
Read,
Update,
Delete,
}

/// Holds the data that Rust streams to Dart.
#[derive(Clone)]
pub struct RustSignal {
pub address: String,
pub bytes: Vec,
}

/// Request object that is sent from Dart to Rust.
pub struct RustRequest {
pub address: String,
pub operation: RustOperation,
pub bytes: Vec,
}

/// Wrapper for RustRequest with a unique ID.
pub struct RustRequestUnique {
pub id: i32,
pub request: RustRequest,
}

/// Response object that is sent from Rust to Dart.
#[derive(Clone)]
pub struct RustResponse {
pub successful: bool,
pub bytes: Vec,
}

impl Default for RustResponse {
/// Empty response with the successful value of false.
fn default() -> RustResponse {
RustResponse {
successful: false,
bytes: Vec::new(),
}
}
}

/// Wrapper for RustResponse with a unique ID.
#[derive(Clone)]
pub struct RustResponseUnique {
pub id: i32,
pub response: RustResponse,
}

type Cell = RefCell<Option>;
type SharedCell = Arc<Mutex<Cell>>;

type RustSignalStream = StreamSink;
type RustResponseStream = StreamSink;
type RustRequestSender = Sender;
type RustRequestReceiver = Receiver;

// Native: Main thread
// Web: Main thread
thread_local! {
pub static REQUEST_SENDER: Cell = RefCell::new(None);
#[cfg(not(target_family="wasm"))]
pub static TOKIO_RUNTIME: Celltokio::runtime::Runtime = RefCell::new(None);
}

// Native: tokio runtime threads
// Web: Worker thread
thread_local! {
pub static SIGNAL_STREAM: Cell = RefCell::new(None);
pub static RESPONSE_STREAM: Cell = RefCell::new(None);
pub static RESPONSE_SENDER: Cell = RefCell::new(None);
}

// Native: All threads
// Web: Worker thread
lazy_static! {
pub static ref SIGNAL_STREAM_SHARED: SharedCell =
Arc::new(Mutex::new(RefCell::new(None)));
pub static ref RESPONSE_STREAM_SHARED: SharedCell =
Arc::new(Mutex::new(RefCell::new(None)));
pub static ref REQUST_RECEIVER_SHARED: SharedCell =
Arc::new(Mutex::new(RefCell::new(None)));
}

/// Returns a stream object in Dart that listens to Rust.
pub fn prepare_rust_signal_stream(signal_stream: StreamSink) {
let cell = SIGNAL_STREAM_SHARED.lock().unwrap();
cell.replace(Some(signal_stream));
}

/// Returns a stream object in Dart that returns responses from Rust.
pub fn prepare_rust_response_stream(response_stream: StreamSink) {
let cell = RESPONSE_STREAM_SHARED.lock().unwrap();
cell.replace(Some(response_stream));
}

/// Prepare channels that are used in the Rust world.
pub fn prepare_channels() {
let (request_sender, request_receiver) = channel(1024);
REQUEST_SENDER.with(move |inner| {
inner.replace(Some(request_sender));
});
let cell = REQUST_RECEIVER_SHARED.lock().unwrap();
cell.replace(Some(request_receiver));
}

/// Check if the streams are ready in Rust.
/// This should be done before starting the Rust logic.
pub fn check_rust_streams() -> bool {
let mut are_all_ready = true;
let cell = SIGNAL_STREAM_SHARED.lock().unwrap();
if cell.borrow().is_none() {
are_all_ready = false;
};
let cell = RESPONSE_STREAM_SHARED.lock().unwrap();
if cell.borrow().is_none() {
are_all_ready = false;
};
are_all_ready
}

/// Start the main function of Rust.
pub fn start_rust_logic() {
#[cfg(not(target_family = "wasm"))]
{
TOKIO_RUNTIME.with(move |inner| {
let popped = inner.replace(None);
if let Some(previous_runtime) = popped {
previous_runtime.shutdown_background()
};
let tokio_runtime = tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()
.unwrap();
tokio_runtime.spawn(crate::main());
inner.replace(Some(tokio_runtime));
});
}
#[cfg(target_family = "wasm")]
{
wasm_bindgen_futures::spawn_local(crate::main());
}
}

/// Send a request to Rust and receive a response in Dart.
pub fn request_to_rust(request_unique: RustRequestUnique) {
REQUEST_SENDER.with(move |inner| {
let borrowed = inner.borrow();
let sender = borrowed.as_ref().unwrap();
sender.try_send(request_unique).ok();
});
}

native\hub\src\lib.rs

use bridge::respond_to_dart;
use web_alias::*;
use with_request::handle_request;

mod bridge;
mod sample_functions;
mod web_alias;
mod with_request;

/// This hub crate is the entry point for the Rust logic.
/// Always use non-blocking async functions such as tokio::fs::File::open.
async fn main() {
// This is tokio::sync::mpsc::Reciver that receives the requests from Dart.
let mut request_receiver = bridge::get_request_receiver();
// Repeat crate::spawn anywhere in your code
// if more concurrent tasks are needed.
crate::spawn(sample_functions::keep_drawing_mandelbrot());
crate::spawn(sample_functions::keep_sending_strings());
while let Some(request_unique) = request_receiver.recv().await {
crate::spawn(async {
let response_unique = handle_request(request_unique).await;
respond_to_dart(response_unique);
});
}
}

[temeddix]

Thanks! I'll inspect this shortly

[temeddix]

When I perform hot restart, the output in the terminal is as follows:

Current time: 1691030186 seconds since epoch
Current time: 1691030187 seconds since epoch
Current time: 1691030188 seconds since epoch
Current time: 1691030189 seconds since epoch
Current time: 1691030190 seconds since epoch

Performing hot restart...                                               
Restarted application in 288ms.
Current time: 1691030190 seconds since epoch
Current time: 1691030190 seconds since epoch
Current time: 1691030191 seconds since epoch
Current time: 1691030192 seconds since epoch
Current time: 1691030193 seconds since epoch
Current time: 1691030194 seconds since epoch
Current time: 1691030195 seconds since epoch
Current time: 1691030196 seconds since epoch
Current time: 1691030197 seconds since epoch
Current time: 1691030198 seconds since epoch

Performing hot restart...                                               
Restarted application in 273ms.
Current time: 1691030199 seconds since epoch
Current time: 1691030199 seconds since epoch
Current time: 1691030200 seconds since epoch
Current time: 1691030201 seconds since epoch
Current time: 1691030202 seconds since epoch
Current time: 1691030203 seconds since epoch
Current time: 1691030204 seconds since epoch
Current time: 1691030205 seconds since epoch
Current time: 1691030206 seconds since epoch

Performing hot restart...                                               
Restarted application in 275ms.
Current time: 1691030207 seconds since epoch
Current time: 1691030207 seconds since epoch
Current time: 1691030208 seconds since epoch
Current time: 1691030209 seconds since epoch
Current time: 1691030210 seconds since epoch
Current time: 1691030211 seconds since epoch
Current time: 1691030212 seconds since epoch
Current time: 1691030213 seconds since epoch
Current time: 1691030214 seconds since epoch
Current time: 1691030215 seconds since epoch
Current time: 1691030216 seconds since epoch
Current time: 1691030217 seconds since epoch
Current time: 1691030218 seconds since epoch
Current time: 1691030219 seconds since epoch
Current time: 1691030220 seconds since epoch
Current time: 1691030221 seconds since epoch
Current time: 1691030222 seconds since epoch
Current time: 1691030223 seconds since epoch
Current time: 1691030224 seconds since epoch
Current time: 1691030225 seconds since epoch
Current time: 1691030226 seconds since epoch
Current time: 1691030227 seconds since epoch

This is the code:

// native/hub/src/sample_functions.rs

pub async fn keep_drawing_mandelbrot() {
    let mut scale: f64 = 1.0;
    let mut interval = crate::time::interval(std::time::Duration::from_millis(1000));
    loop {
        use std::time::{SystemTime, UNIX_EPOCH};
        if let Ok(duration) = SystemTime::now().duration_since(UNIX_EPOCH) {
            let seconds_since_epoch = duration.as_secs();
            crate::print!("Current time: {} seconds since epoch", seconds_since_epoch);
        } else {
            crate::print!("Error: Failed to get the current time.");
        }
        interval.tick().await;
        scale *= 0.95;
        if scale < 1e-7 {
            scale = 1.0
        };
        let calculated = sample_crate::mandelbrot(
            sample_crate::Size {
                width: 64,
                height: 64,
            },
            sample_crate::Point {
                x: 0.360,
                y: -0.641,
            },
            scale,
            4,
        );
        if let Ok(mandelbrot) = calculated {
            let rust_signal = RustSignal {
                address: String::from("sampleCategory.mandelbrot"),
                bytes: mandelbrot,
            };
            send_rust_signal(rust_signal);
        }
    }
}

It looks like the whole async tokio runtime is properly terminated and restarted upon Dart's hot restart to me, as the previous print loop does disappear. If the previous print loop did remain, there should be accumulated prints every second, but there's not.

If you don't mind, could you provide an elaborated description of how you are using calculate_something() function to check if Rust's hot restart is working to help us get a better understanding?

[hareendranmg]

Hi @temeddix, I believe there might be a misunderstanding regarding how Rust logic interacts with Flutter restarts. Can you kindly clarify the following doubts for me?

In my Flutter code, I am incrementing the count variable value. However, upon restarting the Flutter application, the count variable is reset to 0. On the Rust side, if I change the increment value from 7 to 10 as shown below:

let after_value = before_value + 10;
Will this change take effect after the host restart, or do we need to rebuild the application again to see the updated behavior?

[temeddix]

Oh, I now understand what made the confusion.

The updated Rust code cannot be loaded upon Dart's hot restart. To incorporate the changes, the app needs to be re-compiled, as the app binary must be linked to the newly compiled Rust library files again. This limitation arises from the Rust compilation process, as Rust does not inherently support a hot restart feature.

Thank you for the heads-up, I will include this in the guides soon!

[hareendranmg]

Thank you, @temeddix , for the clear explanation.

[hareendranmg]

Hi @temeddix,

Is there any other ways to incorporate the updated Rust code changes other than re-compilation, like some sort of cargo build like that?

[temeddix]

If you use VS code, you can run the app in profile or release mode in the ‘run and debug’ panel with GUI buttons at the top of the screen. There's a convenient refresh button up there that compiles and restarts the whole app, including changes in Rust.

There‘s no method to do that in CLI other than doing flutter run again

Hope this helps :)

[hareendranmg]

Thanks @temeddix.