Best way to have long-running update loop

[AndrewJSchoen]

Hey all,

Sorry if this is a naive question, so forgive me if my rust knowledge is a bit lacking. I have a system that will have a long-running loop running, and I want to eventually emit changes within that loop to the frontend. However, I am just working on getting the loop to run without errors, and I thought it would be useful to double-check that generally speaking, I am taking the best approach. To start off, there are a couple considerations that I have that may or may not be specific to my code.

1. The frontend may at any time update some values that will change the execution of the long-running loop.
2. The backend will emit fairly regularly a set of updated values that the frontend will handle. This question was asked in Emitting Event During Loop #3971 but a solution wasn't really given, and this question is actually a bit more broad than just that.
3. There is a struct which, each time it runs a round of the loop, mutates itself to update its internal model

So I will get into a bit of implementation. I have generalized the structs and commented them a bit to give some explanation.

// The inner struct that handles receiving the updated values 
// from the frontend and updates the values that will be emitted
//  to the frontend. This gets wrapped in a mutex later.
struct BrainHandler {
  // BrainStruct is a thing that receives Input and 
  // produces Output, mutating itself in the process.
  pub brain_struct: Option<BrainStruct>,
  pub output: Option<Output>,
  pub input: Option<Input>,
  pub initial_time: Instant
}

impl BrainHandler {

  pub fn new() -> Self {
    return Self { 
      brain_struct: None,
      output: None,
      input: None,
      initial_time: Instant::now()
    }
  }

  pub fn start(mut self) {
    spawn(move || {
      loop {
        self.process_with_current_values();
      }
    });
  }

  pub fn process_with_current_values(&mut self) {
    let elapsed_time = self.initial_time.elapsed();
    let time = elapsed_time.as_secs_f64();
    match &mut self.brain_struct {
      Some(brain_struct) => {
        // for our purposes, process accepts Option<Input> and time (f64)
        let new_output = brain_struct.process(
          self.input.clone(),
          time
        );
        self.output = Some(new_output)
      },
      None => {println!("Brain Invalid, skipping...")}
    }
  }

  pub fn emit_current_output(&self) {
    // todo
  }

}

Then, I wrap the BrainHandler in a mutex and specify how it is instantiated

struct Runner(Mutex<BrainHandler>);

impl Runner {
  pub fn new() -> Self {
    return Self(Mutex::new(BrainHandler::new()))
  }
}

I tried a couple things, but couldn't get the loop to execute within the tauri command.
Entirely possible that I am not doing it right, and that this is the way to do it.
So, I tried just wrapping an inner function of the BrainHandler. Note, this still raises errors saying the BrainHandler doesn't implement "Copy"

#[tauri::command]
fn start(state: tauri::State<Runner>) {
  match state.0.lock() {
    Ok(s) => {
      s.start()
    },
    _ => {println!("Could not start")}
  }
  return
}

// Note, there would also be a command for updating the input field of the BrainHandler

Finally, I specify the main function in Tauri

fn main() {
  let runner = Runner::new();
  tauri::Builder::default()
    .manage(runner)
    // The premise here is that 'start' would be 
    // executed from the frontend when it launches.
    // Is that a good idea, or is there a better way???
    .invoke_handler(tauri::generate_handler![start])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

So that is generally what I am trying to do. I know I could keep trying to fix the various issues one by one, but I just wanted to do a bit of a sanity check with the pros here to see if this is even the right way to go about things. If the general logic checks out, any suggestions on how to handle instantiating and executing the loop? Any feedback would be greatly appreciated. Thanks!

[Sparkenstein]

I believe it's too late to answer this, but just keeping it here since this sounds like a common use cases people are running into like me, and I didn't find any solution in issues/discussions. So here's something I gathered with trial and error:

Pretty sure some optimizations are possible, I am not exactly a rust pro.

Firstly, you need your state to be Arc<Muxtex<>> so that you can share it in thread

    tauri::Builder::default()
        .manage(AppState(Arc::new(Mutex::new(Some(db)))))      // <---- state is Arc<Mutex<db>>
        .invoke_handler(tauri::generate_handler![ start ])      //  <--------- register your command
        .run(tauri::generate_context!())
        .expect("error while running tauri application");

Rest is pretty straighforward, just create your tauri command, make it async, accept the state, lock the mutex etc etc

#[tauri::command]
async fn get_cpu_info<R: Runtime>(
    window: tauri::Window<R>,
    state: State<'_, AppState>,
) -> Result<(), String> {
    let  state = Arc::clone(&state.0);

    thread::spawn(move || loop {
        let lock = state .try_lock();
		// Handle errors, unwrap if you want
        if lock.is_err() {
            break;
        }
        let mut lock = match lock {
            Ok(x) => x,
            Err(_) => break,
        };
		
		// Here's your state
        let db = lock.as_mut().unwrap();

       // use it however you want, you can emit an event to FE as well.
    });
    Ok(())
}