update prometheus dependencies (#5520)

Signed-off-by: junot <junotxiang@kubesphere.io>

vendor/github.com/go-openapi/spec/schema_loader.go

@@ -25,35 +25,50 @@ import (
 	"github.com/go-openapi/swag"
 )
 
-// PathLoader function to use when loading remote refs
-var PathLoader func(string) (json.RawMessage, error)
-
-func init() {
-	PathLoader = func(path string) (json.RawMessage, error) {
-		data, err := swag.LoadFromFileOrHTTP(path)
-		if err != nil {
-			return nil, err
-		}
-		return json.RawMessage(data), nil
+// PathLoader is a function to use when loading remote refs.
+//
+// This is a package level default. It may be overridden or bypassed by
+// specifying the loader in ExpandOptions.
+//
+// NOTE: if you are using the go-openapi/loads package, it will override
+// this value with its own default (a loader to retrieve YAML documents as
+// well as JSON ones).
+var PathLoader = func(pth string) (json.RawMessage, error) {
+	data, err := swag.LoadFromFileOrHTTP(pth)
+	if err != nil {
+		return nil, err
 	}
+	return json.RawMessage(data), nil
 }
 
 // resolverContext allows to share a context during spec processing.
 // At the moment, it just holds the index of circular references found.
 type resolverContext struct {
-	// circulars holds all visited circular references, which allows shortcuts.
-	// NOTE: this is not just a performance improvement: it is required to figure out
-	// circular references which participate several cycles.
+	// circulars holds all visited circular references, to shortcircuit $ref resolution.
+	//
 	// This structure is privately instantiated and needs not be locked against
 	// concurrent access, unless we chose to implement a parallel spec walking.
 	circulars map[string]bool
 	basePath  string
+	loadDoc   func(string) (json.RawMessage, error)
+	rootID    string
 }
 
-func newResolverContext(originalBasePath string) *resolverContext {
+func newResolverContext(options *ExpandOptions) *resolverContext {
+	expandOptions := optionsOrDefault(options)
+
+	// path loader may be overridden by options
+	var loader func(string) (json.RawMessage, error)
+	if expandOptions.PathLoader == nil {
+		loader = PathLoader
+	} else {
+		loader = expandOptions.PathLoader
+	}
+
 	return &resolverContext{
 		circulars: make(map[string]bool),
-		basePath:  originalBasePath, // keep the root base path in context
+		basePath:  expandOptions.RelativeBase, // keep the root base path in context
+		loadDoc:   loader,
 	}
 }
 
@@ -62,21 +77,20 @@ type schemaLoader struct {
 	options *ExpandOptions
 	cache   ResolutionCache
 	context *resolverContext
-	loadDoc func(string) (json.RawMessage, error)
 }
 
-func (r *schemaLoader) transitiveResolver(basePath string, ref Ref) (*schemaLoader, error) {
+func (r *schemaLoader) transitiveResolver(basePath string, ref Ref) *schemaLoader {
 	if ref.IsRoot() || ref.HasFragmentOnly {
-		return r, nil
+		return r
 	}
 
-	baseRef, _ := NewRef(basePath)
-	currentRef := normalizeFileRef(&ref, basePath)
+	baseRef := MustCreateRef(basePath)
+	currentRef := normalizeRef(&ref, basePath)
 	if strings.HasPrefix(currentRef.String(), baseRef.String()) {
-		return r, nil
+		return r
 	}
 
-	// Set a new root to resolve against
+	// set a new root against which to resolve
 	rootURL := currentRef.GetURL()
 	rootURL.Fragment = ""
 	root, _ := r.cache.Get(rootURL.String())
@@ -85,35 +99,36 @@ func (r *schemaLoader) transitiveResolver(basePath string, ref Ref) (*schemaLoad
 	// traversing multiple documents
 	newOptions := r.options
 	newOptions.RelativeBase = rootURL.String()
-	debugLog("setting new root: %s", newOptions.RelativeBase)
+
 	return defaultSchemaLoader(root, newOptions, r.cache, r.context)
 }
 
 func (r *schemaLoader) updateBasePath(transitive *schemaLoader, basePath string) string {
 	if transitive != r {
-		debugLog("got a new resolver")
 		if transitive.options != nil && transitive.options.RelativeBase != "" {
-			basePath, _ = absPath(transitive.options.RelativeBase)
-			debugLog("new basePath = %s", basePath)
+			return normalizeBase(transitive.options.RelativeBase)
 		}
 	}
+
 	return basePath
 }
 
 func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string) error {
 	tgt := reflect.ValueOf(target)
 	if tgt.Kind() != reflect.Ptr {
-		return fmt.Errorf("resolve ref: target needs to be a pointer")
+		return ErrResolveRefNeedsAPointer
 	}
 
-	refURL := ref.GetURL()
-	if refURL == nil {
+	if ref.GetURL() == nil {
 		return nil
 	}
 
-	var res interface{}
-	var data interface{}
-	var err error
+	var (
+		res  interface{}
+		data interface{}
+		err  error
+	)
+
 	// Resolve against the root if it isn't nil, and if ref is pointing at the root, or has a fragment only which means
 	// it is pointing somewhere in the root.
 	root := r.root
@@ -122,12 +137,11 @@ func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string)
 			root, _, _, _ = r.load(baseRef.GetURL())
 		}
 	}
+
 	if (ref.IsRoot() || ref.HasFragmentOnly) && root != nil {
 		data = root
 	} else {
-		baseRef := normalizeFileRef(ref, basePath)
-		debugLog("current ref is: %s", ref.String())
-		debugLog("current ref normalized file: %s", baseRef.String())
+		baseRef := normalizeRef(ref, basePath)
 		data, _, _, err = r.load(baseRef.GetURL())
 		if err != nil {
 			return err
@@ -150,52 +164,60 @@ func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error)
 	toFetch.Fragment = ""
 
 	var err error
-	path := toFetch.String()
-	if path == rootBase {
-		path, err = absPath(rootBase)
-		if err != nil {
-			return nil, url.URL{}, false, err
-		}
-	}
-	normalized := normalizeAbsPath(path)
+	pth := toFetch.String()
+	normalized := normalizeBase(pth)
+	debugLog("loading doc from: %s", normalized)
 
-	data, fromCache := r.cache.Get(normalized)
-	if !fromCache {
-		b, err := r.loadDoc(normalized)
-		if err != nil {
-			debugLog("unable to load the document: %v", err)
-			return nil, url.URL{}, false, err
-		}
-
-		if err := json.Unmarshal(b, &data); err != nil {
-			return nil, url.URL{}, false, err
-		}
-		r.cache.Set(normalized, data)
+	unescaped, err := url.PathUnescape(normalized)
+	if err != nil {
+		return nil, url.URL{}, false, err
 	}
 
-	return data, toFetch, fromCache, nil
+	u := url.URL{Path: unescaped}
+
+	data, fromCache := r.cache.Get(u.RequestURI())
+	if fromCache {
+		return data, toFetch, fromCache, nil
+	}
+
+	b, err := r.context.loadDoc(normalized)
+	if err != nil {
+		return nil, url.URL{}, false, err
+	}
+
+	var doc interface{}
+	if err := json.Unmarshal(b, &doc); err != nil {
+		return nil, url.URL{}, false, err
+	}
+	r.cache.Set(normalized, doc)
+
+	return doc, toFetch, fromCache, nil
 }
 
 // isCircular detects cycles in sequences of $ref.
+//
 // It relies on a private context (which needs not be locked).
 func (r *schemaLoader) isCircular(ref *Ref, basePath string, parentRefs ...string) (foundCycle bool) {
-	normalizedRef := normalizePaths(ref.String(), basePath)
+	normalizedRef := normalizeURI(ref.String(), basePath)
 	if _, ok := r.context.circulars[normalizedRef]; ok {
 		// circular $ref has been already detected in another explored cycle
 		foundCycle = true
 		return
 	}
-	foundCycle = swag.ContainsStringsCI(parentRefs, normalizedRef)
+	foundCycle = swag.ContainsStrings(parentRefs, normalizedRef) // normalized windows url's are lower cased
 	if foundCycle {
 		r.context.circulars[normalizedRef] = true
 	}
 	return
 }
 
-// Resolve resolves a reference against basePath and stores the result in target
-// Resolve is not in charge of following references, it only resolves ref by following its URL
-// if the schema that ref is referring to has more refs in it. Resolve doesn't resolve them
-// if basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct
+// Resolve resolves a reference against basePath and stores the result in target.
+//
+// Resolve is not in charge of following references: it only resolves ref by following its URL.
+//
+// If the schema the ref is referring to holds nested refs, Resolve doesn't resolve them.
+//
+// If basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct
 func (r *schemaLoader) Resolve(ref *Ref, target interface{}, basePath string) error {
 	return r.resolveRef(ref, target, basePath)
 }
@@ -212,30 +234,32 @@ func (r *schemaLoader) deref(input interface{}, parentRefs []string, basePath st
 	case *PathItem:
 		ref = &refable.Ref
 	default:
-		return fmt.Errorf("deref: unsupported type %T", input)
+		return fmt.Errorf("unsupported type: %T: %w", input, ErrDerefUnsupportedType)
 	}
 
 	curRef := ref.String()
-	if curRef != "" {
-		normalizedRef := normalizeFileRef(ref, basePath)
-		normalizedBasePath := normalizedRef.RemoteURI()
-
-		if r.isCircular(normalizedRef, basePath, parentRefs...) {
-			return nil
-		}
-
-		if err := r.resolveRef(ref, input, basePath); r.shouldStopOnError(err) {
-			return err
-		}
-
-		// NOTE(fredbi): removed basePath check => needs more testing
-		if ref.String() != "" && ref.String() != curRef {
-			parentRefs = append(parentRefs, normalizedRef.String())
-			return r.deref(input, parentRefs, normalizedBasePath)
-		}
+	if curRef == "" {
+		return nil
 	}
 
-	return nil
+	normalizedRef := normalizeRef(ref, basePath)
+	normalizedBasePath := normalizedRef.RemoteURI()
+
+	if r.isCircular(normalizedRef, basePath, parentRefs...) {
+		return nil
+	}
+
+	if err := r.resolveRef(ref, input, basePath); r.shouldStopOnError(err) {
+		return err
+	}
+
+	if ref.String() == "" || ref.String() == curRef {
+		// done with rereferencing
+		return nil
+	}
+
+	parentRefs = append(parentRefs, normalizedRef.String())
+	return r.deref(input, parentRefs, normalizedBasePath)
 }
 
 func (r *schemaLoader) shouldStopOnError(err error) bool {
@@ -250,30 +274,65 @@ func (r *schemaLoader) shouldStopOnError(err error) bool {
 	return false
 }
 
+func (r *schemaLoader) setSchemaID(target interface{}, id, basePath string) (string, string) {
+	debugLog("schema has ID: %s", id)
+
+	// handling the case when id is a folder
+	// remember that basePath has to point to a file
+	var refPath string
+	if strings.HasSuffix(id, "/") {
+		// ensure this is detected as a file, not a folder
+		refPath = fmt.Sprintf("%s%s", id, "placeholder.json")
+	} else {
+		refPath = id
+	}
+
+	// updates the current base path
+	// * important: ID can be a relative path
+	// * registers target to be fetchable from the new base proposed by this id
+	newBasePath := normalizeURI(refPath, basePath)
+
+	// store found IDs for possible future reuse in $ref
+	r.cache.Set(newBasePath, target)
+
+	// the root document has an ID: all $ref relative to that ID may
+	// be rebased relative to the root document
+	if basePath == r.context.basePath {
+		debugLog("root document is a schema with ID: %s (normalized as:%s)", id, newBasePath)
+		r.context.rootID = newBasePath
+	}
+
+	return newBasePath, refPath
+}
+
 func defaultSchemaLoader(
 	root interface{},
 	expandOptions *ExpandOptions,
 	cache ResolutionCache,
-	context *resolverContext) (*schemaLoader, error) {
+	context *resolverContext) *schemaLoader {
 
-	if cache == nil {
-		cache = resCache
-	}
 	if expandOptions == nil {
 		expandOptions = &ExpandOptions{}
 	}
-	absBase, _ := absPath(expandOptions.RelativeBase)
-	if context == nil {
-		context = newResolverContext(absBase)
+
+	cache = cacheOrDefault(cache)
+
+	if expandOptions.RelativeBase == "" {
+		// if no relative base is provided, assume the root document
+		// contains all $ref, or at least, that the relative documents
+		// may be resolved from the current working directory.
+		expandOptions.RelativeBase = baseForRoot(root, cache)
 	}
+	debugLog("effective expander options: %#v", expandOptions)
+
+	if context == nil {
+		context = newResolverContext(expandOptions)
+	}
+
 	return &schemaLoader{
 		root:    root,
 		options: expandOptions,
 		cache:   cache,
 		context: context,
-		loadDoc: func(path string) (json.RawMessage, error) {
-			debugLog("fetching document at %q", path)
-			return PathLoader(path)
-		},
-	}, nil
+	}
 }