Struct Msg 

pub struct Msg { /* private fields */ }

One Dynomite message: the in-memory representation of a request or a response on its way through the engine.

Implementations

impl Msg

pub fn new(id: MsgId, ty: MsgType, is_request: bool) -> Self

Construct a new message with id, type tag ty, and the request/response orientation is_request. The mbuf chain starts empty and the parser is reset to DynParseState::Start.

Examples

use dynomite::msg::{Msg, MsgType};
let m = Msg::new(1, MsgType::ReqRedisGet, true);
assert_eq!(m.id(), 1);
assert!(m.is_request());

pub fn keys(&self) -> &[KeyPos]

Borrow the parsed key list. Populated by the protocol parsers.

Examples

use dynomite::msg::{Msg, MsgType};
assert!(Msg::new(1, MsgType::Unknown, true).keys().is_empty());

pub fn keys_mut(&mut self) -> &mut Vec<KeyPos>

Mutably borrow the parsed key list.

pub fn push_key(&mut self, k: KeyPos)

Append a parsed key. Used by the protocol parsers.

pub fn args(&self) -> &[ArgPos]

Borrow the parsed argument list.

pub fn args_mut(&mut self) -> &mut Vec<ArgPos>

Mutably borrow the parsed argument list.

pub fn push_arg(&mut self, a: ArgPos)

Append a parsed argument.

pub fn parser_state(&self) -> u32

Protocol-specific parser state index. Each parser defines its own state alphabet keyed on this u32.

pub fn set_parser_state(&mut self, s: u32)

Set the protocol parser state index.

pub fn parser_pos(&self) -> usize

Cursor offset into the input buffer where the next byte should be read.

pub fn set_parser_pos(&mut self, p: usize)

Set the parser cursor offset.

pub fn parser_token(&self) -> Option<usize>

Optional token marker offset.

pub fn set_parser_token(&mut self, t: Option<usize>)

Set the optional token marker offset.

pub fn rlen(&self) -> u32

Remaining length of the bulk argument the parser is currently consuming.

pub fn set_rlen(&mut self, n: u32)

Set the bulk-argument remaining length.

pub fn rntokens(&self) -> u32

Remaining unprocessed token count for the current parse.

pub fn set_rntokens(&mut self, n: u32)

Set the remaining-token counter.

pub fn ntokens(&self) -> u32

Total parsed token count for the current message.

pub fn set_ntokens(&mut self, n: u32)

Set the total parsed token count.

pub fn nkeys(&self) -> u32

Number of keys the script (EVAL/EVALSHA) declared.

pub fn set_nkeys(&mut self, n: u32)

Set the script-key count.

pub fn vlen(&self) -> u32

Storage-command value length.

pub fn set_vlen(&mut self, n: u32)

Set the storage-command value length.

pub fn integer(&self) -> i64

Integer value carried by the response (:n\r\n).

pub fn set_integer(&mut self, v: i64)

Set the integer response value.

pub fn end_marker(&self) -> Option<usize>

Offset of the multi-bulk END marker in the response, if any.

pub fn set_end_marker(&mut self, m: Option<usize>)

Set the response END marker offset.

pub fn ntoken_start(&self) -> Option<usize>

Start offset of the multi-bulk argument count token.

pub fn ntoken_end(&self) -> Option<usize>

End offset (exclusive) of the multi-bulk argument count token.

pub fn set_ntoken_span(&mut self, start: Option<usize>, end: Option<usize>)

Set the multi-bulk argument count span.

pub fn frag_id(&self) -> u64

Fragment id grouping all sub-messages produced from a multi-key request.

pub fn set_frag_id(&mut self, id: u64)

Set the fragment id.

pub fn id(&self) -> MsgId

Message id.

Examples

use dynomite::msg::{Msg, MsgType};
assert_eq!(Msg::new(99, MsgType::Unknown, true).id(), 99);

pub fn parent_id(&self) -> MsgId

Parent id (zero when not a fragment).

Examples

use dynomite::msg::{Msg, MsgType};
assert_eq!(Msg::new(1, MsgType::Unknown, true).parent_id(), 0);

