mirror of
https://github.com/grafana/loki.git
synced 2026-03-13 09:33:58 +08:00
d54e0871d4
This PR updates the Prometheus dependency in Loki and Promtail. The PR is required so that we can also update Grafana Agent to the latest Prometheus. Unfortunately, Promtail and Loki share the same go.mod file.
328 lines
7.9 KiB
Go
328 lines
7.9 KiB
Go
// Copyright 2015 go-swagger maintainers
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package strfmt
|
|
|
|
import (
|
|
"encoding"
|
|
stderrors "errors"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/go-openapi/errors"
|
|
"github.com/mitchellh/mapstructure"
|
|
)
|
|
|
|
// Default is the default formats registry
|
|
var Default = NewSeededFormats(nil, nil)
|
|
|
|
// Validator represents a validator for a string format.
|
|
type Validator func(string) bool
|
|
|
|
// Format represents a string format.
|
|
//
|
|
// All implementations of Format provide a string representation and text
|
|
// marshaling/unmarshaling interface to be used by encoders (e.g. encoding/json).
|
|
type Format interface {
|
|
String() string
|
|
encoding.TextMarshaler
|
|
encoding.TextUnmarshaler
|
|
}
|
|
|
|
// Registry is a registry of string formats, with a validation method.
|
|
type Registry interface {
|
|
Add(string, Format, Validator) bool
|
|
DelByName(string) bool
|
|
GetType(string) (reflect.Type, bool)
|
|
ContainsName(string) bool
|
|
Validates(string, string) bool
|
|
Parse(string, string) (interface{}, error)
|
|
MapStructureHookFunc() mapstructure.DecodeHookFunc
|
|
}
|
|
|
|
type knownFormat struct {
|
|
Name string
|
|
OrigName string
|
|
Type reflect.Type
|
|
Validator Validator
|
|
}
|
|
|
|
// NameNormalizer is a function that normalizes a format name.
|
|
type NameNormalizer func(string) string
|
|
|
|
// DefaultNameNormalizer removes all dashes
|
|
func DefaultNameNormalizer(name string) string {
|
|
return strings.ReplaceAll(name, "-", "")
|
|
}
|
|
|
|
type defaultFormats struct {
|
|
sync.Mutex
|
|
data []knownFormat
|
|
normalizeName NameNormalizer
|
|
}
|
|
|
|
// NewFormats creates a new formats registry seeded with the values from the default
|
|
func NewFormats() Registry {
|
|
//nolint:forcetypeassert
|
|
return NewSeededFormats(Default.(*defaultFormats).data, nil)
|
|
}
|
|
|
|
// NewSeededFormats creates a new formats registry
|
|
func NewSeededFormats(seeds []knownFormat, normalizer NameNormalizer) Registry {
|
|
if normalizer == nil {
|
|
normalizer = DefaultNameNormalizer
|
|
}
|
|
// copy here, don't modify original
|
|
d := append([]knownFormat(nil), seeds...)
|
|
return &defaultFormats{
|
|
data: d,
|
|
normalizeName: normalizer,
|
|
}
|
|
}
|
|
|
|
// MapStructureHookFunc is a decode hook function for mapstructure
|
|
func (f *defaultFormats) MapStructureHookFunc() mapstructure.DecodeHookFunc {
|
|
return func(from reflect.Type, to reflect.Type, obj interface{}) (interface{}, error) {
|
|
if from.Kind() != reflect.String {
|
|
return obj, nil
|
|
}
|
|
data, ok := obj.(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("failed to cast %+v to string", obj)
|
|
}
|
|
|
|
for _, v := range f.data {
|
|
tpe, _ := f.GetType(v.Name)
|
|
if to == tpe {
|
|
switch v.Name {
|
|
case "date":
|
|
d, err := time.ParseInLocation(RFC3339FullDate, data, DefaultTimeLocation)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return Date(d), nil
|
|
case "datetime":
|
|
input := data
|
|
if len(input) == 0 {
|
|
return nil, stderrors.New("empty string is an invalid datetime format")
|
|
}
|
|
return ParseDateTime(input)
|
|
case "duration":
|
|
dur, err := ParseDuration(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return Duration(dur), nil
|
|
case "uri":
|
|
return URI(data), nil
|
|
case "email":
|
|
return Email(data), nil
|
|
case "uuid":
|
|
return UUID(data), nil
|
|
case "uuid3":
|
|
return UUID3(data), nil
|
|
case "uuid4":
|
|
return UUID4(data), nil
|
|
case "uuid5":
|
|
return UUID5(data), nil
|
|
case "hostname":
|
|
return Hostname(data), nil
|
|
case "ipv4":
|
|
return IPv4(data), nil
|
|
case "ipv6":
|
|
return IPv6(data), nil
|
|
case "cidr":
|
|
return CIDR(data), nil
|
|
case "mac":
|
|
return MAC(data), nil
|
|
case "isbn":
|
|
return ISBN(data), nil
|
|
case "isbn10":
|
|
return ISBN10(data), nil
|
|
case "isbn13":
|
|
return ISBN13(data), nil
|
|
case "creditcard":
|
|
return CreditCard(data), nil
|
|
case "ssn":
|
|
return SSN(data), nil
|
|
case "hexcolor":
|
|
return HexColor(data), nil
|
|
case "rgbcolor":
|
|
return RGBColor(data), nil
|
|
case "byte":
|
|
return Base64(data), nil
|
|
case "password":
|
|
return Password(data), nil
|
|
case "ulid":
|
|
ulid, err := ParseULID(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return ulid, nil
|
|
default:
|
|
return nil, errors.InvalidTypeName(v.Name)
|
|
}
|
|
}
|
|
}
|
|
return data, nil
|
|
}
|
|
}
|
|
|
|
// Add adds a new format, return true if this was a new item instead of a replacement
|
|
func (f *defaultFormats) Add(name string, strfmt Format, validator Validator) bool {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
|
|
nme := f.normalizeName(name)
|
|
|
|
tpe := reflect.TypeOf(strfmt)
|
|
if tpe.Kind() == reflect.Ptr {
|
|
tpe = tpe.Elem()
|
|
}
|
|
|
|
for i := range f.data {
|
|
v := &f.data[i]
|
|
if v.Name == nme {
|
|
v.Type = tpe
|
|
v.Validator = validator
|
|
return false
|
|
}
|
|
}
|
|
|
|
// turns out it's new after all
|
|
f.data = append(f.data, knownFormat{Name: nme, OrigName: name, Type: tpe, Validator: validator})
|
|
return true
|
|
}
|
|
|
|
// GetType gets the type for the specified name
|
|
func (f *defaultFormats) GetType(name string) (reflect.Type, bool) {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
nme := f.normalizeName(name)
|
|
for _, v := range f.data {
|
|
if v.Name == nme {
|
|
return v.Type, true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// DelByName removes the format by the specified name, returns true when an item was actually removed
|
|
func (f *defaultFormats) DelByName(name string) bool {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
|
|
nme := f.normalizeName(name)
|
|
|
|
for i, v := range f.data {
|
|
if v.Name == nme {
|
|
f.data[i] = knownFormat{} // release
|
|
f.data = append(f.data[:i], f.data[i+1:]...)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// DelByFormat removes the specified format, returns true when an item was actually removed
|
|
func (f *defaultFormats) DelByFormat(strfmt Format) bool {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
|
|
tpe := reflect.TypeOf(strfmt)
|
|
if tpe.Kind() == reflect.Ptr {
|
|
tpe = tpe.Elem()
|
|
}
|
|
|
|
for i, v := range f.data {
|
|
if v.Type == tpe {
|
|
f.data[i] = knownFormat{} // release
|
|
f.data = append(f.data[:i], f.data[i+1:]...)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ContainsName returns true if this registry contains the specified name
|
|
func (f *defaultFormats) ContainsName(name string) bool {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
nme := f.normalizeName(name)
|
|
for _, v := range f.data {
|
|
if v.Name == nme {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ContainsFormat returns true if this registry contains the specified format
|
|
func (f *defaultFormats) ContainsFormat(strfmt Format) bool {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
tpe := reflect.TypeOf(strfmt)
|
|
if tpe.Kind() == reflect.Ptr {
|
|
tpe = tpe.Elem()
|
|
}
|
|
|
|
for _, v := range f.data {
|
|
if v.Type == tpe {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Validates passed data against format.
|
|
//
|
|
// Note that the format name is automatically normalized, e.g. one may
|
|
// use "date-time" to use the "datetime" format validator.
|
|
func (f *defaultFormats) Validates(name, data string) bool {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
nme := f.normalizeName(name)
|
|
for _, v := range f.data {
|
|
if v.Name == nme {
|
|
return v.Validator(data)
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Parse a string into the appropriate format representation type.
|
|
//
|
|
// E.g. parsing a string a "date" will return a Date type.
|
|
func (f *defaultFormats) Parse(name, data string) (interface{}, error) {
|
|
f.Lock()
|
|
defer f.Unlock()
|
|
nme := f.normalizeName(name)
|
|
for _, v := range f.data {
|
|
if v.Name == nme {
|
|
nw := reflect.New(v.Type).Interface()
|
|
if dec, ok := nw.(encoding.TextUnmarshaler); ok {
|
|
if err := dec.UnmarshalText([]byte(data)); err != nil {
|
|
return nil, err
|
|
}
|
|
return nw, nil
|
|
}
|
|
return nil, errors.InvalidTypeName(name)
|
|
}
|
|
}
|
|
return nil, errors.InvalidTypeName(name)
|
|
}
|