Package endpoint

func Nop ¶

func Nop(context.Context, interface{}) (interface{}, error)

Nop is an endpoint that does nothing and returns a nil error. Useful for tests.

type Endpoint ¶

Endpoint is the fundamental building block of servers and clients. It represents a single RPC method.

type Endpoint func(ctx context.Context, request interface{}) (response interface{}, err error)

type Failer ¶

Failer may be implemented by Go kit response types that contain business logic error details. If Failed returns a non-nil error, the Go kit transport layer may interpret this as a business logic error, and may encode it differently than a regular, successful response.

It's not necessary for your response types to implement Failer, but it may help for more sophisticated use cases. The addsvc example shows how Failer should be used by a complete application.

type Failer interface {
    Failed() error
}

type Middleware ¶

Middleware is a chainable behavior modifier for endpoints.

type Middleware func(Endpoint) Endpoint

func Chain ¶

func Chain(outer Middleware, others ...Middleware) Middleware

Chain is a helper function for composing middlewares. Requests will traverse them in the order they're declared. That is, the first middleware is treated as the outermost middleware.

package endpoint_test

import (
    "context"
    "fmt"

    "github.com/go-kit/kit/endpoint"
)

func ExampleChain() {
    e := endpoint.Chain(
        annotate("first"),
        annotate("second"),
        annotate("third"),
    )(myEndpoint)

    if _, err := e(ctx, req); err != nil {
        panic(err)
    }

    // Output:
    // first pre
    // second pre
    // third pre
    // my endpoint!
    // third post
    // second post
    // first post
}

var (
    ctx = context.Background()
    req = struct{}{}
)

func annotate(s string) endpoint.Middleware {
    return func(next endpoint.Endpoint) endpoint.Endpoint {
        return func(ctx context.Context, request interface{}) (interface{}, error) {
            fmt.Println(s, "pre")
            defer fmt.Println(s, "post")
            return next(ctx, request)
        }
    }
}

func myEndpoint(context.Context, interface{}) (interface{}, error) {
    fmt.Println("my endpoint!")
    return struct{}{}, nil
}