Change fifo Io to PIPE in shim , just do like go shim. Resovled the much io case problem.

[jokemanfire]

disscustion in containerd
I have told this question to containerd . But looks like containerd will not change. So I will take a pr to change fifo to pipe.
I have complete this code , after some ci test ,I will submit this pr.

[jokemanfire]

I found another two problem, when use fifo directly.

1. ctr run -d busybox:latest test , it status will be stopping directly , but go shim will not.
2. when containerd service is stop , all rshim io will broken, but not go shim.

This is a method to get this error.
1、Get a image
Dockerfile like this:

FROM busybox:latest

COPY test.sh /

ENTRYPOINT ["sh","/test.sh"]

test.sh is blow this:

while true; do 
    sleep 3
    echo "hello"
    result=$?
    if [ $result -ne 0 ]; then
        date >> log.txt
        echo "echo faile . Result : $result" >> /log.txt
    fi
done

docker build get this image.
use ctr import this image.
2、run a container
then use rshim to run a container.
3、get this error
stop containerd service . you can see the error message in this container. but go shim will not be influenced.
So I think use a pipe in shim may be completely needed. This pr which I test can resolve this problem #278

friendly ping , @fuweid @mxpv @Burning1020 . Looking forward to your reply.

[jokemanfire]

I try to use two method to resolve the pipe io's problem . And in my case ,the io problem have been resolved.Add an io monitor service to check if the inode+dev of io has been changed, use read_buf instead of tokio-copy in spawn_copy, and add timeout and put it in a loop.
My code like this

fn spawn_copy<R, W, F>(
    from: R,
    to: W,
    exit_signal: Arc<ExitSignal>,
    on_close: Option<F>,
    mut r: tokio::sync::mpsc::Receiver<i64>,
) where
    R: AsyncRead + Send + Unpin + 'static,
    W: AsyncWrite + Send + Unpin + 'static,
    F: FnOnce() + Send + 'static,
{
    let mut src = from;
    let mut dst = to;

    tokio::spawn(async move {
        let mut buffer: Vec<u8> = vec![0u8; 1024];
        //Change to loop and use time out, to make sure the read_buf will not hangon forever
        loop {
            let mut if_cn = true;
            let result = tokio::time::timeout(tokio::time::Duration::from_secs(5), async {
                tokio::select! {
                    _ = exit_signal.wait() =>{
                        debug!("container exit");
                        if_cn = false;
                    }
                    r = src.read_buf(&mut buffer) => {
                        match r{
                            //Read n=0 but read_buf not close means pipe close
                            Ok(n) => {
                                if n == 0{
                                    if_cn = false;
                                }else{
                                    //Need sure the dist write complete?
                                    let d_w = dst.write_all(&buffer).await;
                                    if d_w.is_err(){
                                        if_cn = false;
                                    }
                                    buffer.clear();
                                }
                            },
                            Err(_) => {
                                debug!("read exit");
                                if_cn = false;
                            },
                        }
                    }
                    c = r.recv() =>{
                        debug!("fd error io exit!! recv {:?}",c);
                        if_cn = false;
                    }
                }
            });
            //Timeout will continue unitl recv the io close
            let _ = result.await;
            if !if_cn {
                break;
            }
        }
        if let Some(f) = on_close {
            f();
        }
    });
}

I will pull this pr next week.