package http import ( "context" "fmt" "net/http" "github.com/unistack-org/micro/v3/server" ) type rspCodeKey struct{} type rspCodeVal struct { code int } // SetError pass error to caller func SetError(err interface{}) error { return &Error{err: err} } // Error struct holds error type Error struct { err interface{} } // Error func for error interface func (err *Error) Error() string { return fmt.Sprintf("%v", err.err) } // SetRspCode saves response code in context, must be used by handler to specify http code func SetRspCode(ctx context.Context, code int) { if rsp, ok := ctx.Value(rspCodeKey{}).(*rspCodeVal); ok { rsp.code = code } } // GetRspCode used internally by generated http server handler func GetRspCode(ctx context.Context) int { var code int if rsp, ok := ctx.Value(rspCodeKey{}).(*rspCodeVal); ok { code = rsp.code } return code } type middlewareKey struct{} // Middleware passes http middlewares func Middleware(mw ...func(http.Handler) http.Handler) server.Option { return server.SetOption(middlewareKey{}, mw) } type serverKey struct{} // Server provide ability to pass *http.Server func Server(hs *http.Server) server.Option { return server.SetOption(serverKey{}, hs) } type errorHandlerKey struct{} // ErrorHandler specifies handler for errors func ErrorHandler(fn func(ctx context.Context, s server.Handler, w http.ResponseWriter, r *http.Request, err error, status int)) server.Option { return server.SetOption(errorHandlerKey{}, fn) } type pathHandlerKey struct{} type pathHandlerVal struct { h map[string]http.HandlerFunc } // PathHandler specifies http handler for path regexp func PathHandler(path string, h http.HandlerFunc) server.Option { return func(o *server.Options) { if o.Context == nil { o.Context = context.Background() } v, ok := o.Context.Value(pathHandlerKey{}).(*pathHandlerVal) if !ok { v = &pathHandlerVal{h: make(map[string]http.HandlerFunc)} } v.h[path] = h o.Context = context.WithValue(o.Context, pathHandlerKey{}, v) } }