Method process_set

redis-server/src/codec.rs:141–232

(&mut self, buf: &mut BytesMut)

    }

    fn process_set(&mut self, buf: &mut BytesMut) -> Result<Option<RedisClientMsg>, io::Error> {
        if let DecodeState::Set {
            fh,
            key: _,
            dsz: _,
            rem,
        } = &mut self.d_state
        {
            trace!("START PROCESS SET");
            trace!("cap: {}: len: {}", buf.capacity(), buf.len());
            // trace!("buf_raw: {:?}", String::from_utf8(buf.to_vec()));

            // How much is remaining?
            trace!("rem: {}", rem);

            if *rem > 0 {
                let r_buf = if *rem <= buf.len() {
                    // There could be excess bytes.
                    // Can finish and consume everything.
                    let (a, _) = buf.split_at(*rem);
                    a
                } else {
                    // Not enough to finish, just take as much as we can.
                    &buf
                };

                let wr_b = fh.write(r_buf).map_err(|e| {
                    error!(?e, "Failed to write to fh");
                    io::Error::new(io::ErrorKind::Other, "Server Error")
                })?;
                *rem -= wr_b;
                trace!("wrote: {} rem: {} buflen: {}", wr_b, rem, buf.len());

                if wr_b == buf.len() {
                    buf.clear();
                } else {
                    buf.advance(wr_b);
                }
            }

            let r = if *rem == 0 {
                // We don't need to read anything but we still need the crlf.
                match tag_eol(buf) {
                    Ok(_) => {
                        // We ignore the OK inners since this is the remaining / trailing bytes.
                        // Since we'll advance by the correct len here, we don't need to
                        // do anything else.
                        let wr_b = 2;
                        trace!("COMPLETE!!! {} {}", wr_b, buf.len());
                        if wr_b == buf.len() {
                            buf.clear();
                        } else {
                            buf.advance(wr_b);
                        };

                        // (2, Some(...))
                        let mut n_state = DecodeState::Cmd;
                        std::mem::swap(&mut n_state, &mut self.d_state);