mirror of
https://github.com/luxfi/netrunner.git
synced 2026-07-27 00:04:23 +00:00
Hanzo AI
301a8e2601
Per the project rule 'ZAP internal, ZIP edge': netrunner's 26-method
ControlService + PingService move off google.golang.org/grpc and
grpc-gateway onto a luxfi/zap envelope. Default builds now have ZERO
google.golang.org/grpc transitive deps.
New package: netrunner/zaprpc/
- protocol.go: MsgType (uint8 range, encoded in ZAP flags upper byte).
One stable wire ID per method. Append-only.
- dispatch.go: typed Bind[Req, Resp](d, msg, handler) — register a
'func(ctx, *Req) (*Resp, error)' handler. JSON encode/decode +
envelope framing happen here, handlers stay business-logic-only.
- server.go: thin wrapper around zap.Node hosting a Dispatcher.
- client.go: typed Call[Req, Resp](ctx, c, msg, req) — same DX as the
old gRPC client but transport is ZAP. Includes connect-retry around
the boot race.
server/bind.go: one-shot registration of all 26 RPC methods onto a
Dispatcher. The canonical map of 'what this server exposes'.
server/server.go: gRPC server + grpc-gateway HTTP bridge are gone.
Run() now starts the ZAP server and waits for rootCtx.Done. The
'soldier-on' isClientCanceled helper goes with the gRPC stream code.
client/client.go: full rewrite. Same Client interface (28 methods),
implementation is now one-line zaprpc.Call per method. StreamStatus
becomes a client-driven Status() poll on the requested interval —
ZAP has no native server-streaming, but the observable contract
(channel of ClusterInfo) is unchanged.
Deleted:
- rpcpb/rpc_grpc.pb.go (gRPC service stubs)
- rpcpb/rpc.pb.gw.go (grpc-gateway HTTP bridge)
The rpcpb message types (rpc.pb.go) stay — they're plain Go structs
with json: tags, used as the JSON payload format inside ZAP envelopes.
A future cleanup pass can replace them with hand-written structs to
drop google.golang.org/protobuf from the dep tree too.
go.mod cleanup: drop github.com/grpc-ecosystem/grpc-gateway/v2,
google.golang.org/grpc, google.golang.org/genproto/googleapis/api.
Pin luxfi/proto v1.0.0 (was luxfi/protocol v0.0.4 — stale rename
artifact). Add luxfi/zap v0.2.0.
Tests: zaprpc/zaprpc_test.go round-trips request/response and proves
the error path propagates through the envelope.
No backwards compat — forwards perfection per the project rule.
67 lines
1.7 KiB
Go
67 lines
1.7 KiB
Go
// Copyright (C) 2021-2026, Lux Industries Inc. All rights reserved.
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
package zaprpc
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
|
|
"github.com/luxfi/zap"
|
|
)
|
|
|
|
// ServerConfig configures a netrunner ZAP server.
|
|
type ServerConfig struct {
|
|
NodeID string // human-readable identifier, e.g. "netrunner-server"
|
|
Port int // TCP port to listen on
|
|
Logger *slog.Logger
|
|
}
|
|
|
|
// Server is a thin wrapper around zap.Node that hosts a Dispatcher.
|
|
type Server struct {
|
|
node *zap.Node
|
|
disp *Dispatcher
|
|
}
|
|
|
|
// NewServer constructs a ZAP server that will dispatch to the handlers
|
|
// registered on the given Dispatcher.
|
|
func NewServer(cfg ServerConfig, disp *Dispatcher) *Server {
|
|
if cfg.Logger == nil {
|
|
cfg.Logger = slog.Default()
|
|
}
|
|
node := zap.NewNode(zap.NodeConfig{
|
|
NodeID: cfg.NodeID,
|
|
ServiceType: "_netrunner._tcp",
|
|
Port: cfg.Port,
|
|
Logger: cfg.Logger,
|
|
NoDiscovery: true, // netrunner clients dial directly, no mDNS needed
|
|
})
|
|
disp.AttachTo(node)
|
|
return &Server{node: node, disp: disp}
|
|
}
|
|
|
|
// Start binds the listener. Run inside its own goroutine — call Stop to wind down.
|
|
func (s *Server) Start() error {
|
|
if err := s.node.Start(); err != nil {
|
|
return fmt.Errorf("zaprpc server start: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Stop gracefully closes the listener and all peer connections.
|
|
func (s *Server) Stop() {
|
|
s.node.Stop()
|
|
}
|
|
|
|
// Wait blocks until the server's context is canceled. Useful in main().
|
|
func (s *Server) Wait(ctx context.Context) {
|
|
<-ctx.Done()
|
|
}
|
|
|
|
// Node returns the underlying ZAP node — primarily for tests and for
|
|
// server-side pushes to subscribed clients.
|
|
func (s *Server) Node() *zap.Node {
|
|
return s.node
|
|
}
|