update prometheus dependencies (#5520)

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

vendor/github.com/go-openapi/analysis/analyzer.go

@@ -149,6 +149,7 @@ func New(doc *spec.Swagger) *Spec {
 	}
 	a.reset()
 	a.initialize()
+
 	return a
 }
 
@@ -212,7 +213,7 @@ func (s *Spec) initialize() {
 		}
 	}
 	for path, pathItem := range s.AllPaths() {
-		s.analyzeOperations(path, &pathItem)
+		s.analyzeOperations(path, &pathItem) //#nosec
 	}
 
 	for name, parameter := range s.spec.Parameters {
@@ -277,7 +278,7 @@ func (s *Spec) analyzeOperations(path string, pi *spec.PathItem) {
 	for i, param := range op.Parameters {
 		refPref := slashpath.Join("/paths", jsonpointer.Escape(path), "parameters", strconv.Itoa(i))
 		if param.Ref.String() != "" {
-			s.references.addParamRef(refPref, &param)
+			s.references.addParamRef(refPref, &param) //#nosec
 		}
 		if param.Pattern != "" {
 			s.patterns.addParameterPattern(refPref, param.Pattern)
@@ -311,6 +312,26 @@ func (s *Spec) analyzeItems(name string, items *spec.Items, prefix, location str
 	}
 }
 
+func (s *Spec) analyzeParameter(prefix string, i int, param spec.Parameter) {
+	refPref := slashpath.Join(prefix, "parameters", strconv.Itoa(i))
+	if param.Ref.String() != "" {
+		s.references.addParamRef(refPref, &param) //#nosec
+	}
+
+	if param.Pattern != "" {
+		s.patterns.addParameterPattern(refPref, param.Pattern)
+	}
+
+	if len(param.Enum) > 0 {
+		s.enums.addParameterEnum(refPref, param.Enum)
+	}
+
+	s.analyzeItems("items", param.Items, refPref, "parameter")
+	if param.In == "body" && param.Schema != nil {
+		s.analyzeSchema("schema", param.Schema, refPref)
+	}
+}
+
 func (s *Spec) analyzeOperation(method, path string, op *spec.Operation) {
 	if op == nil {
 		return
@@ -319,72 +340,80 @@ func (s *Spec) analyzeOperation(method, path string, op *spec.Operation) {
 	for _, c := range op.Consumes {
 		s.consumes[c] = struct{}{}
 	}
+
 	for _, c := range op.Produces {
 		s.produces[c] = struct{}{}
 	}
+
 	for _, ss := range op.Security {
 		for k := range ss {
 			s.authSchemes[k] = struct{}{}
 		}
 	}
+
 	if _, ok := s.operations[method]; !ok {
 		s.operations[method] = make(map[string]*spec.Operation)
 	}
+
 	s.operations[method][path] = op
 	prefix := slashpath.Join("/paths", jsonpointer.Escape(path), strings.ToLower(method))
 	for i, param := range op.Parameters {
-		refPref := slashpath.Join(prefix, "parameters", strconv.Itoa(i))
-		if param.Ref.String() != "" {
-			s.references.addParamRef(refPref, &param)
-		}
-		if param.Pattern != "" {
-			s.patterns.addParameterPattern(refPref, param.Pattern)
-		}
-		if len(param.Enum) > 0 {
-			s.enums.addParameterEnum(refPref, param.Enum)
-		}
-		s.analyzeItems("items", param.Items, refPref, "parameter")
-		if param.In == "body" && param.Schema != nil {
-			s.analyzeSchema("schema", param.Schema, refPref)
+		s.analyzeParameter(prefix, i, param)
+	}
+
+	if op.Responses == nil {
+		return
+	}
+
+	if op.Responses.Default != nil {
+		s.analyzeDefaultResponse(prefix, op.Responses.Default)
+	}
+
+	for k, res := range op.Responses.StatusCodeResponses {
+		s.analyzeResponse(prefix, k, res)
+	}
+}
+
+func (s *Spec) analyzeDefaultResponse(prefix string, res *spec.Response) {
+	refPref := slashpath.Join(prefix, "responses", "default")
+	if res.Ref.String() != "" {
+		s.references.addResponseRef(refPref, res)
+	}
+
+	for k, v := range res.Headers {
+		hRefPref := slashpath.Join(refPref, "headers", k)
+		s.analyzeItems("items", v.Items, hRefPref, "header")
+		if v.Pattern != "" {
+			s.patterns.addHeaderPattern(hRefPref, v.Pattern)
 		}
 	}
-	if op.Responses != nil {
-		if op.Responses.Default != nil {
-			refPref := slashpath.Join(prefix, "responses", "default")
-			if op.Responses.Default.Ref.String() != "" {
-				s.references.addResponseRef(refPref, op.Responses.Default)
-			}
-			for k, v := range op.Responses.Default.Headers {
-				hRefPref := slashpath.Join(refPref, "headers", k)
-				s.analyzeItems("items", v.Items, hRefPref, "header")
-				if v.Pattern != "" {
-					s.patterns.addHeaderPattern(hRefPref, v.Pattern)
-				}
-			}
-			if op.Responses.Default.Schema != nil {
-				s.analyzeSchema("schema", op.Responses.Default.Schema, refPref)
-			}
+
+	if res.Schema != nil {
+		s.analyzeSchema("schema", res.Schema, refPref)
+	}
+}
+
+func (s *Spec) analyzeResponse(prefix string, k int, res spec.Response) {
+	refPref := slashpath.Join(prefix, "responses", strconv.Itoa(k))
+	if res.Ref.String() != "" {
+		s.references.addResponseRef(refPref, &res) //#nosec
+	}
+
+	for k, v := range res.Headers {
+		hRefPref := slashpath.Join(refPref, "headers", k)
+		s.analyzeItems("items", v.Items, hRefPref, "header")
+		if v.Pattern != "" {
+			s.patterns.addHeaderPattern(hRefPref, v.Pattern)
 		}
-		for k, res := range op.Responses.StatusCodeResponses {
-			refPref := slashpath.Join(prefix, "responses", strconv.Itoa(k))
-			if res.Ref.String() != "" {
-				s.references.addResponseRef(refPref, &res)
-			}
-			for k, v := range res.Headers {
-				hRefPref := slashpath.Join(refPref, "headers", k)
-				s.analyzeItems("items", v.Items, hRefPref, "header")
-				if v.Pattern != "" {
-					s.patterns.addHeaderPattern(hRefPref, v.Pattern)
-				}
-				if len(v.Enum) > 0 {
-					s.enums.addHeaderEnum(hRefPref, v.Enum)
-				}
-			}
-			if res.Schema != nil {
-				s.analyzeSchema("schema", res.Schema, refPref)
-			}
+
+		if len(v.Enum) > 0 {
+			s.enums.addHeaderEnum(hRefPref, v.Enum)
 		}
 	}
+
+	if res.Schema != nil {
+		s.analyzeSchema("schema", res.Schema, refPref)
+	}
 }
 
 func (s *Spec) analyzeSchema(name string, schema *spec.Schema, prefix string) {
@@ -401,9 +430,11 @@ func (s *Spec) analyzeSchema(name string, schema *spec.Schema, prefix string) {
 	if schema.Ref.String() != "" {
 		s.references.addSchemaRef(refURI, schRef)
 	}
+
 	if schema.Pattern != "" {
 		s.patterns.addSchemaPattern(refURI, schema.Pattern)
 	}
+
 	if len(schema.Enum) > 0 {
 		s.enums.addSchemaEnum(refURI, schema.Enum)
 	}
@@ -412,52 +443,63 @@ func (s *Spec) analyzeSchema(name string, schema *spec.Schema, prefix string) {
 		v := v
 		s.analyzeSchema(k, &v, slashpath.Join(refURI, "definitions"))
 	}
+
 	for k, v := range schema.Properties {
 		v := v
 		s.analyzeSchema(k, &v, slashpath.Join(refURI, "properties"))
 	}
+
 	for k, v := range schema.PatternProperties {
 		v := v
 		// NOTE: swagger 2.0 does not support PatternProperties.
 		// However it is possible to analyze this in a schema
 		s.analyzeSchema(k, &v, slashpath.Join(refURI, "patternProperties"))
 	}
+
 	for i := range schema.AllOf {
 		v := &schema.AllOf[i]
 		s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "allOf"))
 	}
+
 	if len(schema.AllOf) > 0 {
 		s.allOfs["#"+refURI] = schRef
 	}
+
 	for i := range schema.AnyOf {
 		v := &schema.AnyOf[i]
 		// NOTE: swagger 2.0 does not support anyOf constructs.
 		// However it is possible to analyze this in a schema
 		s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "anyOf"))
 	}
+
 	for i := range schema.OneOf {
 		v := &schema.OneOf[i]
 		// NOTE: swagger 2.0 does not support oneOf constructs.
 		// However it is possible to analyze this in a schema
 		s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "oneOf"))
 	}
+
 	if schema.Not != nil {
 		// NOTE: swagger 2.0 does not support "not" constructs.
 		// However it is possible to analyze this in a schema
 		s.analyzeSchema("not", schema.Not, refURI)
 	}
+
 	if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil {
 		s.analyzeSchema("additionalProperties", schema.AdditionalProperties.Schema, refURI)
 	}
+
 	if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil {
 		// NOTE: swagger 2.0 does not support AdditionalItems.
 		// However it is possible to analyze this in a schema
 		s.analyzeSchema("additionalItems", schema.AdditionalItems.Schema, refURI)
 	}
+
 	if schema.Items != nil {
 		if schema.Items.Schema != nil {
 			s.analyzeSchema("items", schema.Items.Schema, refURI)
 		}
+
 		for i := range schema.Items.Schemas {
 			sch := &schema.Items.Schemas[i]
 			s.analyzeSchema(strconv.Itoa(i), sch, slashpath.Join(refURI, "items"))
@@ -487,8 +529,10 @@ func (s *Spec) SecurityRequirementsFor(operation *spec.Operation) [][]SecurityRe
 		if len(scheme) == 0 {
 			// append a zero object for anonymous
 			result = append(result, []SecurityRequirement{{}})
+
 			continue
 		}
+
 		var reqs []SecurityRequirement
 		for k, v := range scheme {
 			if v == nil {
@@ -496,8 +540,10 @@ func (s *Spec) SecurityRequirementsFor(operation *spec.Operation) [][]SecurityRe
 			}
 			reqs = append(reqs, SecurityRequirement{Name: k, Scopes: v})
 		}
+
 		result = append(result, reqs)
 	}
+
 	return result
 }
 
@@ -512,6 +558,7 @@ func (s *Spec) SecurityDefinitionsForRequirements(requirements []SecurityRequire
 			}
 		}
 	}
+
 	return result
 }
 
@@ -529,10 +576,12 @@ func (s *Spec) SecurityDefinitionsFor(operation *spec.Operation) map[string]spec
 				// optional requirement
 				continue
 			}
+
 			if _, ok := result[v.Name]; ok {
 				// duplicate requirement
 				continue
 			}
+
 			if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok {
 				if definition != nil {
 					result[v.Name] = *definition
@@ -540,17 +589,18 @@ func (s *Spec) SecurityDefinitionsFor(operation *spec.Operation) map[string]spec
 			}
 		}
 	}
