v1.1.0

• Thrift: Mock clients compatible with gomock are now generated for each
  service inside a test subpackage. Disable this by passing a -no-gomock
  flag to the plugin.

v1.0.1

• Thrift: Fixed code generation for empty services.
• Thrift: Fixed code generation for Thrift services that inherit other Thrift
  services.

v1.0.0

• Stable release: No more breaking changes will be made in the 1.x release
  series.

v1.0.0-rc5

• Breaking: The ThriftRW plugin now generates code under the subpackages
  ${service}server and $[service}client rather than
  yarpc/${service}server and yarpc/${service}client.

Given a kv.thrift that defines a KeyValue service, previously the
imports would be,

import ".../kv/yarpc/keyvalueserver"
import ".../kv/yarpc/keyvalueclient"

The same packages will now be available at,

import ".../kv/keyvalueserver"
import ".../kv/keyvalueclient"

• Breaking: NewChannelTransport can now return an error upon
  construction.
• Breaking: http.URLTemplate has no effect on http.NewSingleOutbound.
• http.Transport.NewOutbound now accepts http.OutboundOptions.

v1.0.0-rc4

• Breaking: Removed the yarpc.ReqMeta and yarpc.ResMeta types. To
  migrate your handlers, simply drop the argument and the return value from
  your handler definition.

Before:

func (h *myHandler) Handle(ctx context.Context, reqMeta yarpc.ReqMeta, ...) (..., yarpc.ResMeta, error) {
    // ...
}

After:

func (h *myHandler) Handle(ctx context.Context, ...) (..., error) {
    // ...
}

To access information previously available in the yarpc.ReqMeta or to
write response headers, use the yarpc.CallFromContext function.

• Breaking: Removed the yarpc.CallReqMeta and yarpc.CallResMeta
  types. To migrate your call sites, drop the argument and remove the return
  value.

Before:

res, resMeta, err := client.Call(ctx, reqMeta, ...)

After:

res, err := client.Call(ctx, ...)

Use yarpc.CallOptions to specify per-request options and
yarpc.ResponseHeaders to receive response headers for the call.

• Breaking: Removed yarpc.Headers in favor of map[string]string.
• Breaking: yarpc.Dispatcher no longer implements the
  transport.Router interface.
• Breaking: Start and Stop for Inbound and Outbound are now expected to
  be idempotent.
• Breaking: Combine ServiceProcedure and Registrant into Procedure.
• Breaking: Rename Registrar to RouteTable.
• Breaking: Rename Registry to Router.
• Breaking: Rename middleware.{Oneway,Unary}{Inbound,Outbound}Middleware
  to middleware.{Oneway,Unary}{Inbound,Outbound}
• Breaking: Changed peer.List.Update to accept a peer.ListUpdates
  struct instead of a list of additions and removals
• Breaking: yarpc.NewDispatcher now returns a pointer to a
  yarpc.Dispatcher. Previously, yarpc.Dispatcher was an interface, now a
  concrete struct.

This change will allow us to extend the Dispatcher after the 1.0.0 release
without breaking tests depending on the rigidity of the Dispatcher
interface.

• Breaking: Peer.StartRequest and Peer.EndRequest no longer accept a
  dontNotify argument.
• Added yarpc.IsBadRequestError, yarpc.IsUnexpectedError and
  yarpc.IsTimeoutError functions.
• Added a transport.InboundBadRequestError function to build errors which
  satisfy transport.IsBadRequestError.
• Added a transport.ValidateRequest function to validate
  transport.Requests.

v1.0.0-rc3

• Moved the yarpc/internal/crossdock/ and yarpc/internal/examples
  folders to yarpc/crossdock/ and yarpc/examples respectively.
• Breaking: Relocated the go.uber.org/yarpc/transport package to
  go.uber.org/yarpc/api/transport. In the process the middleware
  logic from transport has been moved to go.uber.org/yarpc/api/middleware
  and the concrete implementation of the Registry has been moved from
  transport.MapRegistry to yarpc.MapRegistry. This did not move the
  concrete implementations of http/tchannel from the yarpc/transport/ directory.
• Breaking: Relocated the go.uber.org/yarpc/peer package to
  go.uber.org/yarpc/api/peer. This does not include the concrete
  implementations still in the /yarpc/peer/ directory.
• Breaking: This version overhauls the code required for constructing
  inbounds and outbounds.

Inbounds and Outbounds now share an underlying Transport, of which there
should be one for each transport protocol, so one HTTP Transport for all
HTTP inbounds and outbounds, and a TChannel transport for all TChannel
inbounds and outbounds.

Before:

ch, err := tchannelProper.NewChannel("example-service", nil)
if err != nil {
    log.Fatalln(err)
}
yarpc.NewDispatcher(yarpc.Config{
    Name: "example-service",
    yarpc.Inbounds{
        http.NewInbound(":80"),
        tchannel.NewInbound(ch, tchannel.ListenAddr(":4040")),
    },
    yarpc.Outbounds{
        http.NewOutbound("http://example-service/rpc/v1"),
        tchannel.NewOutbound(ch, tchannel.HostPort("127.0.0.1:4040")),
    },
})

After:

httpTransport := http.NewTransport()
tchannelTransport := tchannel.NewChannelTransport(
    tchannel.ServiceName("example-service"),
    tchannel.ListenAddr(":4040"),
)
yarpc.NewDispatcher(yarpc.Config{
    Name: "example-service",
    yarpc.Inbounds{
        httpTransport.NewInbound(":80"),
        tchannelTransport.NewInbound(),
    },
    yarpc.Outbounds{
        httpTransport.NewSingleOutbound("http://example-service/rpc/v1"),
        tchannelTransport.NewSingleOutbound("127.0.0.1:4040"),
    },
})

The dispatcher now collects all of the unique transport instances from
inbounds and outbounds and manages their lifecycle independently.

This version repurposed the name NewOutbound for outbounds with a peer
chooser, whereas NewSingleOutbound is a convenience for creating an
outbound addressing a specific single peer.
You may need to rename existing usage. The compiler will complain that
strings are not peer.Chooser instances.

This version introduces support for peer choosers, peer lists, and peer
providers for HTTP outbounds. This is made possible by the above
change that introduces a concrete instance of a Transport for each
protocol, which deduplicates peer instances across all inbounds and
outbounds, making connection sharing and load balancing possible,
eventually for all transport protocols.

Note that we use NewChannelTransport, as opposed to NewTransport.
We reserve this name for a future minor release that will provide
parity with HTTP for outbounds with peer choosers.

The new ChannelTransport constructor can still use a shared TChannel
Channel instance, if that is required.

ch, err := tchannelProper.NewChannel("example-service", nil)
if err != nil {
    log.Fatalln(err)
}
tchannelTransport := tchannel.NewChannelTransport(
    tchannel.WithChannel(ch),
    tchannel.ServiceName("example-service"),
    tchannel.ListenAddr(":4040"),
)
yarpc.NewDispatcher(yarpc.Config{
    Name: "example-service",
    yarpc.Inbounds{
        tchannelTransport.NewInbound(),
    },
})

• Breaking: the transport.Inbound and transport.Outbound interfaces
  now implement Start() without any arguments.

The dispatcher no longer threads a dependencies object through the start
method of every configured transport. The only existing dependency was an
opentracing Tracer, which you can now thread through Transport constructor
options instead.

Before:

yarpc.NewDispatcher(yarpc.Config{
    yarpc.Inbounds{
        http.NewInbound(...),
    },
    yarpc.Outbounds{
        "callee": http.NewOutbound(...)
    },
    Tracer: opentracing.GlobalTracer(),
})

Now:

tracer := opentracing.GlobalTracer()
httpTransport := http.NewTransport(
    http.Tracer(tracer),
)
tchannelTransport := tchannel.NewChannelTransport(
    tchannel.Tracer(tracer),
)
yarpc.NewDispatcher(yarpc.Config{
    Name: "example-service",
    yarpc.Inbounds{
        httpTransport.NewInbound(":80"),
        tchannelTransport.NewInbound(),
    },
    yarpc.Outbounds{
        httpTransport.NewSingleOutbound("http://example-service/rpc/v1"),
        tchannelTransport.NewSingleOutbound("127.0.0.1:4040"),
    },
})

The yarpc.Config Tracer property is still accepted, but unused and
deprecated.

The dispatcher no longer provides a transport.ServiceDetail as an
argument to Start on inbound transports. The transport.ServiceDetail
no longer exists. You no longer need to provide the service name to start
an inbound, only a registry. Instead of passing the service detail to start,
the dispatcher now calls inbound.SetRegistry(transport.Registry) before
calling Start().

Custom transport protocols must change their interface accordingly to
satisfy the transport.Inbound interface. Uses that construct inbounds
manually must either call SetRegistry or use the WithRegistry chained
configuration method before calling Start without a ServiceDetail.

Before:

inbound := tchannel.NewInbound(...)
err := inbound.Start(
    transport.ServiceDetail{
        Name: "service",
        Registry: registry,
    },
    transport.NoDeps,
)

Now:

transport := tchannel.NewTransport()
inbound := transport.NewInbound()
inbound.SetRegistry(registry)
err := inbound.Start()

The transport.Deps struct and transport.NoDeps instance no longer exist.

• Breaking: TChannel inbound and outbound constructors now return
  pointers to Inbound and Outbound structs with private state satisfying the
  transport.Inbound and transport.Outbound interfaces. These were
  previously transport specific Inbound and Outbound interfaces.
  This eliminates unnecessary polymorphism in some cases.
