closing std::os::Pipe in a simple user written shell in Rust - shell

Question

I am trying to write a shell using Rust. Currently, I am implementing the pipe | function.
So I split the user input by | into a vector of programs. For the programs, I spawn a process if is not the last program in the vector. If it is the last one, I create the process and wait for it to finish.
Setting up the pipes:
let mut channels: ~[std::os::Pipe] = ~[];
for _ in range(0, progs.len()) {
channels.push(std::os::pipe());
}
Set the input and output FILENO
for i in range(0, progs.len()) {
let mut in_chan = libc::STDIN_FILENO;
let mut out_chan = libc::STDOUT_FILENO;
if i == 0 {
out_chan = channels[i].out;
}
if i > 0 {
in_chan = channels[i-1].input;
out_chan = channels[i].out;
}
if i == progs.len() - 1 {
out_chan = libc::STDOUT_FILENO;
}
}
Spawn the processes:
for i in range(0, progs.len()) {
if i == progs.len() - 1 {
let proc_run = run::Process::new(program, argv, run::ProcessOptions {
env: None,
dir: None,
in_fd: Some(in_chan),
out_fd: Some(out_chan),
err_fd: Some(libc::STDERR_FILENO)
});
proc_run.unwrap().finish();
}
else {
do spawn {
let proc_run = run::Process::new(program, argv, run::ProcessOptions {
env: None,
dir: None,
in_fd: Some(in_chan),
out_fd: Some(out_chan),
err_fd: Some(libc::STDERR_FILENO)
});
proc_run.unwrap().finish();
}
}
}
I tried to run this with a simple C++ program:
#include <iostream>
using namespace std;
int main() {
int readNo;
while(cin >> readNo) {
cout << readNo+1 << endl;
}
return 0;
}
I ran with ./a.out | ./a.out
It seems to me that the pipes are working (1 => 3, 2 => 4 etc) but when I close the stdin with ctrl + d. Only the first process (the process spawned first) finishes. The rest are still running. What is wrong here and how shall I tell the rest of the processes to terminate?
EDIT:
I can do this with blocking process for all programs in the vector:
for i in range(0, progs.len()) {
let proc_run = run::Process::new(program, argv, run::ProcessOptions {
env: None,
dir: None,
in_fd: Some(in_chan),
out_fd: Some(out_chan),
err_fd: Some(libc::STDERR_FILENO)
});
proc_run.unwrap().finish();
}
But this is not what a "shell" does, it should be non-blocking between the processes. When I enter 1 into stdin, it should spit out 3 immediately.
Any help on any parts is appreciated!

Answer 1

Have you tried closing the stdout descriptor when each process ends?
e.g.
extern crate libc;
...
proc_run.unwrap().finish();
libc::unistd::close(out_chan)
The pipe is owned by the Rust Shell program, not the exited process, so when it exits, the pipe remains open. Closing it yourself, should close stdin on the following process.