+
 	return result
 }
 
 // ConsumesFor gets the mediatypes for the operation
 func (s *Spec) ConsumesFor(operation *spec.Operation) []string {
-
 	if len(operation.Consumes) == 0 {
 		cons := make(map[string]struct{}, len(s.spec.Consumes))
 		for _, k := range s.spec.Consumes {
 			cons[k] = struct{}{}
 		}
+
 		return s.structMapKeys(cons)
 	}
 
@@ -558,6 +608,7 @@ func (s *Spec) ConsumesFor(operation *spec.Operation) []string {
 	for _, c := range operation.Consumes {
 		cons[c] = struct{}{}
 	}
+
 	return s.structMapKeys(cons)
 }
 
@@ -568,6 +619,7 @@ func (s *Spec) ProducesFor(operation *spec.Operation) []string {
 		for _, k := range s.spec.Produces {
 			prod[k] = struct{}{}
 		}
+
 		return s.structMapKeys(prod)
 	}
 
@@ -575,6 +627,7 @@ func (s *Spec) ProducesFor(operation *spec.Operation) []string {
 	for _, c := range operation.Produces {
 		prod[c] = struct{}{}
 	}
+
 	return s.structMapKeys(prod)
 }
 
@@ -587,6 +640,7 @@ func fieldNameFromParam(param *spec.Parameter) string {
 	if nm, ok := param.Extensions.GetString("go-name"); ok {
 		return nm
 	}
+
 	return swag.ToGoName(param.Name)
 }
 
@@ -606,31 +660,38 @@ type ErrorOnParamFunc func(spec.Parameter, error) bool
 func (s *Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Parameter, callmeOnError ErrorOnParamFunc) {
 	for _, param := range parameters {
 		pr := param
-		if pr.Ref.String() != "" {
-			obj, _, err := pr.Ref.GetPointer().Get(s.spec)
-			if err != nil {
-				if callmeOnError != nil {
-					if callmeOnError(param, fmt.Errorf("invalid reference: %q", pr.Ref.String())) {
-						continue
-					}
-					break
-				} else {
-					panic(fmt.Sprintf("invalid reference: %q", pr.Ref.String()))
-				}
-			}
-			if objAsParam, ok := obj.(spec.Parameter); ok {
-				pr = objAsParam
-			} else {
-				if callmeOnError != nil {
-					if callmeOnError(param, fmt.Errorf("resolved reference is not a parameter: %q", pr.Ref.String())) {
-						continue
-					}
-					break
-				} else {
-					panic(fmt.Sprintf("resolved reference is not a parameter: %q", pr.Ref.String()))
-				}
+		if pr.Ref.String() == "" {
+			res[mapKeyFromParam(&pr)] = pr
+
+			continue
+		}
+
+		// resolve $ref
+		if callmeOnError == nil {
+			callmeOnError = func(_ spec.Parameter, err error) bool {
+				panic(err)
 			}
 		}
+
+		obj, _, err := pr.Ref.GetPointer().Get(s.spec)
+		if err != nil {
+			if callmeOnError(param, fmt.Errorf("invalid reference: %q", pr.Ref.String())) {
+				continue
+			}
+
+			break
+		}
+
+		objAsParam, ok := obj.(spec.Parameter)
+		if !ok {
+			if callmeOnError(param, fmt.Errorf("resolved reference is not a parameter: %q", pr.Ref.String())) {
+				continue
+			}
+
+			break
+		}
+
+		pr = objAsParam
 		res[mapKeyFromParam(&pr)] = pr
 	}
 }
@@ -661,31 +722,34 @@ func (s *Spec) SafeParametersFor(operationID string, callmeOnError ErrorOnParamF
 		for _, v := range bag {
 			res = append(res, v)
 		}
+
 		return res
 	}
+
 	for _, pi := range s.spec.Paths.Paths {
 		if pi.Get != nil && pi.Get.ID == operationID {
-			return gatherParams(&pi, pi.Get)
+			return gatherParams(&pi, pi.Get) //#nosec
 		}
 		if pi.Head != nil && pi.Head.ID == operationID {
-			return gatherParams(&pi, pi.Head)
+			return gatherParams(&pi, pi.Head) //#nosec
 		}
 		if pi.Options != nil && pi.Options.ID == operationID {
-			return gatherParams(&pi, pi.Options)
+			return gatherParams(&pi, pi.Options) //#nosec
 		}
 		if pi.Post != nil && pi.Post.ID == operationID {
-			return gatherParams(&pi, pi.Post)
+			return gatherParams(&pi, pi.Post) //#nosec
 		}
 		if pi.Patch != nil && pi.Patch.ID == operationID {
-			return gatherParams(&pi, pi.Patch)
+			return gatherParams(&pi, pi.Patch) //#nosec
 		}
 		if pi.Put != nil && pi.Put.ID == operationID {
-			return gatherParams(&pi, pi.Put)
+			return gatherParams(&pi, pi.Put) //#nosec
 		}
 		if pi.Delete != nil && pi.Delete.ID == operationID {
-			return gatherParams(&pi, pi.Delete)
+			return gatherParams(&pi, pi.Delete) //#nosec
 		}
 	}
+
 	return nil
 }
 
@@ -713,6 +777,7 @@ func (s *Spec) SafeParamsFor(method, path string, callmeOnError ErrorOnParamFunc
 		s.paramsAsMap(pi.Parameters, res, callmeOnError)
 		s.paramsAsMap(s.operations[strings.ToUpper(method)][path].Parameters, res, callmeOnError)
 	}
+
 	return res
 }
 
@@ -725,6 +790,7 @@ func (s *Spec) OperationForName(operationID string) (string, string, *spec.Opera
 			}
 		}
 	}
