Function validateMessage

pkg/rpcmiddleware/validator/validator.go:100–183

(ctx context.Context, fullMethod string, msg any)

)

func validateMessage(ctx context.Context, fullMethod string, msg any) error {
	var paths []string
	switch v := msg.(type) {
	case interface {
		GetFieldMask() *fieldmaskpb.FieldMask
	}:
		paths = v.GetFieldMask().GetPaths()
	}
	if len(paths) > 0 {
		region := trace.StartRegion(ctx, "validate field mask")

		if forbiddenPaths := forbiddenPaths(paths, allowedFieldMaskPaths[fullMethod]); len(forbiddenPaths) > 0 {
			region.End()
			return errForbiddenFieldMaskPaths.WithAttributes("forbidden_paths", forbiddenPaths)
		}

		isZeroPaths, ok := isZeroFieldMaskPaths[fullMethod]
		if ok && len(isZeroPaths) > 0 {
			var isZero func(string) bool
		outer:
			for _, p := range paths {
				prefix := p + "."
				i := sort.Search(len(isZeroPaths), func(i int) bool {
					return strings.HasPrefix(isZeroPaths[i], prefix)
				})
				if i == len(isZeroPaths) || !strings.HasPrefix(isZeroPaths[i], prefix) {
					continue
				}
				tail := isZeroPaths[i+1:]
				for _, sp := range isZeroPaths[i : i+1+sort.Search(len(tail), func(j int) bool {
					return !strings.HasPrefix(tail[j], prefix)
				})] {
					if isZero == nil {
						if v, ok := msg.(interface {
							FieldIsZero(string) bool
						}); ok {
							isZero = v.FieldIsZero
						} else {
							break outer
						}
					}
					if !isZero(sp) {
						region.End()
						return errNonZeroPath.WithAttributes("path", sp)
					}
				}
			}
		}
		region.End()
	}

	switch v := msg.(type) {
	case interface {
		ValidateContext(context.Context) error
	}:
		defer trace.StartRegion(ctx, "validate with context").End()
		if err := v.ValidateContext(ctx); err != nil {
			return convertError(err)