Standalone only

The mode, read once at load

// trafikey — the server mode, cached by init
// whether the server is cluster-enabled, read once at load: cluster-enabled is a startup-only
// setting, so the value cannot change while the module is loaded
static CLUSTER: OnceLock<bool> = OnceLock::new();

// init's third step; a second call keeps the first value
pub(crate) fn load_mode(ctx: &Context) {
    let _ = CLUSTER.set(ctx.get_flags().contains(ContextFlags::CLUSTER));
}

One read at load, one cached boolean: every later call consults memory, never the server.

Three answers, and the test that pins them

// trafikey — host::mode_refusal, standalone and serving
// pure: standalone admits; a cluster refuses with its EMQWIRE text; a mode init never
// recorded refuses as a host failure rather than guess
fn mode_refusal(cluster: Option<bool>) -> Result<(), ValkeyError> {
    match cluster {
        Some(false) => Ok(()),
        Some(true) => Err(errors::emq(errors::WIRE_CLUSTER)),
        None => Err(errors::emq(errors::HOST_CALL)),
    }
}

// refuse on a cluster-enabled server, before any key is read or written
pub fn standalone() -> Result<(), ValkeyError> {
    mode_refusal(CLUSTER.get().copied())
}

// EMQ is served only on a server known to be standalone; EMQ.VERSION advertises its
// capabilities only then, so a client following the version contract refuses a cluster
pub fn serving() -> bool {
    CLUSTER.get() == Some(&false)
}

// trafikey — the two texts, from emq::errors
// a cluster-enabled server: refused at the fence, and by EMQ.INSTALL after its shape checks
pub const WIRE_CLUSTER: &str = "EMQWIRE expected a standalone server but cluster mode is enabled";
// …
/// RM_Call returned no reply object, or a host API pointer is missing.
pub const HOST_CALL: &str = "ERR EMQ host call failed";

// trafikey — the unit test that pins the three answers
#[test]
fn a_cluster_refuses_and_an_unknown_mode_refuses() {
    assert!(mode_refusal(Some(false)).is_ok());
    assert_eq!(
        errors::text(&mode_refusal(Some(true)).unwrap_err()),
        errors::WIRE_CLUSTER
    );
    assert_eq!(
        errors::text(&mode_refusal(None).unwrap_err()),
        errors::HOST_CALL
    );
}

Standalone admits, a cluster refuses with its own text, and an unknown mode refuses rather than guesses.

Where the check runs, and where it does not

// trafikey — host::fence, the first lines
pub fn fence(ctx: &Context) -> Result<Caller, ValkeyError> {
    // the mode check, before the caller is resolved and before {emq}:version is read
    standalone()?;
    let caller = Caller::of(ctx)?;
    caller.open(keyspace::VERSION_KEY, Access::Read)?;
    // …
}

// trafikey — EMQ.INSTALL, the administrative write
/// `EMQ.INSTALL 1 {emq}:version` (install.md#grammar).
pub(crate) fn install(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
    check_shape(&args)?;
    // a cluster refuses here: after the shape check, before the one read
    host::standalone()?;
    match decide(host::read(ctx, cmd::GET, &[keyspace::VERSION_KEY]))? {
        Step::Equal => Ok(ValkeyValue::Integer(0)),
        Step::Install => {
            let w = host::begin_writes(ctx)?;
            w.call(cmd::SET, &[keyspace::VERSION_KEY, keyspace::EPOCH])?;
            Ok(ValkeyValue::Integer(1))
        }
    }
}

The check sits at one choke point, the fence, plus the one write that installs what the fence reads.

EMQ.VERSION advertises nothing, so a client refuses

// trafikey — EMQ.VERSION, the branch that empties the list
// a read-only command: it reads no key and runs no fence, so it answers on any server
pub(crate) fn version(ctx: &Context, _: Vec<ValkeyString>) -> ValkeyResult {
    // G1 order is the EMQ rows' table order; a token is advertised only while its command is
    // registered (R14), so a capability always names a served command.
    // on a cluster-enabled server every EMQ command stays registered but refuses, so the list is empty
    let caps = if host::serving() {
        registry::capabilities(Family::Emq, |name| registry::registered(ctx, name))
            .collect::<Vec<_>>()
            .join(" ")
    } else {
        String::new()
    };
    // …
}

An empty list is a refusal a client can read: the node answers EMQ.VERSION truthfully, and the truth is that it serves nothing.

Recap — standalone only

Next in the part: The command grammar — shape, layout, the fence, the domain checks, one write guard, then the writes.

References