+
 	return "", "", nil, false
 }
 
@@ -732,8 +798,10 @@ func (s *Spec) OperationForName(operationID string) (string, string, *spec.Opera
 func (s *Spec) OperationFor(method, path string) (*spec.Operation, bool) {
 	if mp, ok := s.operations[strings.ToUpper(method)]; ok {
 		op, fn := mp[path]
+
 		return op, fn
 	}
+
 	return nil, false
 }
 
@@ -751,6 +819,7 @@ func (s *Spec) structMapKeys(mp map[string]struct{}) []string {
 	for k := range mp {
 		result = append(result, k)
 	}
+
 	return result
 }
 
@@ -759,6 +828,7 @@ func (s *Spec) AllPaths() map[string]spec.PathItem {
 	if s.spec == nil || s.spec.Paths == nil {
 		return nil
 	}
+
 	return s.spec.Paths.Paths
 }
 
@@ -767,6 +837,7 @@ func (s *Spec) OperationIDs() []string {
 	if len(s.operations) == 0 {
 		return nil
 	}
+
 	result := make([]string, 0, len(s.operations))
 	for method, v := range s.operations {
 		for p, o := range v {
@@ -777,6 +848,7 @@ func (s *Spec) OperationIDs() []string {
 			}
 		}
 	}
+
 	return result
 }
 
@@ -785,12 +857,14 @@ func (s *Spec) OperationMethodPaths() []string {
 	if len(s.operations) == 0 {
 		return nil
 	}
+
 	result := make([]string, 0, len(s.operations))
 	for method, v := range s.operations {
 		for p := range v {
 			result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p))
 		}
 	}