• Introduced OpenTracing helpers for transport authors.
• Created the yarpc.Serialize package for marshalling RPC messages at rest.
  Useful for transports that persist RPC messages.
• Tranports have access to DispatchOnewayHandler and DispatchUnaryHandler.
  These should be called by all transport.Inbounds instead of directly
  calling handlers.

v1.0.0-rc2

• Breaking Renamed Agent to Transport.
• Breaking Renamed hostport.Peer's AddSubscriber/RemoveSubscriber
  to Subscribe/Unsubscribe.
• Breaking Updated Peer.StartRequest to take a dontNotify peer.Subscriber to exempt
  from updates. Also added Peer.EndRequest function to replace the finish callback
  from Peer.StartRequest.
• Breaking Renamed peer.List to peer.Chooser, peer.ChangeListener to peer.List
  and peer.Chooser.ChoosePeer to peer.Chooser.Choose.
• Reduced complexity of single peer.Chooser to retain the passed in peer immediately.
• Breaking Moved /peer/list/single.go to /peer/single/list.go.
• Breaking Moved /peer/x/list/roundrobin.go to /peer/x/roundrobin/list.go.
• HTTP Oneway requests will now process http status codes and returns appropriate errors.
• Breaking Update roundrobin.New function to stop accepting an initial peer list.
  Use list.Update to initialize the peers in the list instead.
• Breaking: Rename Channel to ClientConfig for both the dispatcher
  method and the interface. mydispatcher.Channel("myservice") becomes
  mydispatcher.ClientConfig("myservice"). The ClientConfig object can
  then used to build a new Client as before:
  NewMyThriftClient(mydispatcher.ClientConfig("myservice")).
• A comment is added atop YAML files generated by the recorder to help
  understanding where they come from.

v1.0.0-rc1

• Breaking: Rename the Interceptor and Filter types to
  UnaryInboundMiddleware and UnaryOutboundMiddleware respectively.
• Breaking: yarpc.Config now accepts middleware using the
  InboundMiddleware and OutboundMiddleware fields.

Before:

yarpc.Config{Interceptor: myInterceptor, Filter: myFilter}

Now:

yarpc.Config{
    InboundMiddleware: yarpc.InboundMiddleware{Unary: myInterceptor},
    OutboundMiddleware: yarpc.OutboundMiddleware{Unary: myFilter},
}

• Add support for Oneway middleware via the OnewayInboundMiddleware and
  OnewayOutboundMiddleware interfaces.

v0.5.0

• Breaking: A detail of inbound transports has changed.
  Starting an inbound transport accepts a ServiceDetail, including
  the service name and a Registry. The Registry now must
  implement Choose(context.Context, transport.Request) (HandlerSpec, error)
  instead of GetHandler(service, procedure string) (HandlerSpec, error).
  Note that in the prior release, Handler became HandleSpec to
  accommodate oneway handlers.
• Upgrade to ThriftRW 1.0.
• TChannel: NewInbound and NewOutbound now accept any object satisfying
  the Channel interface. This should work with existing *tchannel.Channel
  objects without any changes.
• Introduced yarpc.Inbounds to be used instead of []transport.Inbound
  when configuring a Dispatcher.
• Add support for peer lists in HTTP outbounds.

v0.4.0

This release requires regeneration of ThriftRW code.

• Breaking: Procedure registration must now always be done directly
  against the Dispatcher. Encoding-specific functions json.Register,
  raw.Register, and thrift.Register have been deprecated in favor of
  the Dispatcher.Register method. Existing code may be migrated by running
  the following commands on your go files.

gofmt -w -r 'raw.Register(d, h) -> d.Register(h)' $file.go
gofmt -w -r 'json.Register(d, h) -> d.Register(h)' $file.go
gofmt -w -r 'thrift.Register(d, h) -> d.Register(h)' $file.go

• Add yarpc.InjectClients to automatically instantiate and inject clients
  into structs that need them.
• Thrift: Add a Protocol option to change the Thrift protocol used by
  clients and servers.
• Breaking: Remove the ability to set Baggage Headers through yarpc, use
  opentracing baggage instead
• Breaking: Transport options have been removed completely. Encoding
  values differently based on the transport is no longer supported.
• Breaking: Thrift requests and responses are no longer enveloped by
  default. The thrift.Enveloped option may be used to turn enveloping on
  when instantiating Thrift clients or registering handlers.
• Breaking: Use of golang.org/x/net/context has been dropped in favor
  of the standard library's context package.
• Add support for providing peer lists to dynamically choose downstream
  peers in HTTP Outbounds
• Rename Handler interface to UnaryHandler and separate Outbound
  interface into Outbound and UnaryOutbound.
• Add OnewayHandler and HandlerSpec to support oneway handlers.
  Transport inbounds can choose which RPC types to accept