What causes "rpc client: call failed: " in geektutu/7days-golang?

Increase the context deadline (context.WithTimeout) to cover expected server latency

rpc client: call failed:

Error message

rpc client: call failed:

What it means

Call() runs the request asynchronously via Go() and blocks on either the context being done or the call's Done channel. If ctx expires or is cancelled first, removeCall drops the pending call and Call returns "rpc client: call failed: " + the context error (deadline exceeded or canceled). The actual RPC may still be executing server-side.

Source

Thrown at gee-rpc/day6-load-balance/client.go:191

	}
	call := &Call{
		ServiceMethod: serviceMethod,
		Args:          args,
		Reply:         reply,
		Done:          done,
	}
	client.send(call)
	return call
}

// Call invokes the named function, waits for it to complete,
// and returns its error status.
func (client *Client) Call(ctx context.Context, serviceMethod string, args, reply interface{}) error {
	call := client.Go(serviceMethod, args, reply, make(chan *Call, 1))
	select {
	case <-ctx.Done():
		client.removeCall(call.Seq)
		return errors.New("rpc client: call failed: " + ctx.Err().Error())
	case call := <-call.Done:
		return call.Error
	}
}

func parseOptions(opts ...*Option) (*Option, error) {
	// if opts is nil or pass nil as parameter
	if len(opts) == 0 || opts[0] == nil {
		return DefaultOption, nil
	}
	if len(opts) != 1 {
		return nil, errors.New("number of options is more than 1")
	}
	opt := opts[0]
	opt.MagicNumber = DefaultOption.MagicNumber
	if opt.CodecType == "" {
		opt.CodecType = DefaultOption.CodecType
	}

View on GitHub (pinned to cf36443821)

Solutions

Increase the context deadline (context.WithTimeout) to cover expected server latency
Check the server-side handler for slowness (blocking I/O, locks) and optimize
Read the wrapped ctx.Err() in the message: DeadlineExceeded means raise the timeout, Canceled means the caller cancelled
Implement retry with a fresh context, but be aware the original call may have executed (idempotency)

Example fix

// before
ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond) // too short

// after
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
if err := client.Call(ctx, "Foo.Bar", args, reply); err != nil {
    if errors.Is(context.Cause(ctx), context.DeadlineExceeded) { /* raise timeout or retry */ }
}

Defensive patterns

Strategy: retry

Try / catch

err := client.Call(ctx, "Foo.Bar", args, reply)
if err != nil && strings.HasPrefix(err.Error(), "rpc client: call failed: ") {
    if ctx.Err() == context.DeadlineExceeded {
        // retry with a longer deadline, or back off
    }
}

Prevention

Set call deadlines comfortably above observed p99 server latency
Make RPC handlers idempotent so context-timeout retries are safe
Propagate parent request budgets so a doomed call is cancelled early
Alert on DeadlineExceeded rates to catch server slowdowns early

When it happens

Trigger: Context deadline exceeded before the server response arrives; context cancelled by the caller (e.g. parent request cancelled); server too slow while a short timeout was set on ctx.

Common situations: HTTP handler timeout (e.g. 30s) shorter than the RPC's processing time; user navigation cancelling a downstream RPC; misconfigured per-call timeouts under load.

Related errors

AI-assisted analysis of geektutu/7days-golang@cf36443821 (2026-09-03). Data as JSON: /api/errors/e9c5d4e658a00266. Report an issue: GitHub.