+
 	return result
 }
 
@@ -823,6 +897,7 @@ func (s *Spec) SchemasWithAllOf() (result []SchemaRef) {
 	for _, v := range s.allOfs {
 		result = append(result, v)
 	}
+
 	return
 }
 
@@ -831,6 +906,7 @@ func (s *Spec) AllDefinitions() (result []SchemaRef) {
 	for _, v := range s.allSchemas {
 		result = append(result, v)
 	}
+
 	return
 }
 
@@ -839,6 +915,7 @@ func (s *Spec) AllDefinitionReferences() (result []string) {
 	for _, v := range s.references.schemas {
 		result = append(result, v.String())
 	}
+
 	return
 }
 
@@ -847,6 +924,7 @@ func (s *Spec) AllParameterReferences() (result []string) {
 	for _, v := range s.references.parameters {
 		result = append(result, v.String())
 	}
+
 	return
 }
 
@@ -855,6 +933,7 @@ func (s *Spec) AllResponseReferences() (result []string) {
 	for _, v := range s.references.responses {
 		result = append(result, v.String())
 	}
+
 	return
 }
 
@@ -863,6 +942,7 @@ func (s *Spec) AllPathItemReferences() (result []string) {
 	for _, v := range s.references.pathItems {
 		result = append(result, v.String())
 	}
+
 	return
 }
 
@@ -874,6 +954,7 @@ func (s *Spec) AllItemsReferences() (result []string) {
 	for _, v := range s.references.items {
 		result = append(result, v.String())
 	}
+
 	return
 }
 
@@ -882,6 +963,7 @@ func (s *Spec) AllReferences() (result []string) {
 	for _, v := range s.references.allRefs {
 		result = append(result, v.String())
 	}
+
 	return
 }
 
@@ -893,11 +975,13 @@ func (s *Spec) AllRefs() (result []spec.Ref) {
 		if a == "" {
 			continue
 		}
+
 		if _, ok := set[a]; !ok {
 			set[a] = struct{}{}
 			result = append(result, v)
 		}
 	}
+
 	return
 }
 
@@ -906,6 +990,7 @@ func cloneStringMap(source map[string]string) map[string]string {
 	for k, v := range source {
 		res[k] = v
 	}
+
 	return res
 }
 
@@ -914,6 +999,7 @@ func cloneEnumMap(source map[string][]interface{}) map[string][]interface{} {
 	for k, v := range source {
 		res[k] = v
 	}
+
 	return res
 }