pub fn set_parent_id(&mut self, parent: MsgId)

Set the parent id.

Examples

use dynomite::msg::{Msg, MsgType};
let mut m = Msg::new(2, MsgType::Unknown, true);
m.set_parent_id(1);
assert_eq!(m.parent_id(), 1);

pub fn ty(&self) -> MsgType

Message type tag.

Examples

use dynomite::msg::{Msg, MsgType};
assert_eq!(Msg::new(1, MsgType::ReqMcGet, true).ty(), MsgType::ReqMcGet);

pub fn set_type(&mut self, ty: MsgType)

Override the message type. The previous value is preserved as the original type so query rewriters can recover it.

Examples

use dynomite::msg::{Msg, MsgType};
let mut m = Msg::new(1, MsgType::ReqRedisGet, true);
m.set_type(MsgType::ReqRedisSet);
assert_eq!(m.ty(), MsgType::ReqRedisSet);
assert_eq!(m.orig_type(), MsgType::ReqRedisGet);

pub fn orig_type(&self) -> MsgType

Original message type before any rewrite.

Examples

use dynomite::msg::{Msg, MsgType};
assert_eq!(
    Msg::new(1, MsgType::ReqRedisGet, true).orig_type(),
    MsgType::Unknown,
);

pub fn is_request(&self) -> bool

True for requests.

Examples

use dynomite::msg::{Msg, MsgType};
assert!(Msg::new(1, MsgType::ReqMcGet, true).is_request());
assert!(!Msg::new(1, MsgType::RspMcStored, false).is_request());

pub fn mbufs(&self) -> &MbufQueue

Borrow the underlying mbuf chain.

Examples

use dynomite::msg::{Msg, MsgType};
let m = Msg::new(1, MsgType::Unknown, true);
assert!(m.mbufs().is_empty());

pub fn mbufs_mut(&mut self) -> &mut MbufQueue

Mutably borrow the mbuf chain.

Examples

use dynomite::io::mbuf::MbufPool;
use dynomite::msg::{Msg, MsgType};

let pool = MbufPool::default();
let mut m = Msg::new(1, MsgType::Unknown, true);
m.mbufs_mut().push_back(pool.get());
assert_eq!(m.mbufs().len(), 1);

pub fn mlen(&self) -> u32

Cumulative readable byte count of the chain (mlen).

Examples

use dynomite::msg::{Msg, MsgType};
assert_eq!(Msg::new(1, MsgType::Unknown, true).mlen(), 0);

pub fn recompute_mlen(&mut self)

Refresh mlen from the current chain.

The parser updates the length as it consumes bytes; callers that mutate the chain directly call this to keep the cached length consistent with the actual chain content.

Examples

use dynomite::io::mbuf::MbufPool;
use dynomite::msg::{Msg, MsgType};

let pool = MbufPool::default();
let mut m = Msg::new(1, MsgType::Unknown, true);
let mut buf = pool.get();
buf.recv(b"hi");
m.mbufs_mut().push_back(buf);
m.recompute_mlen();
assert_eq!(m.mlen(), 2);

pub fn set_mlen(&mut self, mlen: u32)

Direct setter for mlen. Use Msg::recompute_mlen when the chain has been mutated; this entry point exists for parsers that adjust the value as they consume bytes.

Examples

use dynomite::msg::{Msg, MsgType};
let mut m = Msg::new(1, MsgType::Unknown, true);
m.set_mlen(123);
assert_eq!(m.mlen(), 123);

pub fn parse_result(&self) -> MsgParseResult

Last parse outcome.

Examples

use dynomite::msg::{Msg, MsgParseResult, MsgType};
assert_eq!(
    Msg::new(1, MsgType::Unknown, true).parse_result(),
    MsgParseResult::Ok,
);

pub fn set_parse_result(&mut self, r: MsgParseResult)

Set the parse outcome.

Examples

use dynomite::msg::{Msg, MsgParseResult, MsgType};
let mut m = Msg::new(1, MsgType::Unknown, true);
m.set_parse_result(MsgParseResult::Again);
assert_eq!(m.parse_result(), MsgParseResult::Again);

