hash = "sha256-GtQcO5i29L38HL4vE+9P5nGI2mW1+PSaEhp18mJNmXU=";

      hash = "sha256-YTzCCpRfaMvVeszKigjqTePaDySZzhVv2POyfW1iXyU=";

                    let n = if let Some(line) = line ?{

                    let n = if let Some(line) = line? {

use tokio::io::{AsyncReadExt, AsyncSeekExt};

use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncSeekExt, BufReader};

    if let Some((a, b, c)) = send_all(&config, id, &mut remote_stdout, &mut remote_stderr)
        .await
        .unwrap()
    {
        socket.send(a.into()).await.unwrap_or(());
        socket.send(b.into()).await.unwrap_or(());
        if let Some(c) = c {
            socket.send(c.into()).await.unwrap_or(());
        }
    }

    send_all(
        &config,
        id,
        &mut remote_stdout,
        &mut remote_stderr,
        &mut socket,
    )
    .await
    .unwrap();

) -> Result<Option<(String, String, Option<String>)>, crate::Error> {

    socket: &mut WebSocket,
) -> Result<(), crate::Error> {

        let mut stdout = String::new();
        let mut stderr = String::new();
        debug!("send_all {:?} {:?}", stdout.len(), stderr.len());
        if let Some(ref path) = config.ci.filesystem {
            let mut outf = tokio::fs::File::open(&path.join(&format!("{}.stdout", id)))

        if let Some(ended) = ended {
            socket
                .send(
                    serde_json::to_string(&Msg::Status { ended, status })
                        .unwrap()
                        .into(),
                )

            let mut errf = tokio::fs::File::open(&path.join(&format!("{}.stderr", id)))

        }
        let Some(ref path) = config.ci.filesystem else {
            return Ok(());
        };
        let mut outf = BufReader::new(
            tokio::fs::File::open(&path.join(&format!("{}.stdout", id)))

                .unwrap();
            outf.seek(std::io::SeekFrom::Start(*remote_stdout as u64))
                .await?;
            errf.seek(std::io::SeekFrom::Start(*remote_stderr as u64))
                .await?;
            outf.read_to_string(&mut stdout).await?;
            errf.read_to_string(&mut stderr).await?;

                .unwrap(),
        );
        outf.seek(std::io::SeekFrom::Start(*remote_stdout as u64))
            .await?;
        let mut buf = String::with_capacity(8192);
        while let Ok(n) = outf.read_line(&mut buf).await {
            *remote_stdout += n;
            if buf.len() >= 4096 || n == 0 {
                socket
                    .send(
                        serde_json::to_string(&Msg::Chunk {
                            channel: 0,
                            offset: 0,
                            content: &buf,
                        })
                        .unwrap()
                        .into(),
                    )
                    .await
                    .unwrap();
                buf.clear()
            }
            if n == 0 {
                break;
            }

        *remote_stdout = stdout.len();
        *remote_stderr = stderr.len();
        Ok(Some((
            serde_json::to_string(&Msg::Chunk {
                channel: 0,
                offset: 0,
                content: &stdout,
            })
            .unwrap(),
            serde_json::to_string(&Msg::Chunk {
                channel: 1,
                offset: 0,
                content: &stderr,
            })
            .unwrap(),
            ended.map(|ended| serde_json::to_string(&Msg::Status { ended, status }).unwrap()),
        )))
    } else {
        Ok(None)

        buf.clear();
        let mut errf = BufReader::new(
            tokio::fs::File::open(&path.join(&format!("{}.stderr", id)))
                .await
                .unwrap(),
        );
        errf.seek(std::io::SeekFrom::Start(*remote_stderr as u64))
            .await?;
        while let Ok(n) = errf.read_line(&mut buf).await {
            *remote_stderr += n;
            if buf.len() >= 4096 || n == 0 {
                socket
                    .send(
                        serde_json::to_string(&Msg::Chunk {
                            channel: 1,
                            offset: 0,
                            content: &buf,
                        })
                        .unwrap()
                        .into(),
                    )
                    .await
                    .unwrap();
                buf.clear()
            }
            if n == 0 {
                break;
            }
        }

    Ok(())