Function reflectHandler

lambda/handler.go:239–351

(f interface{}, h *handlerOptions)

}

func reflectHandler(f interface{}, h *handlerOptions) handlerFunc {
	if f == nil {
		return errorHandler(errors.New("handler is nil"))
	}

	// back-compat: types with reciever `Invoke(context.Context, []byte) ([]byte, error)` need the return bytes wrapped
	if handler, ok := f.(Handler); ok {
		return func(ctx context.Context, payload []byte) (io.Reader, error) {
			b, err := handler.Invoke(ctx, payload)
			if err != nil {
				return nil, err
			}
			return bytes.NewBuffer(b), nil
		}
	}

	handler := reflect.ValueOf(f)
	handlerType := reflect.TypeOf(f)
	if handlerType.Kind() != reflect.Func {
		return errorHandler(fmt.Errorf("handler kind %s is not %s", handlerType.Kind(), reflect.Func))
	}

	takesContext, err := handlerTakesContext(handlerType)
	if err != nil {
		return errorHandler(err)
	}

	if err := validateReturns(handlerType); err != nil {
		return errorHandler(err)
	}

	return func(ctx context.Context, payload []byte) (outFinal io.Reader, _ error) {
		in := bytes.NewBuffer(payload)
		decoder := json.NewDecoder(in)
		if h.jsonRequestUseNumber {
			decoder.UseNumber()
		}
		if h.jsonRequestDisallowUnknownFields {
			decoder.DisallowUnknownFields()
		}

		out := h.jsonOutBufferPool.Get().(*jsonOutBuffer)
		defer func() {
			// If the final return value is not our buffer, reset and return it to the pool.
			// The caller of the handlerFunc does this otherwise.
			if outFinal != out {
				out.Close()
			}
		}()
		encoder := json.NewEncoder(out)
		encoder.SetEscapeHTML(h.jsonResponseEscapeHTML)
		encoder.SetIndent(h.jsonResponseIndentPrefix, h.jsonResponseIndentValue)

		trace := handlertrace.FromContext(ctx)

		// construct arguments
		var args []reflect.Value
		if takesContext {