pub fn dyn_parse_state(&self) -> DynParseState

Current DNODE parser state.

Examples

use dynomite::msg::{Msg, MsgType};
use dynomite::proto::dnode::DynParseState;
assert_eq!(
    Msg::new(1, MsgType::Unknown, true).dyn_parse_state(),
    DynParseState::Start,
);

pub fn set_dyn_parse_state(&mut self, state: DynParseState)

Set the DNODE parser state.

pub fn dmsg(&self) -> Option<&Dmsg>

Borrow the parsed DNODE header, if any.

Examples

use dynomite::msg::{Msg, MsgType};
assert!(Msg::new(1, MsgType::Unknown, true).dmsg().is_none());

pub fn dmsg_mut(&mut self) -> Option<&mut Dmsg>

Mutably borrow the parsed DNODE header.

pub fn set_dmsg(&mut self, dmsg: Dmsg)

Attach a parsed DNODE header.

pub fn routing(&self) -> MsgRouting

Routing override.

pub fn set_routing(&mut self, routing: MsgRouting)

Set the routing override.

pub fn consistency(&self) -> ConsistencyLevel

Consistency level for this message.

pub fn set_consistency(&mut self, level: ConsistencyLevel)

Set the consistency level.

pub fn timestamp_us(&self) -> u64

Microsecond timestamp recorded at request creation.

pub fn set_timestamp_us(&mut self, ts: u64)

Update the request timestamp.

pub fn error_code(&self) -> i32

Datastore-level error code (errno-shaped).

pub fn set_error_code(&mut self, e: i32)

Set the datastore error code.

pub fn dyn_error_code(&self) -> DynErrorCode

Dynomite-level error code.

pub fn set_dyn_error_code(&mut self, e: DynErrorCode)

Set the Dynomite error code.

pub fn awaiting_rsps(&self) -> u32

Number of replies the request is still waiting on.

pub fn incr_awaiting_rsps(&mut self)

Increment awaiting_rsps.

pub fn decr_awaiting_rsps(&mut self)

Decrement awaiting_rsps.

pub fn set_awaiting_rsps(&mut self, n: u32)

Set awaiting_rsps directly. Used by the response manager initialiser to seed the per-DC count.

pub fn fragment_ids(&self) -> &[MsgId]

Borrow the fragment-id list.

pub fn push_fragment_id(&mut self, id: MsgId)

Append id to the fragment-id list.

pub fn response_ids(&self) -> &[MsgId]

Borrow the response-id list.

pub fn push_response_id(&mut self, id: MsgId)

Append id to the response-id list.

pub fn selected_rsp(&self) -> Option<MsgId>

Currently-selected response id.

pub fn set_selected_rsp(&mut self, id: Option<MsgId>)

Set the currently-selected response id.

pub fn owner(&self) -> Option<ConnId>

Owner connection id (placeholder until Stage 9).

pub fn set_owner(&mut self, owner: Option<ConnId>)

Set the owner connection id.

pub fn flags(&self) -> &MsgFlags

Borrow the lifecycle flags.

pub fn flags_mut(&mut self) -> &mut MsgFlags

Mutably borrow the lifecycle flags.

pub fn set_swallow(&mut self, on: bool)

Set the swallow flag.

pub fn set_done(&mut self, on: bool)

Set the done flag.

pub fn set_is_error(&mut self, on: bool)

Set the is_error flag.

pub fn rspmgr(&self) -> Option<&ResponseMgr>

Borrow the local-DC response manager.

pub fn rspmgr_mut(&mut self) -> Option<&mut ResponseMgr>

Mutably borrow the local-DC response manager.

pub fn set_rspmgr(&mut self, mgr: ResponseMgr)

Install a fresh response manager for the local DC.

pub fn additional_rspmgrs(&self) -> &[ResponseMgr]

Borrow the per-remote-DC response managers.

pub fn additional_rspmgrs_mut(&mut self) -> &mut Vec<ResponseMgr>

Mutably borrow the per-remote-DC response managers.

Trait Implementations

impl Debug for Msg

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.