# Response

> The sequence of channel responses that answers the channel, what ends it, and what a finish with nothing before it means.

Canonical: https://protocol.diverge.network/2.3.0/container-proxy-endpoints/fuse-mount/server/read/response/
Specification revision: 2.3.0

```text
[0][bytes …]    the piece: at most length bytes, fewer at the end of the file, none at or past it
[1]             nothing at the path
[2][message …]  an error, UTF-8
```

- **The sequence.** Exactly one channel response, the bytes, the absence of the file, or an error, followed
  by the channel response finish.
- **The message.** The bytes after the error byte are UTF-8, not JSON.

- **A finish with nothing.** A channel response finish that no
  channel response precedes states that the client did not serve the
  ask. The server does not ask again.

The channel response is defined by `diverge-sdk-rs/src/shared/containers/fuse/read/response/frame.rs`:

```rust
//! The answer to a read.

use std::convert::Infallible;

use super::super::super::ResponseError;
use crate::wire::encode::{Encode, Writer};

/// The one message that answers a read.
///
/// ```text
/// [kind: u8][bytes… | message…]
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Frame<'a> {
    /// Kind `0`. The piece's bytes, verbatim: at most the length
    /// asked, fewer at the end of the file, and none at or past it.
    Present(&'a [u8]),
    /// Kind `1`. The caller holds nothing at the path: on a file
    /// mount, nothing under the id yet, and the file reads as empty
    /// until the first write makes it.
    Missing,
    /// Kind `2`. The read was refused or failed, and this says why,
    /// for a reader rather than a program: what a caller can refuse
    /// is its policy and not this specification's.
    Error(&'a str),
}

impl Encode for Frame<'_> {
    /// [`Infallible`]: a kind byte and bytes copied.
    type Error = Infallible;

    fn encode(&self, out: &mut Writer<'_>) -> Result<(), Infallible> {
        match self {
            Frame::Present(bytes) => {
                out.extend_from_slice(&[0]);
                out.extend_from_slice(bytes);
            }
            Frame::Missing => out.extend_from_slice(&[1]),
            Frame::Error(message) => {
                out.extend_from_slice(&[2]);
                out.extend_from_slice(message.as_bytes());
            }
        }
        Ok(())
    }
}

impl<'a> Frame<'a> {
    /// Decode the one message. The bytes or message borrow from
    /// `bytes`.
    pub fn decode(bytes: &'a [u8]) -> Result<Self, ResponseError> {
        let (kind, rest) = bytes.split_first().ok_or(ResponseError::Empty)?;
        match *kind {
            0 => Ok(Frame::Present(rest)),
            1 => Ok(Frame::Missing),
            2 => std::str::from_utf8(rest)
                .map(Frame::Error)
                .map_err(|_| ResponseError::MessageUtf8),
            other => Err(ResponseError::UnknownKind(other)),
        }
    }
}
```