transport

type GenericMessage struct {
	IDField               string
	SenderField           string
	ReceiverField         string
	SenderEndpointField   string
	ReceiverEndpointField string
	ReceiverVersionField  string
	HeadersField          map[string]string
	PayloadField          []byte
	ErrField              error
}

type Handler interface {
	Process(req ImmutableMessage, res Message)
}

type HandlerFunc func(req ImmutableMessage, res Message)

type ImmutableMessage interface {
	// ImmutableMessage implements io.Closer. All messages should be closed
	// when they are no longer being used.
	io.Closer

	// ID returns a UUID for this message.
	ID() string

	// Sender returns the name of the service that sent the mesage.
	Sender() string

	// SenderEndpoint returns the endpoint where the message originated.
	SenderEndpoint() string

	// Receiver returns the name of the service that will receive the message.
	Receiver() string

	// ReceiverEndpoint returns the endpoint where the message should be delivered at.
	ReceiverEndpoint() string

	// ReceiverVersion returns the requested receiving service's version.
	ReceiverVersion() string

	// Headers returns a map of header values associated with the message.
	Headers() map[string]string

	// Payload returns the payload associated with the message as a byte
	// slice or an error if one is encoded in the message.
	Payload() ([]byte, error)
}

type Message interface {
	ImmutableMessage

	// SetPayload sets the content of this message. The content may be either
	// a byte slice or an error message.
	SetPayload(payload []byte, err error)

	// SetHeader sets the content of a message header to the specified value.
	// If the specified header already exists, its value will be overwritten
	// by the new value.
	//
	// This method must ensure that header names are always canonicalized
	// using an algorithm similar to http.CanonicalHeaderKey.
	SetHeader(name, value string)

	// SetHeaders sets the contents of a batch of headers. This is equivalent
	// to iterating the map and calling SetHeader for each key/value.
	SetHeaders(headers map[string]string)

	// SetReceiverVersion sets the required version for the receiving service.
	SetReceiverVersion(string)
}

type Mode bool

type Provider interface {
	// Dial connects to the transport using the specified dial mode. When
	// the dial mode is set to DialModeServer the transport will start
	// relaying messages to registered bindings.
	Dial(mode Mode) error

	// Close terminates a dialed connection using the specified dial mode.
	Close(mode Mode) error

	// Bind listens for messages send to a particular service and
	// endpoint combination and invokes the supplied handler to process them.
	//
	// Transports may implement versioning for bindings in order to support
	// complex deployment flows such as blue-green deployments.
	Bind(version, service, endpoint string, handler Handler) error

	// Unbind removes a message handler previously registered by a call to Bind().
	// Calling Unbind with a (version, service, endpoint) tuple that is not
	// registered has no effect.
	Unbind(version, service, endpoint string)

	// Request performs an RPC and returns back a read-only channel for
	// receiving the result.
	Request(msg Message) <-chan ImmutableMessage
}