Recommended way to pass state from Rails app to embedded AnyCable server

[mudge]

We’re currently using an embedded AnyCable server to do our own bookkeeping of connections in Redis and ideally we’d be able to pass extra state (a string ID) from Rails to the server. Is there a recommended way to do this?

It looks like the connection from the Rails side does have state that can be populated but we can’t seem to easily fetch that on the server side using embedding.

As it is, we’re looking at making our own separate RPC calls from the server side but that has complications as we can’t easily share the barrier used by AnyCable’s own RPC client to throttle concurrency as it is private state.

[palkan]

Hey @mudge,

an embedded AnyCable server

Do you mean a custom Go app with the anycable-go embedded or smth else?

If it's a go app, check out our Twilio example: you can use a custom executor (that wraps the default node.Node) and implement a custom logic on top of it (see ReadInternalState): https://github.com/anycable/twilio-ai-demo/blob/487ca2dff533e2c54402388a4356eacd7bc96186/cable/pkg/twilio/executor.go#L268

[mudge]

Do you mean a custom Go app with the anycable-go embedded or smth else?

Yes, a custom Go app that wraps cli.Runner.Embed() to wrap your SSEHandler in our own before and after logic. Ideally we'd be able to get access to data sent back from the Authenticate call to the RPC server in Rails as answered by ApplicationCable::Connection#connect.

Thanks for the pointer to the Twilio example, we'll take a look.

[palkan]

Oh, I see. The SSEHandler is not really extensible at the moment.

I think, in your case, having a custom controller (a wrapper over the default one) could do the trick.

Smth like that in the options for the AnyCable runner:

type CustomController {
  upstream node.Controller
}

func NewCustomController(upstream node.Controller) *CustomController {
  return &CustomController{upstream}
}

func (c *CustomController) Authenticate(ctx context.Context, sid string, env *common.SessionEnv) (res, error) {
   res, err := c.upstream.Authencate(ctx context.Context, sid string, env *common.SessionEnv)
   
   // extract ID from res
   someId = extractFromAuthRes(res)
   
   // you can store in the session env, for example
   env.MergeConnectionState(...)
   
   return res, nil
} 

opts := []cli.Option{
   cli.WithController(func(m *metrics.Metrics, c *config.Config, l *slog.Logger) (node.Controller, error) {
      rpcCtrl, err := rpc.NewController(m, &c.RPC, l)
      
      if err != nil {
         return nil, err
      }
      
      return NewCustomController(rpcCtrl), nil
  }		
}

[mudge]

For posterity, this is effectively what we ended up doing, embedding node.Controller inside our own type:

type CustomController struct {
	node.Controller
}

We then override Authenticate and Disconnect so we can run our own code like so:

func (k *CustomController) Authenticate(ctx context.Context, sid string, env *common.SessionEnv) (*common.ConnectResult, error) {
	res, err := k.Controller.Authenticate(ctx, sid, env)
	// ...
}

func (k *CustomController) Disconnect(ctx context.Context, sid string, env *common.SessionEnv, ids string, subscriptions []string) error {
	// ...
	err := k.Controller.Disconnect(ctx, sid, env, ids, subscriptions)
	// ...
}