How to stream output of long running process into a widget in Relm4?

[gtamas]

So I have a child process which generates some output. I want to display that output in a GTK TexView.
I used the Command API to do this, so like:

 sender.oneshot_command(async move {
     CommandMsg::Data(spawn_child().await)
 });

where spawn_child() is an async fn which spawns the child process and returns std::process::Child

Then I use Relm4's update_cmd() API to catch and process the command output like:

fn update_cmd(
        &mut self,
        message: Self::CommandOutput,
        _sender: ComponentSender<Self>,
        _: &Self::Root,
    ) {
        match message {
            CommandMsg::Data(mut child) => {

                {
                    let stdout = child.stdout.as_mut().unwrap();
                    let stdout_reader = BufReader::new(stdout);
                    let stdout_lines = stdout_reader.lines();

                    for line in stdout_lines {
                      self.output_buf.insert_at_cursor(&format!("{}\n",line.unwrap()));
                    }
                }              
            }
        }
   child.wait().unwrap();
    }

This kinda works, but the view gets updated only after the process is finished so it's like buffering the output. I want to read lines from stdout and stderr as they are getting generated and display those lines in the corresponding text view widgets in real-time.
This works fine if I just println!() the line, but doesn't work with the widget.

I'm new to multi threading and I'm sure this is related to threads. But my understanding is that the async function and the oneshot_command are supposed to run that child process code in the background asynchronously, so the main thread shouldn't be blocked. Obviously I'm missing something here.

How do I do this properly? Any help would be highly appreciated. Thanks in advance!

[gtamas]

Never mind... this is not Relm4 specific. Just used std::thread::spawn + input messaging and that solved it. Is this solution optimal though?.Probably it isn't :). I'm new to both Rust and multithreading, so if there is a better way, please let me know.

fn set_output<T: std::io::Read + std::marker::Send + 'static>(&self, sender: ComponentSender<Self>, mut stream: Option<T>, is_error: bool) {
          std::thread::spawn(move || {
            let out = stream.as_mut().unwrap();
            let out_reader = BufReader::new(out);
            let out_lines = out_reader.lines();
              for line in out_lines {
                let str = String::from(line.unwrap());
                 if !is_error {
                    sender.input(MyComponentInput:SetOutput(str));
                 } else {
                    sender.input(MyComponentInput::SetErrorOutput(str));  
                 }
              }
          });
    }

[AaronErhardt]

You can still use commands to make this a bit more elegant. If using async, you can use command(), the more powerful variant of oneshot_command(), which allows you to send multiple command messages. You can also use spawn_command(), which also spawns a new thread, but gives you a sender to send command outputs.