Changelog

View Source

All notable changes to this project are documented here. The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[Unreleased]

[0.1.1] - 2026-06-13

Added

  • Client interop check against a real grpc-go server (make interop-client, skipped without Go), proving livery_grpc_client calls services that are not written in Erlang (unary and server-streaming over the standard health service).

Fixed

[0.1.0] - 2026-06-13

First release. gRPC for Erlang on the livery HTTP/2 stack: server and client, all four call types, and the surrounding ecosystem.

Added

  • Project scaffold: OTP application, supervisor, build pipeline with gpb and rebar3_gpb_plugin, sample helloworld.proto.
  • Wire layer: livery_grpc_frame (length-prefixed framing + streaming decoder), livery_grpc_status (canonical codes, grpc-message encoding, trailers), livery_grpc_compression (identity + gzip), livery_grpc_codec (gpb glue + content-type checks). Property and unit tests.
  • livery_grpc_service: method descriptors derived from gpb introspection (wire path, message types, call kind, snake_case callback name) and a path-keyed routing index.
  • Server: livery_grpc:start_server/1 runs gRPC on a dedicated h2 listener; livery_grpc_server dispatches POST /pkg.Svc/Method to the bound callback module. Unary and server-streaming, with status in trailers (and Trailers-Only for pre-dispatch errors). End-to-end tests over h2c cover success, error status, handler crash, unknown method, and streaming.
  • Client: livery_grpc_client calls gRPC services over the h2 client (unary and server-streaming), with metadata and gzip. livery_grpc_wire centralises message encode/decode for both sides. In-tree client tests cover unary, error status, server-streaming, and gzip both directions.
  • Cross-cutting: grpc-timeout deadlines (client sends and bounds the wait; server parses, exposes in the context, and aborts a unary handler that overruns), error details via grpc-status-details-bin, request metadata, and livery middleware as gRPC interceptors.
  • Health: the standard grpc.health.v1.Health service (livery_grpc_health:service/0), with per-service serving status. Check is unary; Watch emits the current status once (live updates follow the bidirectional work).
  • gRPC-Web: livery_grpc_web framing on the same server (binary and text), with the status delivered as an in-body trailer frame. Unary and server-streaming. Reflection is deferred: its RPC is bidirectional and waits on the h2 bidi work.
  • Example (greeter_example), a quickstart guide, and a grpcurl interop smoke test (make interop) confirming on-the-wire compliance with an external gRPC client.
  • Client-streaming and bidirectional streaming on both sides, on h2 0.10.0. The server reads requests through a livery_grpc_stream handle and interleaves replies in the chunked producer; the client adds client_stream/3,4 and open/2,3 + send/2 + send_end/1 + recv/1,2. All four call types are verified against grpcurl.
  • Client interceptor stack, the outbound twin of livery's server middleware: interceptors on connect/3 or per call, with before/1, after_response/1, and wrap/1, matching the livery_client layer shape (Tower layers on the BEAM).
  • Server reflection (grpc.reflection.v1): enable with reflection => true and tools like grpcurl discover services and message schemas at runtime, with no local .proto. Verified with grpcurl list, describe, and a fully reflective call.
  • Health Watch now streams live updates: it emits the current status and a new message on every change until the client disconnects, backed by a small subscription store (livery_grpc_health_store).
  • Code generation (livery_grpc_codegen, make stubs): per service, an erpc-style client stub (greeter_client:say_hello/2) and a service behaviour (-behaviour(greeter_service)) for compiler-checked handlers.

Changed

  • Servers are now owned by a supervised process (livery_grpc_listener under livery_grpc_server_sup) instead of the caller, so a server started from a short-lived process keeps running. start_server/1 returns the listener owner pid.

Added (testing)

  • livery_grpc_e2e_SUITE, a Common Test end-to-end suite against a real running server: the full journey with the in-tree client, and the same calls driven by grpcurl over reflection (skipped if grpcurl is absent).

Added (docs and example)

  • A documentation set in the style of grpc.io with Erlang snippets: Introduction, Core concepts, Getting started, a Basics tutorial built on a real RouteGuide example, a Design guide for the Erlang integration, an Erlang-integration how-to, and task-oriented guides modeled on the gRPC guides (streaming, metadata, interceptors, deadlines, cancellation, error handling, status codes, compression, authentication, health, reflection, retry, graceful shutdown, flow control, wait-for-ready, gRPC-Web, generated stubs, testing). All wired into ex_doc.
  • examples/route_guide.erl + proto/route_guide.proto: the RouteGuide example, exercising all four call types, with an eunit suite.
  • livery_grpc_client:cancel/1 cancels a streaming call.