Struct tauri::api::process::CommandChild

pub struct CommandChild { /* private fields */ }

Available on crate feature process-command-api only.

Spawned child process.

Implementations

impl CommandChild

pub fn write(&mut self, buf: &[u8]) -> Result<()>

Writes to process stdin.

Examples found in repository

src/endpoints/shell.rs (line 189)

  fn stdin_write<R: Runtime>(
    _context: InvokeContext<R>,
    pid: ChildId,
    buffer: Buffer,
  ) -> super::Result<()> {
    if let Some(child) = command_child_store().lock().unwrap().get_mut(&pid) {
      match buffer {
        Buffer::Text(t) => child.write(t.as_bytes())?,
        Buffer::Raw(r) => child.write(&r)?,
      }
    }
    Ok(())
  }

pub fn kill(self) -> Result<()>

Sends a kill signal to the child.

Examples found in repository

src/endpoints/shell.rs (line 199)

  fn kill_child<R: Runtime>(_context: InvokeContext<R>, pid: ChildId) -> super::Result<()> {
    if let Some(child) = command_child_store().lock().unwrap().remove(&pid) {
      child.kill()?;
    }
    Ok(())
  }

pub fn pid(&self) -> u32

Returns the process pid.

Examples found in repository

src/endpoints/shell.rs (line 162)

  fn execute<R: Runtime>(
    context: InvokeContext<R>,
    program: String,
    args: ExecuteArgs,
    on_event_fn: CallbackFn,
    options: CommandOptions,
  ) -> super::Result<ChildId> {
    let mut command = if options.sidecar {
      #[cfg(not(shell_sidecar))]
      return Err(crate::Error::ApiNotAllowlisted("shell > sidecar".to_string()).into_anyhow());
      #[cfg(shell_sidecar)]
      {
        let program = PathBuf::from(program);
        let program_as_string = program.display().to_string();
        let program_no_ext_as_string = program.with_extension("").display().to_string();
        let configured_sidecar = context
          .config
          .tauri
          .bundle
          .external_bin
          .as_ref()
          .map(|bins| {
            bins
              .iter()
              .find(|b| b == &&program_as_string || b == &&program_no_ext_as_string)
          })
          .unwrap_or_default();
        if let Some(sidecar) = configured_sidecar {
          context
            .window
            .state::<Scopes>()
            .shell
            .prepare_sidecar(&program.to_string_lossy(), sidecar, args)
            .map_err(crate::error::into_anyhow)?
        } else {
          return Err(crate::Error::SidecarNotAllowed(program).into_anyhow());
        }
      }
    } else {
      #[cfg(not(shell_execute))]
      return Err(crate::Error::ApiNotAllowlisted("shell > execute".to_string()).into_anyhow());
      #[cfg(shell_execute)]
      match context
        .window
        .state::<Scopes>()
        .shell
        .prepare(&program, args)
      {
        Ok(cmd) => cmd,
        Err(e) => {
          #[cfg(debug_assertions)]
          eprintln!("{}", e);
          return Err(crate::Error::ProgramNotAllowed(PathBuf::from(program)).into_anyhow());
        }
      }
    };
    #[cfg(any(shell_execute, shell_sidecar))]
    {
      if let Some(cwd) = options.cwd {
        command = command.current_dir(cwd);
      }
      if let Some(env) = options.env {
        command = command.envs(env);
      } else {
        command = command.env_clear();
      }
      if let Some(encoding) = options.encoding {
        if let Some(encoding) = crate::api::process::Encoding::for_label(encoding.as_bytes()) {
          command = command.encoding(encoding);
        } else {
          return Err(anyhow::anyhow!(format!("unknown encoding {}", encoding)));
        }
      }
      let (mut rx, child) = command.spawn()?;

      let pid = child.pid();
      command_child_store().lock().unwrap().insert(pid, child);

      crate::async_runtime::spawn(async move {
        while let Some(event) = rx.recv().await {
          if matches!(event, crate::api::process::CommandEvent::Terminated(_)) {
            command_child_store().lock().unwrap().remove(&pid);
          }
          let js = crate::api::ipc::format_callback(on_event_fn, &event)
            .expect("unable to serialize CommandEvent");

          let _ = context.window.eval(js.as_str());
        }
      });

      Ok(pid)
    }
  }

Trait Implementations

impl Debug for CommandChild

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.