CodeVetter · Repo Unpack · Data flow
redis/redis
Input arrives on a connection abstraction (`connection.h` over socket/unix/TLS), is read into a per-client or thread-reusable query buffer by `readQueryFromClient()`, parsed into `pendingCommand` structs by `processInlineBuffer()`/`processMultibulkBuffer()`, dispatched by `processCommand()` and executed by `call()`. Command handlers mutate the authoritative state owner — `server.db[j]` kvstores — and any side effects are queued through `alsoPropagate()`. At the end of the execution unit `propagateNow()` fans out to exactly three sinks: the AOF buffer, the replica stream, and the atomic-slot-migration client. Replies accumulate in per-client output buffers and are flushed in `beforeSleep()` by `handleClientsWithPendingWrites()`, strictly after `flushAppendOnlyFile()` so `appendfsync=always` is honoured before acknowledgement.
- The input boundary is `readQueryFromClient(connection *conn)`, which recovers the client via `connGetPrivateData(conn)` and reads `PROTO_IOBUF_LEN` bytes, except when a multibulk argument exceeds `PROTO_MBULK_BIG_ARG`, in which case it sizes the read to exactly the remaining bulk length to enable zero-copy object creation.
- Query buffers are pooled per IO thread: a client with no private `querybuf` borrows `thread_reusable_qb` and sets `CLIENT_IO_REUSABLE_QUERYBUFFER`; if `thread_reusable_qb_used` is already set (nested execution via `processEventsWhileBlocked()`) the client allocates a private buffer instead.
- `processInputBuffer()` parses ahead up to `server.lookahead` commands into `c->pending_cmds`, but clamps the lookahead to 1 for unauthenticated clients because AUTH changes the handling of succeeding commands.
- Request type is inferred from the first byte: `'*'` selects `PROTO_REQ_MULTIBULK` → `processMultibulkBuffer()`, anything else selects `PROTO_REQ_INLINE` → `processInlineBuffer()`; an unknown `reqtype` triggers `serverPanic("Unknown request type")`.
- `processCommand()` resolves argv to a `struct redisCommand` through a three-tier lookup: an already-set `c->lookedcmd`, then `isCommandReusable(c->lastcmd, ...)` reusing the previous command, then a full `lookupCommand(c->argv, c->argc)`.
- The command table itself is populated once at startup by `populateCommandTable()` walking the generated `extern struct redisCommand redisCommandTable[]` from commands.def, so adding a command is a data change in `src/commands/*.json` followed by codegen.
- Module command filters get first look at every non-reprocessed command: `processCommand()` calls `moduleCallCommandFilters(c)` and `reqresAppendRequest(c)` before command lookup, meaning a module can rewrite argv before the core ever resolves the command name.
- `call()` records `dirty = server.dirty` and `old_master_repl_offset = server.master_repl_offset` before invoking the proc, and clears `CLIENT_FORCE_AOF|CLIENT_FORCE_REPL|CLIENT_PREVENT_PROP` so the handler must opt back into propagation.
- `server.allowed_propagate_targets` is a global mask narrowed for the duration of each `call()` so that nested `RM_Call`/Lua `redis.set_repl()` restrictions from an outer call cannot be escaped by an inner one — this is what makes effect-command rewriting (SPOP→SREM) honour selective replication.
- `propagateNow()` is the single fan-out point to the three output sinks: `feedAppendOnlyFile()` when `server.aof_state != AOF_OFF && target & PROPAGATE_AOF`, then `replicationFeedSlaves(server.slaves, ...)` and `asmFeedMigrationClient(argv, argc)` when `target & PROPAGATE_REPL`.
- `propagateNow()` asserts that propagation never happens while replica actions are paused — `serverAssert(!(isPausedActions(PAUSE_ACTION_REPLICA) && !server.client_pause_in_transaction))` — because a dataset change during a replica pause could be lost on failover.
- Output ordering in `beforeSleep()` is load-bearing and commented as such: `connTypeProcessPendingData()` and `clientCompressionProcessPendingData()` must run before `flushAppendOnlyFile(0)`, which must run before `handleClientsWithPendingWrites()` and `sendPendingClientsToIOThreads()` so `appendfsync=always` is satisfied before the reply is sent.
- Blocked-client resumption is sequenced before AOF flushing: `blockedBeforeSleep()` is called with the comment 'must be done before flushAppendOnlyFile, in case of appendfsync=always, since the unblocked clients may write data'.
- Client-side caching invalidation is a distinct output boundary flushed per-iteration: `beforeSleep()` asserts `server.tracking_pending_keys` and `server.pending_push_messages` are empty, then calls `trackingBroadcastInvalidationMessages(NULL)` for BCAST-mode clients.
- On startup the persistence-to-memory direction is owned by `loadDataFromDisk()`, which honours a `preload-file` config prefixed `aof:/` or `rdb:/` (dispatching to `loadPreLoadAOFFile`/`loadPreLoadManifestFile`/`rdbLoad`), else falls back to `loadAppendOnlyFiles(server.aof_manifest)` when AOF is on, else `rdbLoad(server.rdb_filename, ...)`.