Method decode_cmd

redis-server/src/codec.rs:63–139

(&mut self, buf: &mut BytesMut)

    }

    fn decode_cmd(&mut self, buf: &mut BytesMut) -> Result<Option<RedisClientMsg>, io::Error> {
        trace!("cap: {}: len: {}", buf.capacity(), buf.len());
        // trace!("buf_raw: {:?}", String::from_utf8(buf.to_vec()))

        let (_rem, (cmd, sz)) = match cmd_parser(buf.as_ref()) {
            Ok(r) => r,
            Err(Incomplete(_)) => {
                if buf.len() >= MAX_CMD_LEN {
                    return Err(io::Error::new(io::ErrorKind::Other, "Command too long"));
                } else {
                    debug!("Need more data");
                    return Ok(None);
                }
            }
            Err(e) => {
                error!(?e, "Malformed input");
                return Err(io::Error::new(io::ErrorKind::Other, "Malformed Input"));
            }
        };

        trace!(?cmd);

        let r = match cmd {
            Cmd::Wait => {
                buf.clear();
                trace!("WAIT cap: {}: len: {}", buf.capacity(), buf.len());
                None
            }
            Cmd::Auth(pw) => Some(RedisClientMsg::Auth(pw.to_vec())),
            Cmd::Get(key) => Some(RedisClientMsg::Get(key.to_vec())),
            Cmd::Set(key, dsz) => {
                // Okay, this is the fun one. We basicly need to setup for the next iter.
                let fh = self.cache.new_tempfile().ok_or_else(|| {
                    error!("Unable to allocate temp file");
                    io::Error::new(io::ErrorKind::Other, "Server Error")
                })?;
                self.d_state = DecodeState::Set {
                    fh,
                    key: key.to_vec(),
                    dsz: dsz as usize,
                    rem: dsz as usize,
                };
                buf.advance(sz);
                return self.process_set(buf);
            }
            Cmd::ConfigGet(key) => {
                let skey = String::from_utf8(key.to_vec())
                    .map_err(|_| io::Error::new(io::ErrorKind::Other, "Invalid UTF8"))?;
                Some(RedisClientMsg::ConfigGet(skey))
            }

            Cmd::ClientSetInfo(name, None) => {
                let name = String::from_utf8(name.to_vec())
                    .map_err(|_| io::Error::new(io::ErrorKind::Other, "Invalid UTF8"))?;
                Some(RedisClientMsg::ClientSetInfo(name, None))
            }
            Cmd::ClientSetInfo(name, Some(version)) => {
                let name = String::from_utf8(name.to_vec())