middleware

Documentation

Index

• Variables
• type LabeledMiddleware

Variables

var Auth0Middleware endpoint.Middleware = func(ep endpoint.Endpoint) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		println("---- middlewares Auth0Middleware ----")
		accessToken, err := parseAccessToken(ctx)
		if err != nil {
			return &pb.LukeResponse{
				Retcode: pb.Retcode_UNAUTHORIZED,
				Error:   &pb.ErrMsg{Message: err.Error()},
			}, nil
		}
		fmt.Println(accessToken)
		return ep(ctx, request)
	}
}

var LabeleMiddlewareWithTracer = func(tracer otg.Tracer) LabeledMiddleware {
	return func(name string, in endpoint.Endpoint) endpoint.Endpoint {
		return gokitOt.TraceServer(tracer, name)(in)
	}
}

Types

type LabeledMiddleware

type LabeledMiddleware func(string, endpoint.Endpoint) endpoint.Endpoint

var LoggingMiddleware LabeledMiddleware = func(name string, endpoint endpoint.Endpoint) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		println("---- middlewares LoggingMiddleware ----")
		start := time.Now()
		transport := ctx.Value("transport")

		var sourceIP string

		if transport != nil && transport.(string) == "HTTPJSON" {
			if xForwardedFor := ctx.Value("x-forwarded-for"); xForwardedFor != nil {
				frags := strings.Split(xForwardedFor.(string), ",")
				if len(frags) > 0 {
					sourceIP = strings.TrimSpace(frags[0])
				}
			} else if xRealIP := ctx.Value("x-real-ip"); xRealIP != nil {
				sourceIP = strings.TrimSpace(xRealIP.(string))
			} else if ip, _, err := net.SplitHostPort(strings.TrimSpace(ctx.Value("http-remote-addr").(string))); err == nil {
				sourceIP = ip
			}
		} else {
			pr, ok := peer.FromContext(ctx)
			if !ok {
				return nil, fmt.Errorf("invoke FromContext() failed")
			}
			if pr.Addr == net.Addr(nil) {
				return nil, fmt.Errorf("peer.Addr is nil")
			}

			addSlice := strings.Split(pr.Addr.String(), ":")
			if addSlice[0] == "[" {

				sourceIP = "localhost"
			}
			sourceIP = addSlice[0]
		}

		defer func(begin time.Time) {
			took := time.Since(begin)
			fmt.Println("sourceIp", sourceIP, name, "took", took)
		}(start)

		resp, err := endpoint(ctx, request)
		if response, ok := resp.(*pb.LukeResponse); ok {
			response.RequestId = ksuid.New().String()
			if response.Retcode != pb.Retcode_OK {

				fmt.Println(response.Error)
			}
			resp = response
		}
		return resp, err
	}
}